Wie Sie Ihrem Agenten mit Weaviate Speicher hinzufügen (Schritt für Schritt)

Weaviate Fügen Sie Ihrem Agenten Gedächtnis Hinzu: Ein Praktischer 2500-Wort-Leitfaden

Wenn Sie möchten, dass Ihr intelligenter Agent sich tatsächlich an den Kontext zwischen den Gesprächen erinnert, müssen Sie weaviate add memory to your agent auf die richtige Weise verwenden, indem Sie die Vektorsuche nutzen, um frühere Interaktionen zu speichern und abzurufen. Wir erstellen nicht einfach einige Code-Schnipsel in einer Datenbank; wir bauen ein echtes Wissensgraph mit einer semantischen Suche, die Ihren Agenten wachsam hält.

Was Sie Bauen und Warum Es Wichtig Ist

Wir erstellen einen Agenten, der Weaviate für den Gedächtnisspeicher verwendet, damit er bedeutungsvolle Gespräche führen kann, nicht nur zustandslose Fragen und Antworten. Vergessen Sie diese oberflächlichen Chatbot-Demonstrationen, die jede Frage zurücksetzen – hier geht es um eine kontextuelle Persistenz, die Ihre Benutzer tatsächlich erleben werden.

Voraussetzungen

• Python 3.11+
• Weaviate Community Edition (neueste stabile Version, ich habe 1.19.0 verwendet)
• Pip-Pakete: weaviate-client>=4.16.0, requests, dotenv
• OpenAI API-Schlüssel oder ein anderer API-Schlüssel für Einbettungsmodelle (GPT-4, Cohere oder Huggingface)
• Installiertes Docker (optional, aber empfohlen, um Weaviate lokal auszuführen)
• Grundverständnis von Vektordatenbanken und der Generierung von Einbettungen

Schnelle Statistiken über Weaviate

Metrik	Wert
GitHub-Sterne	15.839
Forks	1.227
Offene Probleme	582 (Stand 20. März 2026)
Lizenz	BSD-3-Clause
Letzte Aktualisierung	20. März 2026

Diese Zahlen zeigen, dass Weaviate ausgereift, aber weiterhin aktiv ist; Sie werden nicht warten müssen, während Sie auf eine veraltete Bibliothek stoßen.

Schritt für Schritt: Weaviate Fügen Sie Ihrem Agenten Gedächtnis Hinzu

Schritt 1: Weaviate-Server Einrichten

# Führen Sie Weaviate mit Docker für schnelle lokale Tests aus
docker run -d \
 -p 8080:8080 \
 -e AUTH_ANONYMOUS_ACCESS_ENABLED=true \
 -e QUERY_DEFAULTS_LIMIT=20 \
 -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
 -v $(pwd)/weaviate_data:/var/lib/weaviate \
 semitechnologies/weaviate:latest

Warum ist das wichtig: Weaviate unterstützt hier die Persistenz und anonymen Zugriff standardmäßig, was die lokale Entwicklung erleichtert. Durch die Einstellung QUERY_DEFAULTS_LIMIT=20 vermeiden Sie, auf die lästigen 10-Ergebnisse-Limits bei Abfragen zu stoßen, was selbst erfahrene Entwickler frustrieren kann. Denken Sie daran, wenn Sie keinen anonymen Zugriff wollen, richten Sie API-Schlüssel ein. Aber für Tests ist das akzeptabel.

Häufige Fehler: Wenn der Container abstürzt, überprüfen Sie, ob der Port 8080 frei ist. Manchmal wird er von Docker Desktop oder vorherigen Containern belegt. Wenn Sie die Einbettungen schneller generieren, als Weaviate mit der Persistenz umgehen kann (selten lokal), erwarten Sie einen Rückstand.

Schritt 2: Ein Schema für das Gedächtnis Ihres Agenten Definieren

import weaviate

client = weaviate.Client("http://localhost:8080")

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Speichert einen einzigartigen Gedächtnissegment für den Agenten",
 "properties": [
 {
 "name": "text",
 "dataType": ["text"],
 "description": "Der textuelle Inhalt des Gedächtnisses."
 },
 {
 "name": "embedding",
 "dataType": ["number[]"],
 "description": "Vektorielle Einbettungsdarstellung."
 },
 {
 "name": "timestamp",
 "dataType": ["date"],
 "description": "Wann das Gedächtnis gespeichert wurde."
 }
 ],
 "vectorizer": "none" # Wir werden die Einbettungen selbst injizieren
 }
 ]
}

client.schema.delete_all() # Saubere Tabelle
client.schema.create(schema)

Warum kein Vektorisierer? Der häufigste Fehler, den Anfänger machen, ist, blind die Standardtextvektorisierer von Weaviate zu verwenden. Das ist in Ordnung für einfache Textsuche, aber wenn Sie eine strenge Kontrolle über Ihr Einbettungsmodell (z.B. OpenAI, Cohere) wünschen, müssen Sie die Vektoren selbst hochladen. Dies vermeidet Verwirrung durch konkurrierende Tutorials, die die eingebetteten Vektorisierer von Weaviate für Agenten missbrauchen.

Das Löschen des Schemas vor der Erstellung zwingt zu einem Neuanfang, was Sie vor seltsamen Fehlern wie „Das Schema existiert bereits“ bewahrt. Sicher, das löscht Daten, aber es ist lokale Entwicklung.

Schritt 3: Generieren und Hochladen der Gedächtniseinbettungen

import os
import requests
from datetime import datetime

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

def get_openai_embedding(text):
 resp = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"}
 )
 resp.raise_for_status()
 return resp.json()["data"][0]["embedding"]

def add_memory_entry(client, text):
 embedding = get_openai_embedding(text)
 memory_obj = {
 "text": text,
 "embedding": embedding,
 "timestamp": datetime.utcnow().isoformat()
 }
 client.data_object.create(memory_obj, "MemoryEntry", vector=embedding)

# Beispielnutzung
add_memory_entry(client, "Ich erinnere mich, dass der Himmel blau ist.")
add_memory_entry(client, "Der Sinn des Lebens ist 42.")

Warum die Einbettungen selbst generieren? Weil es extrem wertvoll ist, die Generierung von Einbettungen und die Speicherung von Vektoren zu entkoppeln. Sie müssen möglicherweise später Ihr Einbettungsmodell ändern oder Vektoren aus verschiedenen Quellen aggregieren. Diese anderen Tutorials vermischen alles und Sie stecken fest.

Häufiger Fehler hier: Vergessen, die Einbettung als Vektorparameter vector=embedding im data_object.create-Aufruf zu übergeben. Wenn Sie das vergessen, versucht Weaviate, es automatisch zu vektorisieren (und wird scheitern, weil wir vectorizer: none eingestellt haben).

Schritt 4: Gedächtnis mit einer Semantischen Suche Abfragen

def query_memory(client, question, top_k=3):
 question_embedding = get_openai_embedding(question)
 near_vector = {"vector": question_embedding}
 response = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector)\
 .with_limit(top_k)\
 .do()
 results = response.get("data", {}).get("Get", {}).get("MemoryEntry", [])
 return results

# Testen Sie es
results = query_memory(client, "Welche Farbe hat der Himmel?")
for res in results:
 print(f"Gedächtnis: {res['text']} (gespeichert am {res['timestamp']})")

Warum die semantische Suche? Die Suche nach Schlüsselwörtern im Gedächtnis ist nutzlos für Agenten, die mehrstufige Gespräche mit nuancierten Anfragen führen müssen. Die wahre Magie liegt in der Einbettungssuche für „ähnliche Gedanken“, ohne exakte Übereinstimmung von Schlüsselwörtern.

Der Schlüssel zu dieser Funktionalität ist, wie Sie diese Anfragen dynamisch zur Laufzeit mischen und zuordnen, um Ihren Agenten im Kontext wachsam zu halten, ohne von irrelevanten Erinnerungen überwältigt zu werden.

Schritt 5: Verbinden Sie Ihren Agenten mit dem Weaviate-Gedächtnis

class MemoryAgent:
 def __init__(self, weaviate_client):
 self.client = weaviate_client

 def remember(self, text):
 add_memory_entry(self.client, text)

 def recall(self, question):
 return query_memory(self.client, question, top_k=5)

 def chat(self, question):
 memories = self.recall(question)
 # Einfache Verkettung für das Prompt — ersetzen Sie es durch Ihr Prompt-Modell
 prompt_context = "\n".join([m["text"] for m in memories])
 prompt = f"Kontext:\n{prompt_context}\n\nFrage: {question}\nAntwort:"
 
 # Senden Sie das Prompt an das LLM (nicht hier abgedeckt)
 # Simulation:
 return f"Simulation der Antwort basierend auf den Erinnerungen:\n{prompt}"

agent = MemoryAgent(client)
agent.remember("Der Agent wurde am 20. März 2026 erstellt.")
agent.remember("Python ist die anerkannte Programmiersprache für KI.")

print(agent.chat("Wann wurde der Agent erstellt?"))

Warum dieses Design? Die Trennung der Gedächtnisverwaltung von der „Chat“-Logik des Agenten ist entscheidend. Ich hasse eng gekoppelte Codes, bei denen die Kontextverwaltung Ihren Generierungsaufruf unordentlich macht. Mit diesem Modell verfolgen, speichern und erinnern Sie unabhängig. Wenn Sie zu einem besseren LLM wechseln oder Caching hinzufügen möchten, ist das trivial.

Die Fallstricke, Die Sie In Anderen Tutorials Nicht Hören Werden

1. Verwirrung über das Schema. Viele Tutorials gehen schnell über die Gestaltung des Schemas hinweg, aber wenn Ihr Schema falsch ist, sind Ihre Vektoren und Metadaten nutzlos. Sie werden es bereuen, wenn Sie keine Zeitstempel oder Metadaten wie Benutzer-IDs zur Filterung Ihres Speichers eingeplant haben.
2. Die Kosten für Incorporations zählen. Die Incorporations von OpenAI sind nicht kostenlos. Wenn Sie Tausende von Erinnerungen hinzufügen, erwarten Sie eine Rechnung. Gruppieren Sie Ihre Generierung, um die Kosten zu senken, und cachen Sie die Incorporations aggressiv.
3. Übermäßiger Speicher tötet die Leistung. Eine Datenbank mit Vektoren mit Zehntausenden von Einträgen abzufragen? Sie werden Spitzen in der Latenz und rauschende Rückrufwerte sehen. Regelmäßige Bereinigung ist notwendig – eine harte, aber unvermeidbare Realität.
4. Inkompatibilität von Vektor-Dimensionen. Wenn Sie versehentlich Incorporation-Modelle oder -Versionen austauschen, stimmen Ihre gespeicherten Vektoren nicht mit den Anfrage-Vektoren überein. Sie werden keine Ergebnisse oder irreführende Übereinstimmungen erhalten. Fixieren Sie immer die Version Ihres Incorporation-Modells in Ihrer Pipeline.
5. Die Konsistenz der Daten ist ein Problem. Ohne Transaktionsunterstützung können partielle Schreib- oder Aktualisierungen Gedächtnisse ohne Kontext hinterlassen. Dieser subtile Fehler kann Sie in der Produktion verfolgen, insbesondere wenn Sie die Erinnerungen aktualisieren.

Vollständiges Funktionsbeispiel

import os
import requests
from datetime import datetime
import weaviate

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
WEAVIATE_URL = "http://localhost:8080"

def get_openai_embedding(text):
 r = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"},
 )
 r.raise_for_status()
 return r.json()["data"][0]["embedding"]

client = weaviate.Client(WEAVIATE_URL)
client.schema.delete_all()

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Speichert das Gedächtnis des Agenten",
 "properties": [
 {"name": "text", "dataType": ["text"]},
 {"name": "embedding", "dataType": ["number[]"]},
 {"name": "timestamp", "dataType": ["date"]}
 ],
 "vectorizer": "none"
 }
 ]
}
client.schema.create(schema)

def add_memory(text):
 embedding = get_openai_embedding(text)
 data = {"text": text, "embedding": embedding, "timestamp": datetime.utcnow().isoformat()}
 client.data_object.create(data, "MemoryEntry", vector=embedding)

def query_memories(question, top_k=5):
 q_emb = get_openai_embedding(question)
 near_vector = {"vector": q_emb}
 res = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector).with_limit(top_k).do()
 return res.get("data", {}).get("Get", {}).get("MemoryEntry", [])

class Agent:
 def __init__(self, client):
 self.client = client

 def remember(self, text):
 add_memory(text)

 def chat(self, question):
 memories = query_memories(question)
 context = "\n".join([m["text"] for m in memories])
 prompt = f"Kontext:\n{context}\n\nFrage: {question}\nAntwort:"
 # Fiktive Antwort
 return prompt

agent = Agent(client)
agent.remember("Der Himmel ist blau.")
agent.remember("Wasser kocht bei 100 Grad Celsius.")
print(agent.chat("Wie ist die Farbe des Himmels?"))

Was als Nächstes tun?

Nachdem Sie die Integration von Weaviate-Speichern gemeistert haben, ist Ihr nächster konkreter Schritt der Aufbau einer Pipeline für Speichergröße und Aktualisierung. Das bedeutet, dass Sie regelmäßig bewerten, welche Erinnerungen veraltet oder nicht relevant sind, und diese löschen oder aktualisieren. Wenn Sie den Speicher unkontrolliert wachsen lassen, werden die Antworten Ihres Agenten langsamer und inkohärent.

Überlegen Sie, ein zeitbasiertes Veralterungssystem oder eine Einstufung der Wichtigkeit von Erinnerungen zu implementieren, um Ihre Datenbank schlank zu halten. Dies wird den Fokus des Agenten auf das Wesentliche verfeinern.

FAQ

Warum sollte ich den integrierten Vektorisierer von Weaviate deaktivieren?

Integrierte Vektorisierer eignen sich für einfache Demos, binden Sie jedoch an deren spezifisches Modell und machen Updates unmöglich. Sie möchten Ihre eigenen von Modellen wie dem text-embedding-ada-002 von OpenAI generierten Embeddings injizieren, um die Qualität der Vektoren und die API-Kosten zu kontrollieren.

Was tun, wenn meine Anfragen keine Ergebnisse zurückgeben?

Überprüfen Sie zunächst, ob die Dimensionen Ihrer Embeddings übereinstimmen. Die embeddings ada-002 von OpenAI sind Vektoren mit 1536 Dimensionen. Wenn Ihre gespeicherten Vektoren und Ihre Anfrage-Vektoren in der Dimension abweichen, gibt die Ähnlichkeitssuche nichts zurück. Stellen Sie auch sicher, dass der Vektorisierer Ihres Schemas auf ‘none’ eingestellt ist und dass Sie beim Erstellen von Objekten explizit Ihre eigenen Vektoren senden.

Wie mit den Kosten von Embeddings bei Tausenden von Erinnerungen umgehen?

Batchen Sie Ihre Daten in Embeddings anstelle von Einzelaufrufen und cachen Sie die Embeddings auf Disk oder Redis. Die Vorverarbeitung neuer Informationen offline kann ebenfalls hilfreich sein. Seien Sie auch strategisch, was Sie speichern – speichern Sie Zusammenfassungen, keine vollständigen Gespräche. Schließlich erkunden Sie kostengünstigere Open-Source-Modelle, aber achten Sie auf die Genauigkeit.

Empfehlungen für Entwickler-Personas

Entwicklertyp	Empfohlene nächste Schritte
KI-Forscher	Integrieren Sie Weaviate mit benutzerdefinierten Transformator-Embeddings und erkunden Sie die hybride Suche, die Text und Vektorsimilarität kombiniert.
Backend-Entwickler	Implementieren Sie das Lebenszyklusmanagement für Speicher mit automatischer Größe, Indexneuaufbau und Nachhaltigkeitsverfolgung.
Full-Stack-Entwickler	Bauen Sie ein UI-Dashboard, um die Gedächtniseinträge zu visualisieren und zu verwalten, und verbinden Sie Weaviate-Speicher mit Ihrem Frontend-Chat-Interface.

Datenstand vom 21. März 2026. Quellen: https://github.com/weaviate/weaviate, https://weaviate.io/product/integrations/mem0

Verwandte Artikel

• Verbessern Sie LLM mit zuverlässigen Wissensgraphen: Qinggang Zhangs Innovation
• Entriegeln Sie Ihre Marke: Gestalten Sie das perfekte Logo eines Convolutional Neural Network
• Warum die Architektur von KI-Agenten verwenden?

🕒 Published: March 30, 2026