Hallo, angehender Agent! Hier ist Emma, dein freundlicher Leitfaden durch die wilde und wunderbare Welt der KI-Agenten. Wenn du ein wenig auf agent101.net herumgehangen hast, weißt du, dass ich alles daran setze, diese Dinge zu entmystifizieren und zugänglich zu machen, selbst wenn deine Programmiererfahrung mit MySpace CSS ihren Höhepunkt erreicht hat (kein Urteil, wir waren alle schon mal dort).
Heute möchte ich über etwas sprechen, das in meinen eigenen Projekten in letzter Zeit viel diskutiert wurde: KI-Agenten dazu zu bringen, tatsächlich Dinge zu erinnern. Nicht nur für eine einzige Interaktion, sondern über mehrere Aufgaben hinweg, über Tage, ja sogar Wochen. Wir gehen über den “One-Shot-Wonder”-Prompt hinaus und bauen Agenten, die sich ein wenig mehr, nun ja, persistent anfühlen. Es geht nicht nur darum, sie schlauer zu machen; es geht darum, sie wirklich nützlich für Aufgaben zu machen, die sich im Laufe der Zeit entwickeln.
Über die Kurzfristigkeit hinaus: Warum Gedächtnis für deinen KI-Agenten wichtig ist
Denke mal darüber nach. Wenn du mit einem menschlichen Assistenten arbeitest, erklärst du nicht jeden Morgen die gesamte Geschichte deines Unternehmens oder die Projektziele von vorne. Sie erinnern sich. Sie bauen Kontext auf. Sie lernen deine Vorlieben, deine Eigenarten, deine Reizthemen. Sie haben ein Gedächtnis.
Die meisten grundlegenden Setups für KI-Agenten, insbesondere wenn du gerade anfängst, funktionieren in einem sehr kurzfristigen Gedächtnismodell. Jede Interaktion ist ein leeres Blatt. Du gibst einen Prompt, er gibt dir eine Antwort, und dann vergisst er im Grunde alles bis zum nächsten Prompt. Das ist in Ordnung für einfache Q&A oder schnelle Aufgaben, aber es stößt schnell an seine Grenzen, wenn du möchtest, dass ein Agent:
- Ein Projekt über mehrere Tage verwaltet.
- Deinen Schreibstil für die Inhaltserstellung lernt.
- Aktuelle Gespräche mit mehreren Kunden verfolgt.
- Einen komplexen Plan entwickelt, der iterative Verfeinerung erfordert.
Ich bin vor ein paar Monaten direkt mit diesem Problem konfrontiert worden, als ich versucht habe, einen einfachen „Blogbeitrag-Ideen-Generator“-Agenten für mich zu bauen. Mein erster Gedanke war: „Super, ich gebe ihm ein paar Schlüsselwörter, und er spuckt Ideen aus.“ Es hat ganz okay funktioniert, aber jedes Mal, wenn ich wollte, dass er eine Idee verfeinert oder einen neuen Ansatz basierend auf unserem vorherigen Gespräch betrachtet, musste ich im Grunde die Hälfte des Gesprächs wieder in den Prompt kopieren und einfügen. Es war mühsam, ineffizient und ehrlich gesagt, nervig. Dann wurde mir klar: Dieser Agent musste sich an unseren Chatverlauf erinnern, und idealerweise die Themen, die wir bereits behandelt haben, speichern, damit er nicht das Gleiche nochmal vorschlägt.
Darum geht es heute: deinem KI-Agenten ein Gedächtnis zu geben, mit einem besonderen Fokus auf einen einsteigerfreundlichen Ansatz für das „langfristige Gedächtnis“ mithilfe von Vektordatenbanken und Einbettungsverfahren. Klingt fancy? Keine Sorge, wir werden es aufschlüsseln.
Der „Gedächtnis“-Stack: Einbettungen und Vektordatenbanken erklärt
Okay, lass uns in die Details einsteigen. Wie geben wir einem KI-Agenten Gedächtnis, ohne ihm jedes Mal riesige Textdateien in den Prompt zu werfen? Die Antwort liegt in zwei Schlüsselkonzepten:
- Einbettungen: Text in Zahlen umwandeln. Stell dir vor, du hast einen Satz: „Die Katze saß auf der Matte.“ Wie speicherst du das auf eine Art und Weise, die ein Computer leicht mit einem anderen Satz, wie „Eine feline ruhte auf dem Teppich,“ vergleichen kann und versteht, dass sie sich sehr ähnlich in der Bedeutung sind? Du wandelst sie in Zahlen um! Ein Einbettungsmodell nimmt Text und wandelt ihn in eine lange Liste von Zahlen (einen Vektor) um, die seine semantische Bedeutung repräsentiert. Sätze mit ähnlicher Bedeutung haben Vektoren, die in diesem numerischen Raum „nahe“ beieinander liegen.
- Vektordatenbanken: Diese Zahlen speichern und suchen. Sobald du diese numerischen Darstellungen (Einbettungen) hast, benötigst du einen Ort, um sie zu speichern, und, was noch wichtiger ist, eine Möglichkeit, die relevantesten schnell zu finden. Genau hier kommen Vektordatenbanken ins Spiel. Im Gegensatz zu herkömmlichen Datenbanken, die nach exakten Übereinstimmungen suchen, sind Vektordatenbanken darauf ausgelegt, nach „Ähnlichkeit“ zu suchen – Vektoren zu finden, die numerisch am nächsten zu einem Abfragevektor liegen.
Mein „Aha!“-Moment mit einem Rezept-Agenten
Um das wirklich zu verdeutlichen, lass mich dir von einem kleinen Nebenprojekt erzählen, das ich ( Wortspiel beabsichtigt) für meinen Partner entwickelt habe. Sie probiert ständig neue Rezepte aus und vergisst manchmal, welche ihr gefallen haben oder möchte ein ähnliches Rezept zu einem, das sie letzten Monat gemocht hat, finden. Mein Ziel war es, einen einfachen Agenten zu bauen, bei dem sie ein Gericht beschreiben kann, und er ähnliche Rezepte, die sie ausprobiert hat, abrufen oder neue basierend auf ihren bisherigen Vorlieben vorschlagen würde.
Mein erster Versuch war nur eine Schlüsselwortsuche, die schrecklich war. „Hähnchen-Pasta“ brachte jedes Hähnchen-Pasta-Rezept im Internet hervor, nicht nur *ihre* Hähnchen-Pasta-Rezepte. Dann habe ich es mit Einbettungen versucht. Ich habe all ihre Lieblingsrezepte genommen, Einbettungen für deren Beschreibungen generiert und sie in einer Vektordatenbank gespeichert. Jetzt, wenn sie fragt: „Finde mir etwas ähnliches wie das scharfe Erdnudeln-Gericht, das ich letzten Monat gemacht habe,“ nimmt der Agent ihre Abfrage, bettet sie ein, sucht in der Datenbank nach ähnlichen Rezept-Einbettungen, und zack! relevante Ergebnisse.
Es war ein bedeutender Fortschritt. Der Agent suchte nicht nur nach Wörtern; er suchte nach *Konzepten*.
Ein einfaches langfristiges Gedächtnis für deinen Agenten aufbauen: Ein praktisches Beispiel
Lasst uns praktisch werden. Ich zeige dir ein vereinfachtes Python-Beispiel, wie du dies implementieren kannst. Wir verwenden ein beliebtes Einbettungsmodell von OpenAI und eine leichte Vektordatenbank namens `FAISS` (Facebook AI Similarity Search), die sich hervorragend für lokale Entwicklungen und Lernzwecke eignet.
Stelle zuerst sicher, dass du die erforderlichen Bibliotheken installiert hast:
pip install openai faiss-cpu numpy
Jetzt lassen Sie uns einen einfachen Speicher für Gedächtnisinhalte einrichten. Stell dir vor, wir haben eine Reihe von „Gedanken“ oder „Beobachtungen“, die unser Agent im Laufe der Zeit gemacht hat. Wir möchten, dass unser Agent relevante vergangene Beobachtungen abrufen kann, wenn ihm eine neue Abfrage gegeben wird.
Schritt 1: Initialisiere dein Einbettungsmodell und den Gedächtnisspeicher
Du benötigst einen OpenAI API-Schlüssel für die Einbettungen. Ersetze YOUR_OPENAI_API_KEY mit deinem tatsächlichen Schlüssel.
import openai
import faiss
import numpy as np
import os
# Setze deinen OpenAI API-Schlüssel
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
openai.api_key = os.getenv("OPENAI_API_KEY")
# Unseren „Wissensspeicher“ im Speicher
# In einer echten Anwendung würde dies aus persistentem Speicher geladen werden
agent_memories_text = [
"Ich habe beobachtet, dass das Budget für Projekt Alpha fast aufgebraucht ist.",
"Der Kunde für Projekt Beta bevorzugt wöchentliche Statusupdates per E-Mail.",
"Teammitglied Sarah ist besonders gut bei Front-End-Entwicklungsaufgaben.",
"Beim letzten Meeting für Projekt Alpha wurde eine kritische Abhängigkeit von externem Anbieter X hervorgehoben.",
"Das Kundenfeedback weist auf eine Vorliebe für minimalistisches Design hin.",
"Ich habe letzten Dienstag einen Entwurf für Projekt Gamma erstellt.",
"Der Server hatte gestern Abend aufgrund einer geplanten Sicherung hohe Belastung.",
"John aus der Buchhaltung benötigt die Q1-Ausgabenberichte bis Freitag, Ende des Tages."
]
# Funktion zur Abrufung der Einbettungen
def get_embedding(text, model="text-embedding-ada-002"):
text = text.replace("\n", " ") # Einbettungen funktionieren besser ohne Zeilenumbrüche
return openai.embeddings.create(input=[text], model=model).data[0].embedding
# Generiere Einbettungen für unsere initialen Gedächtnisinhalte
print("Generiere Einbettungen für die initialen Erinnerungen...")
memory_embeddings = [get_embedding(memory) for memory in agent_memories_text]
memory_embeddings_np = np.array(memory_embeddings).astype('float32')
# Bekomme die Dimension unserer Einbettungen
# (text-embedding-ada-002 hat eine Dimension von 1536)
embedding_dimension = len(memory_embeddings[0])
# Initialisiere den FAISS-Index
# Wir verwenden IndexFlatL2 zur Vereinfachung (L2-Distanz ist die euklidische Distanz)
index = faiss.IndexFlatL2(embedding_dimension)
# Füge unsere Gedächtniseinbettungen zum Index hinzu
index.add(memory_embeddings_np)
print(f"FAISS-Index erstellt mit {index.ntotal} Erinnerungen.")
Schritt 2: Abfragen des Gedächtnisspeichers
Jetzt lassen Sie uns simulieren, wie unser Agent ein neues Stück Information oder eine Abfrage erhält und versucht, relevante frühere Erinnerungen abzurufen.
def recall_memories(query_text, num_results=2):
print(f"\nNeue Abfrage/Beobachtung des Agenten: '{query_text}'")
query_embedding = get_embedding(query_text)
query_embedding_np = np.array([query_embedding]).astype('float32')
# Suche im FAISS-Index nach ähnlichen Erinnerungen
distances, indices = index.search(query_embedding_np, num_results)
print(f"Abgerufen wurden {num_results} relevante Erinnerungen:")
recalled_memories = []
for i, idx in enumerate(indices[0]):
memory = agent_memories_text[idx]
distance = distances[0][i]
print(f"- [Distanz: {distance:.2f}] {memory}")
recalled_memories.append(memory)
return recalled_memories
# Beispielabfragen
print("\n--- Beispiel 1: Projekt Alpha ---")
relevant_alpha_memories = recall_memories("Was ist der aktuelle Stand bei Projekt Alpha?")
print("\n--- Beispiel 2: Kundenpräferenzen ---")
relevant_client_memories = recall_memories("Ich muss eine E-Mail für einen Kunden entwerfen. Wie lautet deren Kommunikationspräferenz?")
print("\n--- Beispiel 3: Teamfähigkeiten ---")
relevant_team_memories = recall_memories("Wer ist im Team gut in Designarbeit?")
print("\n--- Beispiel 4: Finanzen ---")
relevant_financial_memories = recall_memories("Wann sind die Q1-Ausgabenberichte fällig?")
Wenn du das ausführst, wirst du sehen, dass bei einer Abfrage zu „Projekt Alpha“ Erinnerungen in Bezug auf das Budget und externe Abhängigkeiten abgerufen werden. Wenn du nach Kundenpräferenzen fragst, wird die E-Mail-Präferenz und das minimalistische Design erwähnt. Das ist keine Magie; es ist die Kraft von Einbettungen, die die *Bedeutung* hinter deinen Worten verstehen und numerisch ähnliche Konzepte finden.
Schritt 3: Integration mit einem LLM (Das „Gehirn“ des Agenten)
Die abgerufenen Erinnerungen selbst sind nicht die endgültige Antwort; sie sind *Kontext* für das Gehirn unseres Agenten (das LLM). Du würdest diese abgerufenen Erinnerungen dann in deinen Prompt an das LLM einfügen. Auf diese Weise hat das LLM relevante frühere Informationen, die es bei der Generierung seiner Antwort berücksichtigen kann.
def get_agent_response_with_memory(user_query):
# 1. Relevante Erinnerungen abrufen
recalled_context = recall_memories(user_query, num_results=3) # Top 3 relevante Erinnerungen abrufen
# 2. Den Prompt für das LLM erstellen, einschließlich des abgerufenen Kontexts
context_string = "\n".join([f"- {mem}" for mem in recalled_context])
prompt = f"""
Du bist ein hilfreicher Projektassistent. Nutze die folgenden früheren Beobachtungen und Erinnerungen, um deine Antwort zu informieren.
Frühere Beobachtungen:
{context_string}
Benutzeranfrage: {user_query}
Basierend auf dem oben Genannten, bitte eine prägnante und hilfreiche Antwort bereitstellen:
"""
# 3. Den Prompt an das LLM senden
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Oder "gpt-4", wenn du Zugriff hast
messages=[
{"role": "system", "content": "Du bist ein hilfreicher Projektassistent."},
{"role": "user", "content": prompt}
],
max_tokens=150
)
return response.choices[0].message.content
except Exception as e:
return f"Fehler bei der Kommunikation mit dem LLM: {e}"
print("\n--- Agent antwortet mit Erinnerung ---")
user_input_1 = "Was ist mit Projekt Alpha los?"
print(f"Antwort des Agenten: {get_agent_response_with_memory(user_input_1)}")
user_input_2 = "Ich muss einem Kunden ein Update schicken. Was sollte ich beachten?"
print(f"Antwort des Agenten: {get_agent_response_with_memory(user_input_2)}")
Das ist der Kernprozess! Der Agent ruft seine Erinnerungen ab, erhält Kontext und nutzt diesen Kontext, um eine informiertere Antwort mit dem LLM zu generieren. So beginnst du, Agenten zu entwickeln, die sich anfühlen, als wüssten sie tatsächlich, was vor sich geht.
Was kommt als Nächstes für deinen speicherfähigen Agenten?
Dieses grundlegende Setup ist nur der Anfang. Um das Gedächtnis deines Agenten wirklich solide und nützlich zu machen, solltest du darüber nachdenken:
- Persistente Speicherung: Unser FAISS-Index ist im Arbeitsspeicher. Für eine echte Anwendung würdest du den Index auf der Festplatte speichern oder eine dedizierte cloudbasierte Vektordatenbank (wie Pinecone, Weaviate, Qdrant, Chroma usw.) verwenden, damit dein Agent nicht alles vergisst, wenn er neu startet.
- Dynamische Gedächtnisaktualisierungen: Wie fügt dein Agent *neue* Beobachtungen zu seinem Gedächtnis hinzu? Typischerweise hättest du eine Funktion, die neue Informationen aufnimmt, deren Einbettung generiert und sie zum FAISS-Index (oder deiner gewählten Vektordatenbank) hinzufügt.
- Gedächtniszusammenfassung/Kompression: Im Laufe der Zeit können Agenten *viele* Erinnerungen ansammeln. Es könnte ineffizient sein, Hunderte kleiner Fragmente abzurufen. Du könntest den Agenten gelegentlich ältere, weniger kritische Erinnerungen in komprimiertere „Wissensäußerungen“ zusammenfassen und diese speichern.
- Filtern und Rangieren: Manchmal möchtest du nicht nur die „ähnlichste“ Erinnerung, sondern auch die „neueste“ und die „ähnlichste“. Du kannst diese Kriterien kombinieren.
- Verschiedene Arten von Gedächtnis: Über das bloße Faktenabrufen hinaus möchtest du vielleicht ein separates „Notizblock“-Gedächtnis für die kurzfristige Planung oder ein „Fähigkeitsgedächtnis“ für Werkzeuge, die es zu benutzen weiß.
Die Schönheit dieser Architektur besteht darin, dass sie das „Denken“ (LLM) von dem „Erinnern“ (Einbettungen + Vektor DB) entkoppelt. Das macht es effizienter und erlaubt dir, jede Komponente unabhängig zu skalieren.
Handlungsfähige Erkenntnisse für deine AI-Agenten-Reise
Okay, bevor du kopfüber in den Aufbau deines eigenen speicherfähigen Agenten eintauchst, hier sind meine wichtigsten Erkenntnisse:
- Einfach anfangen: Versuche nicht, am ersten Tag den nächsten Jarvis zu bauen. Beginne mit einem konkreten Anwendungsfall, bei dem Gedächtnis die Leistung des Agenten wirklich verbessern würde (wie mein Rezept-Agent oder Blog-Ideen-Generator).
- Einbettungen verstehen: Zu begreifen, dass Text in Zahlen umgewandelt werden kann, die Bedeutung repräsentieren, ist grundlegend. Experimentiere mit einer Einbettungs-API, um zu sehen, wie verschiedene Sätze repräsentiert werden.
- Vektordatenbanken sind deine Freunde: Sie sind nicht nur für riesige Unternehmensprojekte. Werkzeuge wie FAISS oder sogar lokale Installationen von Chroma/Qdrant machen sie zugänglich für Anfänger.
- Gedächtnis ist Kontext: Denke daran, dass das „Gedächtnis“ nicht das Gehirn des Agenten selbst ist; es ist der hochrelevante Kontext, den du *in* das Gehirn des Agenten (das LLM) einfügst, um ihm beim besseren Denken zu helfen.
- Iterieren und Experimentieren: Dies ist ein sich entwickelndes Feld. Dein erstes Gedächtnissystem könnte ungeschliffen sein. Das ist in Ordnung! Lerne daraus, verfeinere es und experimentiere weiter.
Gedächtnis zu deinem AI-Agenten hinzuzufügen, ist ein großer Schritt, um ihn fähiger, hilfsbereiter und ehrlich gesagt intelligenter erscheinen zu lassen. Es bringt deine Projekte von interessanten Demos zu wirklich nützlichen Werkzeugen. Also gehe voran, Agentenbauer, und schenke deinen AI-Agenten das Geschenk des Erinnerns!
Hast du Fragen oder etwas Cooles mit Gedächtnis gebaut? Hinterlasse einen Kommentar unten oder finde mich in den sozialen Medien. Ich würde gern von deinen Projekten hören!
Ähnliche Artikel
- KI-Agenten & IP: Rechte und Vorschriften navigieren
- KI-Startup-Finanzierungsnachrichten: Rekordrunden, dünne Margen und die Suche nach Gräben
- KI-Agenten verstehen: Eine tiefgehende Erkundung ihrer einfachen, aber kraftvollen Natur
🕒 Published: