Hallo, angehender Agent! Emma hier, eure freundliche Begleiterin in der wilden und wunderbaren Welt der KI-Agenten. Wenn ihr ein wenig auf agent101.net stöbert, wisst ihr, dass ich hier bin, um diese Dinge zu entmystifizieren und sie zugänglich zu machen, auch wenn eure Programmiererfahrung mit dem CSS von MySpace geendet hat (kein Urteil, wir sind da alle durchgegangen).
Heute möchte ich über etwas sprechen, das in meinen eigenen Projekten in letzter Zeit viel Aufsehen erregt hat: sicherzustellen, dass KI-Agenten sich tatsächlich an Dinge erinnern. Nicht nur für eine einzige Interaktion, sondern über mehrere Aufgaben hinweg, Tage oder sogar Wochen. Wir gehen über den „One-Night-Stand“ hinaus und arbeiten daran, Agenten zu schaffen, die etwas, nun ja, beständiger erscheinen. Es geht nicht nur darum, sie intelligenter zu machen; es geht darum, sie wirklich nützlich für Aufgaben zu machen, die sich mit der Zeit entwickeln.
Über den kurzfristigen Zeitraum hinaus: Warum Gedächtnis für euren KI-Agenten wichtig ist
Denkt mal drüber nach. Wenn ihr mit einem menschlichen Assistenten arbeitet, erklärt ihr nicht jeden Morgen die gesamte Geschichte eures Unternehmens oder die Ziele eures Projekts neu. Sie erinnern sich. Sie schaffen Kontext. Sie lernen eure Vorlieben, Eigenheiten und kleinen Ärgernisse kennen. Sie haben ein Gedächtnis.
Die meisten grundliegenden Konfigurationen von KI-Agenten, besonders wenn ihr neu dabei seid, funktionieren nach einem Modell mit sehr kurzfristigem Gedächtnis. Jede Interaktion ist eine leere Tafel. Ihr gebt ihm einen Prompt, es gibt euch eine Antwort, und dann vergisst es im Wesentlichen alles bis zum nächsten Prompt. Das ist in Ordnung für einfache Fragen und Antworten oder schnelle Aufgaben, aber es stößt schnell an eine Grenze, wenn ihr wollt, dass ein Agent:
- Ein Projekt über mehrere Tage verwaltet.
- Euren Schreibstil für die Inhaltserstellung lernt.
- Laufende Gespräche mit mehreren Kunden verfolgt.
- Einen komplexen Plan entwickelt, der iterative Verfeinerung erfordert.
Vor einigen Monaten bin ich mit diesem Problem konfrontiert worden, als ich versucht habe, einen einfachen „Blog-Ideen-Generator“-Agenten für mich selbst zu bauen. Mein erster Gedanke war: „Super, ich gebe ihm ein paar Keywords und er wird mir Ideen liefern.“ Das hat ganz gut funktioniert, aber jedes Mal, wenn ich wollte, dass er eine Idee verfeinert oder einen neuen Ansatz auf der Grundlage unseres vorherigen Gesprächs in Betracht zieht, musste ich im Grunde die Hälfte des Gesprächs in den Prompt einfügen. Das war ungeschickt, ineffizient und ehrlich gesagt, langweilig. Da wurde mir klar: Dieser Agent musste sich an unseren Chatverlauf erinnern, und idealerweise an die Themen, die wir bereits besprochen hatten, damit er nicht dasselbe erneut vorschlägt.
Das ist das, womit wir uns heute auseinandersetzen: Euren KI-Agenten mit Gedächtnis auszustatten, wobei wir uns speziell auf einen anfängerfreundlichen Ansatz für „langfristiges Gedächtnis“ konzentrieren, der Vektor-Datenbanken und -Integrationen nutzt. Klingt gut? Keine Sorge, wir werden das alles aufschlüsseln.
Die „Gedächtnis“-Stack: Erklärung der Integrationen und Vektor-Datenbanken
Okay, kommen wir zum Kern der Sache. Wie verleiht man einem KI-Agenten ein Gedächtnis, ohne einfach jedes Mal riesige Textdateien in seinen Prompt zu kippen? Die Antwort liegt in zwei Schlüsselkonzepten:
- Integrationen: Text in Zahlen umwandeln. Stellt euch vor, ihr habt einen Satz: „Die Katze saß auf der Fußmatte.“ Wie kann man ihn so speichern, dass ein Computer ihn leicht mit einem anderen Satz, wie „Ein Felidae hat sich auf dem Teppich ausgeruht“, vergleichen und verstehen kann, dass sie sehr ähnlich in ihrer Bedeutung sind? Ihr wandelt sie in Zahlen um! Ein Integrationsmodell nimmt Text und verwandelt ihn in eine lange Liste von Zahlen (ein Vektor), die seine semantische Bedeutung repräsentiert. Sätze mit ähnlichen Bedeutungen haben Vektoren, die in diesem digitalen Raum „nah“ beieinander liegen.
- Vektor-Datenbanken: Diese Zahlen speichern und durchsuchen. Sobald ihr diese numerischen Darstellungen (Integrationen) habt, benötigt ihr einen Ort, um sie zu speichern, und noch wichtiger, ein Mittel, um schnell die relevantesten zu finden. Hier kommen die Vektor-Datenbanken ins Spiel. Im Gegensatz zu traditionellen Datenbanken, die nach exakten Übereinstimmungen suchen, sind Vektor-Datenbanken so konzipiert, dass sie nach „Ähnlichkeit“ suchen – indem sie Vektoren finden, die numerisch dem Vektor einer Anfrage am nächsten sind.
Mein „Aha!“-Moment mit einem Rezept-Agenten
Um das wirklich zu veranschaulichen, lass mich euch von einem kleinen Nebenprojekt erzählen, das ich für meinen Partner entwickelt habe (Wortspiel beabsichtigt). Sie probiert ständig neue Rezepte aus und vergisst manchmal, welche sie mochte, oder möchte ein ähnliches Rezept finden wie das, das sie letzten Monat gemocht hat. Mein Ziel war es, einen einfachen Agenten zu bauen, bei dem sie ein Gericht beschreiben kann, und der daran erinnert, welche ähnlichen Rezepte sie ausprobiert hat oder neue vorschlägt, basierend auf ihren bisherigen Vorlieben.
Mein erster Versuch war einfach eine Suche nach Keywords, was schrecklich war. „Hühnchen-Pasta“ lieferte alle Hühnchen-Pasta-Rezepte im Internet, nicht nur ihre eigenen. Dann probierte ich die Integration aus. Ich nahm all ihre Lieblingsrezepte, generierte Integrationen für deren Beschreibungen und speicherte sie in einer Vektor-Datenbank. Jetzt, wenn sie fragt: „Finde mir etwas wie dieses scharfe Erdnudeln-Gericht, das ich letzten Monat gemacht habe,“ verarbeitet der Agent ihre Anfrage, integriert sie, durchsucht die Datenbank nach ähnlichen Rezept-Integrationen, und bam! Relevante Ergebnisse.
Das war eine signifikante Verbesserung. Der Agent suchte nicht nur nach Wörtern; er suchte nach *Konzepten*.
Eine grundlegende langfristige Gedächtnisstruktur für euren Agenten aufbauen: Ein praktisches Beispiel
Kommen wir zur praktischen Seite. Ich zeige euch ein vereinfachtes Beispiel in Python, wie ihr das umsetzen könnt. Wir werden ein beliebtes Integrationsmodell von OpenAI verwenden und eine leichte Vektor-Datenbank namens `FAISS` (Facebook AI Similarity Search) nutzen, die sich ideal für die lokale Entwicklung und das Lernen eignet.
Stellt zuerst sicher, dass ihr die nötigen Bibliotheken installiert habt:
pip install openai faiss-cpu numpy
Jetzt richten wir einen einfachen Gedächtnisspeicher ein. Stellt euch vor, wir haben eine Reihe von „Gedanken“ oder „Beobachtungen“, die unser Agent im Laufe der Zeit gemacht hat. Wir wollen, dass unser Agent relevante frühere Beobachtungen abrufen kann, wenn er eine neue Anfrage erhält.
Schritt 1: Initialisiert euer Integrationsmodell und euren Gedächtnisspeicher
Ihr benötigt einen OpenAI API-Schlüssel für die Integrationen. Ersetzt YOUR_OPENAI_API_KEY durch euren echten Schlüssel.
import openai
import faiss
import numpy as np
import os
# Legt euren OpenAI API-Schlüssel fest
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
openai.api_key = os.getenv("OPENAI_API_KEY")
# Unser „Wissensbasis“ im Gedächtnis
# In einer echten Anwendung würde dies aus einem persistenten Speicher geladen werden
agent_memories_text = [
"Ich habe beobachtet, dass das Budget für das Projekt Alpha fast aufgebraucht ist.",
"Der Kunde des Projekts Beta bevorzugt wöchentliche Updates per E-Mail.",
"Das Teammitglied Sarah exceliert in Front-End-Entwicklungsaufgaben.",
"Das letzte Meeting für das Projekt Alpha hat eine kritische Abhängigkeit von einem externen Anbieter X aufgezeigt.",
"Die Kundenrückmeldungen zeigen eine Präferenz für minimalistische Designästhetik.",
"Ich habe letzten Dienstag einen vorläufigen Vorschlag für das Projekt Gamma erstellt.",
"Der Server hatte gestern Abend wegen eines geplanten Backups eine hohe Auslastung.",
"John aus der Buchhaltung braucht die Ausgabenberichte für das erste Quartal vor Freitagabend."
]
# Funktion zum Abrufen von Integrationen
def get_embedding(text, model="text-embedding-ada-002"):
text = text.replace("\n", " ") # Integrationen funktionieren besser ohne Zeilenumbrüche
return openai.embeddings.create(input=[text], model=model).data[0].embedding
# Generieren von Integrationen für unsere ursprünglichen Erinnerungen
print("Generierung der Integrationen für die ursprünglichen Erinnerungen...")
memory_embeddings = [get_embedding(memory) for memory in agent_memories_text]
memory_embeddings_np = np.array(memory_embeddings).astype('float32')
# Erhalten der Dimension unserer Integrationen
# (text-embedding-ada-002 hat eine Dimension von 1536)
embedding_dimension = len(memory_embeddings[0])
# FAISS-Index initialisieren
# Wir verwenden IndexFlatL2 zur Vereinfachung (der L2-Abstand ist der euklidische Abstand)
index = faiss.IndexFlatL2(embedding_dimension)
# Fügen Sie unsere Gedächtnisintegration zum Index hinzu
index.add(memory_embeddings_np)
print(f"FAISS-Index erstellt mit {index.ntotal} Erinnerungen.")
Schritt 2: Den Gedächtnisspeicher abfragen
Lassen Sie uns nun simulieren, dass unser Agent ein neues Informationsstück oder eine Anfrage erhält und versucht, relevante frühere Erinnerungen abzurufen.
def erinnerungen_abfragen(query_text, num_results=2):
print(f"\nNeue Anfrage/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"Relevante Erinnerungen abgerufen: {num_results}")
abgerufene_erinnerungen = []
for i, idx in enumerate(indices[0]):
memory = agent_memories_text[idx]
distance = distances[0][i]
print(f"- [Distanz: {distance:.2f}] {memory}")
abgerufene_erinnerungen.append(memory)
return abgerufene_erinnerungen
# Beispiele für Anfragen
print("\n--- Beispiel 1: Projekt Alpha ---")
relevante_alpha_erinnerungen = erinnerungen_abfragen("Wie ist der aktuelle Stand des Projekts Alpha?")
print("\n--- Beispiel 2: Kundenpräferenzen ---")
relevante_kunden_erinnerungen = erinnerungen_abfragen("Ich muss eine E-Mail an einen Kunden schreiben. Was ist ihre Kommunikationspräferenz?")
print("\n--- Beispiel 3: Teamfähigkeiten ---")
relevante_team_erinnerungen = erinnerungen_abfragen("Wer ist gut im Design im Team?")
print("\n--- Beispiel 4: Finanzen ---")
relevante_finanzielle_erinnerungen = erinnerungen_abfragen("Wann sind die Ausgabenberichte für das erste Quartal?")
Wenn Sie das ausführen, werden Sie sehen, dass, wenn Sie eine Frage zum „Projekt Alpha“ stellen, Erinnerungen zu dessen Budget und externen Abhängigkeiten abgerufen werden. Wenn Sie nach Kundenpräferenzen fragen, wird die Präferenz für E-Mails und minimalistisches Design erwähnt. Das ist keine Magie; es ist die Kraft von Integrationen, die den *Sinn* hinter Ihren Worten verstehen und digital ähnliche Konzepte finden.
Schritt 3: Integration mit einem LLM (Das „Gehirn“ des Agenten)
Die abgerufenen Erinnerungen selbst sind nicht die endgültige Antwort; sie bilden einen *Kontext* für das Gehirn unseres Agenten (das LLM). Sie würden also diese abgerufenen Erinnerungen nehmen und in Ihren Prompt für das LLM einfügen. Auf diese Weise hat das LLM relevante frühere Informationen zur Verfügung, die es bei der Generierung seiner Antwort berücksichtigen kann.
def agenten_antwort_mit_gedächtnis_bekommen(user_query):
# 1. Relevante Erinnerungen abfragen
abgerufener_kontext = erinnerungen_abfragen(user_query, num_results=3) # Die 3 relevantesten Erinnerungen abrufen
# 2. Den Prompt für das LLM erstellen, der den abgerufenen Kontext enthält
kontext_string = "\n".join([f"- {mem}" for mem in abgerufener_kontext])
prompt = f"""
Sie sind ein nützlicher Projektassistent. Nutzen Sie die folgenden Beobachtungen und früheren Erinnerungen, um Ihre Antwort zu informieren.
Früher Beobachtungen:
{kontext_string}
Benutzeranfrage: {user_query}
Basierend auf dem Obigen, bitte geben Sie eine prägnante und nützliche Antwort:
"""
# 3. Den Prompt an das LLM senden
try:
antwort = openai.chat.completions.create(
model="gpt-3.5-turbo", # Oder "gpt-4", wenn Sie Zugang haben
messages=[
{"role": "system", "content": "Sie sind ein nützlicher Projektassistent."},
{"role": "user", "content": prompt}
],
max_tokens=150
)
return antwort.choices[0].message.content
except Exception as e:
return f"Kommunikationsfehler mit dem LLM: {e}"
print("\n--- Agent Antwortet mit Gedächtnis ---")
benutzer_input_1 = "Wie ist die Lage beim Projekt Alpha?"
print(f"Antwort des Agenten: {agenten_antwort_mit_gedächtnis_bekommen(benutzer_input_1)}")
benutzer_input_2 = "Ich muss einem Kunden ein Update senden. Was sollte ich beachten?"
print(f"Antwort des Agenten: {agenten_antwort_mit_gedächtnis_bekommen(benutzer_input_2)}")
Das ist der zentrale Kreislauf! Der Agent befragt sein Gedächtnis, erhält einen Kontext und nutzt diesen Kontext, um eine informiertere Antwort mit dem LLM zu generieren. So beginnt man, Agenten zu bauen, die tatsächlich *wissen*, was vor sich geht.
Was sind die nächsten Schritte für Ihren Agenten mit Gedächtnis?
Diese Grundkonfiguration ist erst der Anfang. Um das Gedächtnis Ihres Agenten wirklich nützlich und praktikabel zu machen, sollten Sie über Folgendes nachdenken:
- Persistente Speicherung: Unser FAISS-Index ist im Speicher. Für eine echte Anwendung sollten Sie den Index auf der Festplatte speichern oder eine dedizierte Vektordatenbank in der Cloud (wie Pinecone, Weaviate, Qdrant, Chroma usw.) verwenden, damit Ihr Agent nicht alles vergisst, wenn er neu gestartet wird.
- Dynamische Aktualisierungen des Gedächtnisses: Wie fügt Ihr Agent *neue* Beobachtungen zu seinem Gedächtnis hinzu? Sie hätten typischerweise eine Funktion, die neue Informationen aufnimmt, ihr embedding generiert und es zum FAISS-Index (oder Ihrer gewählten Vektordatenbank) hinzufügt.
- Zusammenfassung/Kompression des Gedächtnisses: Im Laufe der Zeit können Agenten viele Erinnerungen ansammeln. Es könnte ineffektiv sein, Hunderte kleiner Abschnitte abzurufen. Sie könnten den Agenten dazu bringen, regelmäßig alte, weniger kritische Erinnerungen in kompaktere „Wissen“-Aussagen zusammenzufassen und zu speichern.
- Filtering und Ranking: Manchmal möchten Sie nicht nur die „ähnlichste“ Erinnerung, sondern die „aktuellste“ und die „ähnlichste“. Sie können diese Kriterien kombinieren.
- Verschiedene Arten von Gedächtnis: Über das einfache Abrufen faktischer Informationen hinaus möchten Sie möglicherweise ein separates „Notizbuch“-Gedächtnis für die kurzfristige Planung oder ein „Fähigkeiten“-Gedächtnis für die Werkzeuge, die er beherrscht.
Die Schönheit dieser Architektur besteht darin, dass sie das „Denken“ (LLM) vom „Gedächtnis“ (Embeddings + Vektordatenbank) entkoppelt. Das macht sie effizienter und ermöglicht es Ihnen, jedes einzelne Element unabhängig weiterzuentwickeln.
Praktische Tipps für Ihre Reise mit KI-Agenten
Okay, bevor Sie mit dem Bau Ihres eigenen Agenten mit Gedächtnis anfangen, hier sind meine wichtigsten Tipps:
- Einfach anfangen: Versuchen Sie nicht, gleich am ersten Tag den nächsten Jarvis zu bauen. Beginnen Sie mit einem spezifischen Anwendungsfall, bei dem das Gedächtnis die Leistung des Agenten tatsächlich verbessern würde (wie mein Rezept- oder Blogideen-Generator).
- Verstehen Sie die Embeddings: Zu verstehen, dass Text in Zahlen umgewandelt werden kann, die eine Bedeutung darstellen, ist grundlegend. Experimentieren Sie mit einer Embedding-API, um zu sehen, wie verschiedene Sätze dargestellt werden.
- Vektordatenbanken sind Ihre Freunde: Sie sind nicht nur für riesige Unternehmensprojekte gedacht. Tools wie FAISS oder sogar lokale Installationen von Chroma/Qdrant machen sie für Anfänger zugänglich.
- Das Gedächtnis ist Kontext: Denken Sie daran, das „Gedächtnis“ ist nicht das Gehirn des Agenten selbst; es ist der äußerst relevante Kontext, den Sie *in* das Gehirn des Agenten (das LLM) einspeisen, um ihm zu helfen, besser zu denken.
- Iterieren und Experimentieren: Dies ist ein sich entwickelndes Feld. Ihr erstes Gedächtnissystem kann rudimentär sein. Das ist normal! Lernen Sie daraus, verfeinern Sie es und experimentieren Sie weiter.
Das Hinzufügen von Gedächtnis zu Ihrem KI-Agenten ist ein großer Schritt, um ihn fähiger, nützlicher und, ehrlich gesagt, intelligenter erscheinen zu lassen. Es verwandelt Ihre Projekte von interessanten Demonstrationen in wirklich nützliche Werkzeuge. Also los, Agentenbauer, und gebt euren KI-Agenten das Geschenk des Gedächtnisses!
Haben Sie Fragen oder haben Sie etwas Cooles mit Gedächtnis gebaut? Hinterlassen Sie einen Kommentar unten oder finden Sie mich in den sozialen Medien. Ich würde gerne von Ihren Projekten hören!
Verwandte Artikel
- KI-Agenten & PI: Rechte und Vorschriften navigieren
- Nachrichten über die Finanzierung von KI-Startups: Rekordrunden, knappe Margen und die Suche nach Wettbewerbsvorteilen
- KI-Agenten erklärt: Eine gründliche Untersuchung ihrer einfachen, aber mächtigen Natur
🕒 Published: