Ich habe eine KI entwickelt, die sich erinnert: Mein Weg zu persistentem Gedächtnis

Als Erstes denken wir über die Struktur nach. Eine einfache JSON-Datei könnte so aussehen:

{
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": ["KI-Ethische", "Biotechnologie", "Weltraumforschung"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": []
}

Wie lassen wir now unseren Python-Agenten mit dieser Datei interagieren?

Wir benötigen Funktionen, um das Gedächtnis zu laden und zu speichern. Hier ist eine grundlegende Einrichtung:

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def update_user_preference(key, value):
 memory = load_memory()
 memory["user_preferences"][key] = value
 memory["user_preferences"]["last_seen"] = datetime.now().isoformat()
 save_memory(memory)
 print(f"Präferenz aktualisiert: {key} auf {value}")

def get_user_preference(key):
 memory = load_memory()
 return memory["user_preferences"].get(key)

# --- Agenteninteraktionsbeispiel ---

if __name__ == "__main__":
 print("Willkommen zurück bei deinem Agenten!")

 # Lade bestehendes Gedächtnis oder initialisiere neu
 current_memory = load_memory()
 print(f"Deine bevorzugte Zusammenfassungs Länge ist: {get_user_preference('summary_length')}")
 print(f"Deine Lieblings Themen sind: {get_user_preference('favorite_topics')}")

 # Simuliere, dass der Benutzer eine Präferenz festlegt
 user_input = input("Möchtest du 'kurze', 'mittlere' oder 'lange' Zusammenfassungen? (Tippe, um zu ändern oder drücke Enter, um zu behalten): ").strip().lower()
 if user_input in ["kurz", "mittel", "lang"]:
 update_user_preference("summary_length", user_input)
 print(f"Okay, ich werde mir merken, dass du {user_input} Zusammenfassungen bevorzugst.")
 else:
 print("Behalte die aktuelle Präferenz bei.")

 # Simuliere, dass der Agent das Gedächtnis nutzt
 preferred_length = get_user_preference("summary_length")
 print(f"Erstelle eine {preferred_length} Zusammenfassung für deine nächste Aufgabe...")

 # Fügen wir ein neues Lieblings Thema hinzu
 new_topic = input("Hast du neue Lieblings Themen, die du hinzufügen möchtest? ").strip()
 if new_topic:
 topics = get_user_preference('favorite_topics')
 if new_topic not in topics:
 topics.append(new_topic)
 update_user_preference('favorite_topics', topics)
 print(f"'{new_topic}' zu deinen Lieblings Themen hinzugefügt.")
 else:
 print(f"'{new_topic}' ist bereits in deinen Favoriten.")

 print(f"\nNach dieser Sitzung sieht dein Gedächtnis so aus:")
 print(json.dumps(load_memory(), indent=4))

Was passiert hier?

• `load_memory()` prüft, ob `agent_memory.json` existiert. Wenn ja, liest sie es. Wenn nicht, erstellt sie eine grundlegende Struktur.
• `save_memory()` nimmt unser Python-Wörterbuch und schreibt es in die JSON-Datei.
• `update_user_preference()` und `get_user_preference()` sind Hilfsfunktionen, um die Interaktion mit spezifischen Teilen des Gedächtnisses zu erleichtern.
• Der Hauptteil des Skripts (`if __name__ == ” __main__ “:`) simuliert einen Benutzer, der mit dem Agenten interagiert, Präferenzen festlegt und dann der Agent diese Präferenzen verwendet.

Probiere aus, dieses Skript ein paar Mal auszuführen. Du wirst sehen, dass deine Präferenzen auch nach dem Schließen und Wiederöffnen des Skripts bestehen bleiben! Das ist die Magie des persistenten Gedächtnisses, selbst in seiner einfachsten Form.

Beispiel 2: Erinnern an Gesprächsverlauf

Über die Präferenzen hinaus ist ein entscheidender Teil des Gedächtnisses eines Agenten die Erinnerung daran, was gerade gesagt wurde. Dies ist besonders wichtig für Gespräche oder Aufgaben mit mehreren Interaktionen. Während LLMs ein „Kontextfenster“ haben, wird dieser Kontext normalerweise nach jedem APIaufruf oder Sitzung gelöscht. Wir wollen das erweitern.

Lasst uns unsere `agent_memory.json` so anpassen, dass sie eine Liste `conversation_history` enthält. Jeder Eintrag in dieser Liste könnte ein Dictionary enthalten, das den Sprecher (Benutzer/Agent) und die Nachricht enthält.

Aktualisierte Struktur von `agent_memory.json`:

{
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": ["KI-Ethische", "Biotechnologie", "Weltraumforschung"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": [
 {"role": "user", "message": "Hey, was ist los?"},
 {"role": "agent", "message": "Nicht viel, ich warte nur auf deine Befehle!"}
 ]
}

Jetzt lass uns Funktionen hinzufügen, um diesen Verlauf zu verwalten:

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

# (Inkludieren Sie die Funktionen load_memory und save_memory aus dem vorherigen Beispiel)

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def add_to_history(role, message):
 memory = load_memory()
 memory["conversation_history"].append({"role": role, "message": message, "timestamp": datetime.now().isoformat()})
 # Optional: Halten Sie die Historie auf einer überschaubaren Größe, sagen wir die letzten 10 Wendungen
 if len(memory["conversation_history"]) > 10:
 memory["conversation_history"] = memory["conversation_history"][-10:]
 save_memory(memory)

def get_conversation_history():
 memory = load_memory()
 return memory["conversation_history"]

# --- Agenteninteraktion Beispiel mit Historie ---

if __name__ == "__main__":
 print("Willkommen zurück! Hier ist unser letztes Gespräch:")
 for entry in get_conversation_history():
 print(f"{entry['role'].capitalize()}: {entry['message']}")

 while True:
 user_message = input("Du: ")
 if user_message.lower() == "exit":
 break
 
 add_to_history("user", user_message)
 print(f"Agent: (Denke über: '{user_message}' und vorherige Historie...)")
 
 # Simuliere Agentenantwort (in einem echten Agenten würde dies einen LLM-Aufruf beinhalten)
 agent_response = f"Verstanden, du hast gesagt '{user_message}'. Ich werde das im Gedächtnis behalten."
 add_to_history("agent", agent_response)
 print(f"Agent: {agent_response}")

 print("\nChat beendet. Deine Gesprächshistorie wurde gespeichert.")
 print(json.dumps(load_memory(), indent=4))

In diesem Beispiel wird jede Nachricht vom Benutzer und jede simulierte Antwort vom Agenten der Liste `conversation_history` in unserer JSON-Datei hinzugefügt. Wenn das Skript startet, lädt es diese Historie und gibt dem Agenten eine Art „Gedächtnis“ vorheriger Interaktionen. Ich habe eine kleine Zeile hinzugefügt, um die Historie auf die letzten 10 Einträge zu kürzen – dies ist eine einfache Möglichkeit, um zu verhindern, dass deine Gedächtnisdatei unbegrenzt wächst, was bei sehr langen Gesprächen ein Problem sein kann.

Überlegungen und nächste Schritte

Während JSON-Dateien fantastisch sind, um anzufangen, haben sie auch Einschränkungen:

• Skalierbarkeit: Bei sehr großen Datenmengen kann das wiederholte Lesen und Schreiben der gesamten Datei langsam werden.
• Nebenläufigkeit: Wenn mehrere Teile deines Agenten (oder mehrere Agenten) gleichzeitig versuchen, in dieselbe Datei zu schreiben, können Probleme auftreten.
• Komplexe Abfragen: Es ist schwierig, Fragen zu stellen wie „Finde alle Gespräche, in denen der Benutzer ‘quantum computing’ UND ‘ethische Implikationen’ erwähnt hat.“ Du müsstest die gesamte Datei laden und manuell suchen.

Aber für einen Anfänger und für viele persönliche Projekte sind diese Einschränkungen absolut akzeptabel. Du beginnst, das Kernkonzept des persistenten Gedächtnisses zu verstehen, ohne dich mit der zusätzlichen Komplexität einer Datenbank herumschlagen zu müssen.

Sobald du dich mit JSON-Dateien wohlfühlst, hier sind einige natürliche nächste Schritte:

1. SQLite: Dies ist eine dateibasierte relationale Datenbank, die sich super einfach in Python integrieren lässt. Sie löst die Skalierbarkeits- und Abfrageprobleme von JSON-Dateien, ohne einen separaten Server zu benötigen. Oft ist dies der nächste logische Schritt für viele Projekte.
2. Vektor-Datenbanken (z. B. Chroma, FAISS): Hier wird es für KI-Agenten wirklich interessant! Vektor-Datenbanken speichern Informationen als numerische Einbettungen, die es deinem Agenten ermöglichen, semantische Suchen durchzuführen (z. B. „Finde Informationen, die mit diesem Konzept zusammenhängen,“ auch wenn die genauen Schlüsselwörter nicht vorhanden sind). Dies ist das Fundament vieler fortgeschrittener RAG-Systeme.
3. Komplexere Gedächtnisstrukturen: Anstatt nur rohe Konversationen zu speichern, könntest du versuchen, wichtige Punkte festzuhalten, Entitäten zu extrahieren oder sogar ein „Wissensgraph“ in deinem Gedächtnis aufzubauen.

Meine Takeaways für dich

Persistentes Gedächtnis ist nicht nur ein fortgeschrittenes Feature; es ist eine grundlegende Anforderung für den Aufbau von KI-Agenten, die wirklich nützlich und intelligent wirken. Mit einfachen JSON-Dateien zu beginnen, ist eine unglaublich praktische Möglichkeit, das Kernkonzept zu verstehen, ohne sich in Komplexität zu verlieren.

Hier ist, was ich möchte, dass du heute im Hinterkopf behältst:

• Beginne einfach: Fühle dich nicht gedrängt, sofort die fortschrittlichste Technologie zu verwenden. JSON-Dateien sind dein Freund für persistentes Gedächtnis als Anfänger.
• Struktur ist entscheidend: Auch in einer JSON-Datei solltest du darüber nachdenken, wie du das Gedächtnis deines Agenten (Präferenzen, Geschichte, erlernte Fakten usw.) organisieren möchtest.
• Übe das Laden und Speichern: Die Kernschleife von `load_memory()`, modifizieren `memory`, `save_memory()` ist das, was du ständig verwenden wirst.
• Iteriere und erweitere: Sobald du dich mit JSON wohlfühlst, fordere dich selbst heraus, auf SQLite umzusteigen und dann vielleicht Vektor-Datenbanken zu erkunden. Jeder Schritt baut auf dem vorherigen auf.

Ich erinnere mich, als ich meinen einfachen Agenten zum „Erinnern“ meiner bevorzugten Zusammenfassungs Länge über Sitzungen hinweg brachte, fühlte sich das wie ein kleiner Durchbruch an. Es ging nicht nur darum, Code auszuführen; es begann, sich so anzufühlen, als hätte es ein kleines, digitales Gehirn für sich allein. Probiere es aus – du wirst erstaunt sein, wie viel fähiger deine Agenten werden!

Viel Spaß beim Programmieren, und lass uns weiter an diesen intelligenteren Agenten arbeiten!

🕒 Published: March 29, 2026