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

Weaviate Speicher hinzufügen zu Ihrem Agenten: Ein 2500-Wörter-Nichts-als-Tutorial

Wenn Sie möchten, dass Ihr intelligenter Agent tatsächlich den Kontext zwischen Gesprächen erinnert, müssen Sie weaviate add memory to your agent auf die richtige Art und Weise verwenden, indem Sie eine Vektorsuche nutzen, um frühere Interaktionen zu speichern und abzurufen. Wir werfen nicht einfach Schnipsel in irgendeine Datenbank; wir bauen ein tatsächliches Wissensgraph, das mit semantischer Suche angereichert ist und Ihren Agenten scharf hält.

Was Sie bauen und warum es wichtig ist

Wir bauen einen Agenten, der Weaviate für die Speicherungen nutzt, damit er bedeutungsvolle Gespräche führen kann, nicht nur zustandslose Fragen und Antworten. Vergessen Sie die flachen Chatbot-Demonstrationen, die jede Frage zurücksetzen – hier geht es um kontextuelle Beständigkeit, die Ihre Benutzer tatsächlich spüren 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 einen API-Schlüssel für ein anderes Einbettungsmodell (GPT-4, Cohere oder Huggingface)
• Docker installiert (optional, aber empfohlen für das lokale Ausführen von Weaviate)
• Grundlegendes Verständnis von Vektordatenbanken und der Generierung von Einbettungen

Kurze Statistiken zu Weaviate

Metrik	Wert
GitHub Sterne	15.839
Forks	1.227
Offene Issues	582 (Stand 20. März 2026)
Lizenz	BSD-3-Clause
Letztes Update	20. März 2026

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

Schritt-für-Schritt: Weaviate Speicher hinzufügen zu Ihrem Agenten

Schritt 1: Weaviate-Server einrichten

# Weaviate mit Docker für schnelle lokale Tests ausführen
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 das wichtig ist: Weaviate unterstützt standardmäßig Persistenz und anonymen Zugriff, was die lokale Entwicklung erleichtert. Die Einstellung QUERY_DEFAULTS_LIMIT=20 verhindert, dass Sie auf lästige 10-Ergebnis-Grenzen bei Abfragen stoßen, die selbst erfahrene Entwickler ärgern. Denken Sie daran, wenn Sie keinen anonymen Zugriff möchten, richten Sie API-Schlüssel ein. Aber für Tests ist das in Ordnung.

Häufige Fehler: Wenn der Container abstürzt, überprüfen Sie, ob der Port 8080 frei ist. Manchmal belegt Docker Desktop oder frühere Container ihn. Außerdem, wenn Sie Einbettungen schneller pumpen, als Weaviate’s Persistenz mithalten kann (selten lokal), erwarten Sie Lag.

Schritt 2: Ein Schema für den Speicher Ihres Agenten definieren

import weaviate

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

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Speichert ein einzelnes Gedächtnissegment für den Agenten",
 "properties": [
 {
 "name": "text",
 "dataType": ["text"],
 "description": "Der Textinhalt des Gedächtnisses."
 },
 {
 "name": "embedding",
 "dataType": ["number[]"],
 "description": "Vektoreinbettungsdarstellung."
 },
 {
 "name": "timestamp",
 "dataType": ["date"],
 "description": "Wann das Gedächtnis gespeichert wurde."
 }
 ],
 "vectorizer": "none" # Wir werden die Einbettungen selbst einfügen
 }
 ]
}

client.schema.delete_all() # Sauberer Start
client.schema.create(schema)

Warum kein Vektorisierer? Der Hauptfehler, den Anfänger machen, ist, blind Weaviate’s Standardtextvektorisierer zu verwenden. Es ist in Ordnung für einfache Textsuche, aber wenn Sie eine enge Kontrolle über Ihr Einbettungsmodell (z. B. OpenAI, Cohere) haben möchten, müssen Sie die Vektoren selbst hochladen. Dies beseitigt Verwirrung durch konkurrierende Tutorials, die die ON-BOARD-Vektorisierer von Weaviate überbeanspruchen.

Das Löschen des Schemas vor dem Erstellen zwingt einen frischen Start, was Sie vor merkwürdigen „Schema existiert bereits“-Fehlern bewahrt. Sicher, es löscht Daten, aber das ist lokale Entwicklung.

Schritt 3: Gedächtniseinbettungen generieren und hochladen

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)

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

Warum Einbettungen selbst generieren? Weil es unglaublich wertvoll ist, die Generierung von Einbettungen und die Vektorspeicherung zu entkoppeln. Sie könnten später Ihr Einbettungsmodell wechseln oder Vektoren aus verschiedenen Quellen aggregieren müssen. Diese anderen Tutorials vermischen das, und Sie werden festgefahren.

Ein häufiger Fehler hier: das Vergessen, die Einbettung als Vektorparameter vector=embedding im Aufruf data_object.create zu übergeben. Wenn Sie dies überspringen, wird Weaviate versuchen, es automatisch zu vektorisieren (und wird scheitern, weil wir vectorizer: none gesetzt haben).

Schritt 4: Gedächtnis mit semantischer 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 semantische Suche? Die Stichwortsuche im Gedächtnis ist nutzlos für Agenten, die mehrteilige Gespräche mit nuancierten Abfragen führen müssen. Die echte Magie liegt in der Einbettungssuche nach „ähnlichen Gedanken“, ohne genaue Stichwortüberschneidung.

Das herausragende Merkmal ist, wie Sie diese Abfragen dynamisch zur Laufzeit kombinieren und anpassen, um Ihren Agenten kontextbewusst zu halten, ohne sich an irrelevanten Erinnerungen zu ersticken.

Schritt 5: Ihren Agenten mit Weaviate-Speicher verbinden

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 den Prompt – ersetzen Sie dies durch Ihre Prompt-Vorlage
 prompt_context = "\n".join([m["text"] for m in memories])
 prompt = f"Kontext:\n{prompt_context}\n\nFrage: {question}\nAntwort:"
 
 # Prompt an LLM senden (hier nicht behandelt)
 # Simulieren:
 return f"Simulierte Antwort basierend auf 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 des Speichermanagements von der „Chat“-Logik des Agenten ist entscheidend. Ich hasse eng gekoppelte Codes, bei denen die Verwaltung des Kontexts Ihren Generierungsaufruf zu einem verschachtelten Chaos macht. Mit diesem Muster verfolgen, speichern und rufen Sie unabhängig ab. Wenn Sie ein besseres LLM einfügen oder Caching hinzufügen möchten, ist das trivial.

Die Stolpersteine, die Sie in anderen Tutorials nicht hören werden

1. Schema-Verwirrung. Viele Tutorials blenden die Schema-Entwicklung aus, aber wenn Ihr Schema nicht stimmt, sind Ihre Vektoren und Metadaten Müll. Sie werden es bereuen, nicht für Zeitstempel oder Metadaten wie Benutzer-IDs zu planen, um Ihr Gedächtnis zu filtern.
2. Kosten für Einbettungen sind wichtig. OpenAI-Einbettungen sind nicht kostenlos. Wenn Sie Tausende von Erinnerungen hinzufügen, erwarten Sie eine Rechnung. Batchen Sie Ihre Generierung, um Kosten zu sparen und Einbettungen aggressiv zwischenzuspeichern.
3. Speicheraufblähung tötet die Leistung. Abfragen einer Vektordatenbank mit Zehntausenden von Einträgen? Sie werden Latenzspitzen und unangenehme Abrufsergebnisse sehen. Regelmäßiges Bereinigen ist erforderlich – eine harte, aber unvermeidliche Realität.
4. Mismatch der Vektordimensionen. Wenn Sie versehentlich Einbettungsmodelle oder -versionen vertauschen, passen Ihre gespeicherten Vektoren nicht zu den Abfragevektoren. Sie erhalten keine Ergebnisse oder irreführende Übereinstimmungen. Fixieren Sie immer die Version Ihres Einbettungsmodells in Ihrer Pipeline.
5. Datenkonsistenz ist mühsam. Ohne Transaktionssupport können teilweise Schreibvorgänge oder Aktualisierungen verweiste Erinnerungen ohne Kontext hinterlassen. Dieser subtile Fehler kann Sie in der Produktion verfolgen, insbesondere wenn Sie Erinnerungen aktualisieren.

Vollständiges funktionierendes Beispiel

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:"
 # Dummy answer
 return prompt

agent = Agent(client)
agent.remember("Der Himmel ist blau.")
agent.remember("Wasser kocht bei 100 Grad Celsius.")
print(agent.chat("Welche Farbe hat der Himmel?"))

Was kommt als Nächstes?

Nachdem Sie die Integration des Weaviate-Gedächtnisses gemeistert haben, besteht Ihr nächster konkreter Schritt darin, eine Pipeline zum Beschneiden und Aktualisieren des Gedächtnisses zu erstellen. Das bedeutet, regelmäßig zu bewerten, welche Erinnerungen veraltet oder irrelevant sind, und diese zu löschen oder zu aktualisieren. Wenn Sie das Gedächtnis unkontrolliert wachsen lassen, werden die Antworten Ihres Agenten langsamer und inkonsistent.

Erwägen Sie die Implementierung eines zeitbasierten Abbaus oder einer Bewertung der Wichtigkeit von Erinnerungen, um Ihre Datenbank schlank zu halten. Dies wird den Fokus des Agenten auf das lenken, was tatsächlich wichtig ist.

FAQ

Warum sollte ich den integrierten Vektorisierer von Weaviate deaktivieren?

Integrierte Vektorisierer sind für einfache Demos in Ordnung, binden Sie jedoch an deren spezifisches Einbettungsmodell und machen Aktualisierungen unmöglich. Sie möchten Ihre eigenen Einbettungen verwenden, die von Modellen wie OpenAIs text-embedding-ada-002 erzeugt werden, damit Sie die Vektorqualität und die API-Kosten kontrollieren können.

Was mache ich, wenn meine Abfragen null Ergebnisse zurückgeben?

Überprüfen Sie zunächst, ob Ihre Einbettungsdimensionen übereinstimmen. OpenAIs ada-002-Einbettungen sind 1536-dimensionale Vektoren. Wenn sich die Dimensionen Ihrer gespeicherten Vektoren und Abfragevektoren unterscheiden, gibt die Ähnlichkeitssuche nichts zurück. Überprüfen Sie auch, ob der Vektorisierer Ihres Schemas als ‘none’ eingestellt ist und dass Sie beim Erstellen von Objekten explizit Ihre eigenen Vektoren senden.

Wie manage ich die Kosten für Einbettungen mit Tausenden von Gedächtniseinträgen?

Verarbeiten Sie Ihre Daten in Chargen anstelle von einmaligen Aufrufen und cachen Sie Einbettungen auf der Festplatte oder Redis. Auch eine Offline-Vorverarbeitung neuer Informationen kann hilfreich sein. Seien Sie außerdem strategisch, was Sie speichern — speichern Sie Zusammenfassungen, nicht vollständige Gespräche. Schließlich sollten Sie günstigere Open-Source-Modelle erkunden, aber seien Sie vorsichtig bei der Genauigkeit.

Empfehlungen für Entwickler

Entwicklertyp	Empfohlene nächste Schritte
KI-Forscher	Integrieren Sie Weaviate mit benutzerdefinierten Transformer-Einbettungen und erkunden Sie hybride Suchlösungen, die Text- und Vektorähnlichkeit kombinieren.
Backend-Entwickler	Implementieren Sie das Lebenszyklusmanagement von Gedächtnis mit automatisiertem Beschneiden, Neuaufbau von Indizes und Überwachung der Haltbarkeit.
Full-Stack-Entwickler	Erstellen Sie ein Dashboard zur Visualisierung und Verwaltung von Gedächtniseinträgen und verbinden Sie das Weaviate-Gedächtnis mit Ihrer Frontend-Chat-Oberfläche.

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

Verwandte Artikel

• Verbessern Sie LLMs mit zuverlässigen Wissensgraphen: Qinggang Zhangs Innovation
• Entfesseln Sie Ihre Marke: Gestalten Sie das perfekte Logo für ein Convolutional Neural Network
• Warum die Verwendung der KI-Agentenarchitektur?

🕒 Published: March 28, 2026