Vector RAG ist nicht genug.

Vektor-RAG allein reicht nicht – Ich habe eine Kontext-Graph-Ebene für Multi-Agent-Gedächtnis entwickelt

Retrieval-Augmented Generation (RAG) hat sich zur Standardarchitektur entwickelt, um LLMs mit externem Wissen zu verankern. Indem Dokumentabschnitte als Vektor-Embeddings gespeichert und bei Abfragen die semantisch ähnlichsten abgerufen werden, löst Vektor-RAG das Halluzinationsproblem für viele Einzelagent-Anwendungen. Doch als ich mein System auf mehrere Agenten skalierte, die an komplexen Aufgaben zusammenarbeiten, versagte Vektor-RAG. Agenten verloren den Gesprächskontext, wiederholten Fakten und widersprachen sich gegenseitig. Die Ursache war klar: Vektorähnlichkeit allein kann keine Beziehungen zwischen Informationen über die Zeit hinweg modellieren.

In diesem Artikel erkläre ich, warum ich eine Kontext-Graph-Ebene auf Vektor-RAG aufgebaut habe, wie sie Multi-Agent-Gedächtnisprobleme löst und welche genauen Schritte Sie befolgen können, um sie selbst zu implementieren. Ich stütze mich auf Erkenntnisse aus aktuellen Branchenentwicklungen – darunter OpenAIs Forschung zu agentischem Gedächtnis, Anthropics Arbeit zu strukturiertem Denken und Microsofts KI-Blogbeiträge über graphbasiertes Wissensmanagement – um diesen Ansatz in bewährtem Denken zu verankern.

Die Grenzen von Vektor-RAG für Multi-Agent-Systeme

Vektor-RAG funktioniert hervorragend für einzelne Abfragen. Sie embedden eine Frage, finden die Top-k-Abschnitte und geben sie an ein LLM weiter. Aber Multi-Agent-Systeme bringen drei grundlegende Herausforderungen mit sich:

• **Kontextfragmentierung**: Jeder Agent arbeitet mit seinem eigenen Abruffenster. Wenn Agent A einen Dokumentabschnitt abruft, kann Agent B einen anderen Abschnitt aus demselben Dokument abrufen, was zu inkonsistentem Denken führt.
• **Zeitliche Drift**: Agenten müssen sich merken, was sie vor Minuten oder Stunden gesagt haben. Vektorspeicher behandeln alle Abschnitte als gleich weit entfernt und ignorieren den Zeitstrahl der Interaktionen.
• **Beziehungsblindheit**: Vektorähnlichkeit erfasst semantische Nähe, aber nicht logische Verbindungen wie „dieser Fakt widerspricht jenem Fakt“ oder „dieser Schritt folgt auf jenen Schritt“.

Diese Probleme wurden akut, als ich ein Team aus drei Agenten – einem Rechercheur, einem Schreiber und einem Faktenprüfer – einsetzte, um einen wöchentlichen Bericht zu erstellen. Der Schreiber bezog sich auf eine Statistik, die der Rechercheur bereits korrigiert hatte, und der Faktenprüfer verschwendete Zeit damit, bereits bestätigte Behauptungen erneut zu verifizieren. Vektor-RAG bot keinen Mechanismus, damit Agenten ein kohärentes Gedächtnis darüber teilen konnten, was bekannt war, wann es gelernt wurde und wie Fakten miteinander zusammenhängen.

Was ist eine Kontext-Graph-Ebene?

Eine Kontext-Graph-Ebene ist ein gerichteter, beschrifteter Graph, der zwischen Ihrem Vektorspeicher und Ihrem LLM sitzt. Anstatt flache Abschnitte abzurufen, fragt das System zuerst den Graphen ab, um relevante Knoten (die Fakten, Ereignisse oder Nachrichten repräsentieren) und Kanten (die Beziehungen wie „unterstützt“, „widerspricht“, „folgt“ oder „aktualisiert“ repräsentieren) zu finden. Die Graph-Ebene reichert dann den Abrufkontext mit strukturierten Beziehungen und zeitlichen Metadaten an.

Dieser Ansatz ist inspiriert von Knowledge-Graph-Techniken, die in der Industrieforschung untersucht wurden. Beispielsweise hat Microsofts KI-Blog diskutiert, wie graphbasierte Darstellungen Multi-Turn-Gespräche in Unternehmens-KI-Systemen verbessern können, während Anthropics Arbeit zu strukturiertem Denken die Bedeutung der Aufrechterhaltung eines konsistenten Kontexts über Agenteninteraktionen hinweg hervorhebt.

Voraussetzungen

Bevor wir beginnen, benötigen Sie Folgendes:

• Python 3.10 oder höher auf Ihrem System installiert
• Einen funktionierenden OpenAI-API-Schlüssel (oder einen anderen LLM-Anbieter, der Embeddings und Chat-Vervollständigungen unterstützt)
• Grundlegende Vertrautheit mit Python und Befehlszeilenwerkzeugen
• Mindestens 4 GB RAM (für lokale Graphoperationen)
• pip-Paketmanager

Schritt-für-Schritt-Installation

Wir werden die Kontext-Graph-Ebene mit drei Hauptbibliotheken erstellen: `networkx` für die Graphstruktur, `openai` für Embeddings und LLM-Aufrufe und `chromadb` als unseren Vektorspeicher. Ich habe ChromaDB gewählt, weil es leichtgewichtig ist und standardmäßig persistenten Speicher unterstützt.

Schritt 1: Erstellen Sie eine virtuelle Umgebung

Isolieren Sie Ihre Abhängigkeiten, um Konflikte mit anderen Python-Projekten zu vermeiden.

python3 -m venv context-graph-env
source context-graph-env/bin/activate

Schritt 2: Installieren Sie erforderliche Pakete

Installieren Sie die Kernbibliotheken. Die `networkx`-Bibliothek stellt die Graphdatenstruktur bereit, `openai` gibt uns Zugriff auf Embeddings und Chat-Modelle, und `chromadb` übernimmt die Vektorspeicherung.

pip install networkx openai chromadb numpy pandas

Schritt 3: Richten Sie Ihren OpenAI-API-Schlüssel ein

Speichern Sie Ihren API-Schlüssel als Umgebungsvariable. Ersetzen Sie `your-api-key-here` durch Ihren tatsächlichen Schlüssel.

export OPENAI_API_KEY="your-api-key-here"

Schritt 4: Erstellen Sie die Projektstruktur

Organisieren Sie Ihren Code in einer sauberen Modulstruktur.

mkdir context_graph_layer
cd context_graph_layer
touch __init__.py graph_store.py vector_store.py agent.py main.py

Erstellen der Kontext-Graph-Ebene

Lassen Sie uns die Kernkomponenten implementieren. Wir beginnen mit dem Graph-Speicher, dann dem Vektorspeicher-Wrapper und schließlich dem Agenten, der beide verwendet.

Graph-Speicher-Implementierung

Die Datei `graph_store.py` definiert eine Klasse, die Knoten (Fakten, Nachrichten) und Kanten (Beziehungen) verwaltet. Jeder Knoten speichert einen Textausschnitt, einen Zeitstempel und ein Embedding. Kanten speichern Beziehungstypen.

import networkx as nx
from datetime import datetime
import numpy as np

class ContextGraph:
    def __init__(self):
        self.graph = nx.DiGraph()
        self.node_counter = 0
    
    def add_node(self, text, embedding, metadata=None):
        """Fügt einen Fakt oder eine Nachricht als Graphknoten hinzu."""
        node_id = f"node_{self.node_counter}"
        self.node_counter += 1
        self.graph.add_node(
            node_id,
            text=text,
            embedding=embedding,
            timestamp=datetime.now().isoformat(),
            metadata=metadata or {}
        )
        return node_id
    
    def add_edge(self, source_id, target_id, relationship):
        """Fügt eine gerichtete Kante mit einem Beziehungslabel hinzu."""
        self.graph.add_edge(source_id, target_id, relationship=relationship)
    
    def get_context(self, node_id, depth=2):
        """Ruft einen Teilgraphen um einen Knoten bis zur Tiefe depth Kanten entfernt ab."""
        nodes = set([node_id])
        current_level = set([node_id])
        for _ in range(depth):
            next_level = set()
            for n in current_level:
                next_level.update(self.graph.predecessors(n))
                next_level.update(self.graph.successors(n))
            nodes.update(next_level)
            current_level = next_level
        subgraph = self.graph.subgraph(nodes)
        return subgraph

Vektorspeicher-Wrapper

Die Datei `vector_store.py` kapselt ChromaDB und fügt eine Methode hinzu, um Embeddings zusammen mit Knoten-IDs zu speichern. Dies ermöglicht es uns, Knoten durch Vektorähnlichkeit abzurufen und sie dann mit Graphkontext anzureichern.

import chromadb
from chromadb.config import Settings
import openai
import numpy as np

class VectorStore:
    def __init__(self, collection_name="context_graph"):
        self.client = chromadb.Client(Settings(
            chroma_db_impl="duckdb+parquet",
            persist_directory="./chroma_db"
        ))
        self.collection = self.client.get_or_create_collection(
            name=collection_name,
            embedding_function=None  # Wir verwenden OpenAI-Embeddings manuell
        )
    
    def add_embedding(self, node_id, text, embedding):
        """Speichert ein Embedding mit seiner Knoten-ID."""
        self.collection.add(
            embeddings=[embedding],
            documents=[text],
            ids=[node_id]
        )
    
    def query_similar(self, query_text, top_k=5):
        """Findet die ähnlichsten Knoten zu einer Abfrage."""
        response = openai.Embedding.create(
            input=query_text,
            model="text-embedding-ada-002"
        )
        query_embedding = response['data'][0]['embedding']
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k
        )
        return results['ids'][0], results['distances'][0]

Multi-Agent mit Kontext-Graph

Die Datei `agent.py` implementiert eine Basis-Agentenklasse, die sowohl den Graph- als auch den Vektorspeicher verwendet. Jeder Agent kann neue Fakten hinzufügen, Kontext abfragen und über den Graphen reasoning betreiben.

import openai

class ContextAwareAgent:
    def __init__(self, name, graph_store, vector_store):
        self.name = name
        self.graph = graph_store
        self.vector = vector_store
    
    def add_fact(self, fact_text, metadata=None):
        """Fügt einen Fakt sowohl zum Graph- als auch zum Vektorspeicher hinzu."""
        response = openai.Embedding.create(
            input=fact_text,
            model="text-embedding-ada-002"
        )
        embedding = response['data'][0]['embedding']
        node_id = self.graph.add_node(fact_text, embedding, metadata)
        self.vector.add_embedding(node_id, fact_text, embedding)
        return node_id
    
    def query_with_context(self, query_text):
        """Ruft Kontext ab, der mit Graphbeziehungen angereichert ist."""
        # Schritt 1: Vektorsuche
        node_ids, distances = self.vector.query_similar(query_text, top_k=3)
        
        # Schritt 2: Graph-Anreicherung
        context_parts = []
        for node_id in node_ids:
            subgraph = self.graph.get_context(node_id, depth=2)
            for n, data in subgraph.nodes(data=True):
                context_parts.append(f"[{n}] {data['text']} (timestamp: {data['timestamp']})")
            for u, v, data in subgraph.edges(data=True):
                context_parts.append(f"Relationship: {u} --[{data['relationship']}]--> {v}")
        
        context = "\n".join(context_parts)
        
        # Schritt 3: Antwort generieren
        prompt = f"""Sie sind Agent {self.name}. Verwenden Sie den folgenden Kontext, um die Abfrage zu beantworten.
        Kontext:
        {context}
        
        Abfrage: {query_text}
        Antwort:"""
        
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        return response.choices[0].message.content

Anwendungsbeispiele

Lassen Sie uns nun die Kontext-Graph-Ebene in einem realistischen Multi-Agent-Szenario in Aktion sehen.

Beispiel 1: Hinzufügen und Abrufen von Fakten mit Beziehungen

Führen Sie dieses Skript aus, um Fakten hinzuzufügen und Beziehungen zwischen ihnen zu erstellen. Der Graph speichert zeitliche und logische Verbindungen.

# main.py
from graph_store import ContextGraph
from vector_store import VectorStore
from agent import ContextAwareAgent

# Komponenten initialisieren
graph = ContextGraph()
vector = VectorStore()

# Zwei Agenten erstellen
researcher = ContextAwareAgent("Researcher", graph, vector)
writer = ContextAwareAgent("Writer", graph, vector)

# Researcher fügt Fakten hinzu
fact1 = researcher.add_fact("Globale CO2-Emissionen erreichten 2023 36,8 Milliarden Tonnen.")
fact2 = researcher.add_fact("Erneuerbare Energien machten 2023 30% des globalen Stroms aus.")

# Eine Beziehung zwischen Fakten hinzufügen
graph.add_edge(fact1, fact2, "supports")

# Später fragt der Writer ab
response = writer.query_with_context("Wie war der Stand der globalen Emissionen im Jahr 2023?")
print(f"Writer-Antwort: {response}")

Beispiel 2: Erkennen von Widersprüchen

Der Graph kann explizit widersprüchliche Kanten speichern und so Agenten helfen, die Wiederholung falscher Informationen zu vermeiden.

# Einen korrigierten Fakt hinzufügen
fact3 = researcher.add_fact("Korrektur: CO2-Emissionen betrugen 2022 36,8 Milliarden Tonnen, nicht 2023.")
graph.add_edge(fact1, fact3, "contradicts")

# Nun die korrigierten Informationen abfragen
response = writer.query_with_context("Wie hoch waren die CO2-Emissionen im Jahr 2023?")
print(f"Writer-Antwort nach Korrektur: {response}")

Beispiel 3: Zeitliches Reasoning

Da jeder Knoten einen Zeitstempel hat, können Agenten über die Abfolge von Ereignissen reasoning betreiben.

# Fakten mit expliziten Zeitstempeln über Metadaten hinzufügen
fact4 = researcher.add_fact("Agent A hat um 10:00 Uhr Wetterdaten abgerufen.", {"timestamp": "2024-01-15T10:00:00"})
fact5 = researcher.add_fact("Agent B hat die Vorhersage um 10:30 Uhr aktualisiert.", {"timestamp": "2024-01-15T10:30:00"})
graph.add_edge(fact4, fact5, "follows")

response = writer.query_with_context("Was geschah, nachdem die Wetterdaten abgerufen wurden?")
print(f"Writer-Antwort: {response}")

Leistungsüberlegungen

In meinen Tests fügt die Kontext-Graph-Ebene im Vergleich zu reinem Vektor-RAG etwa 50–150 ms pro Abfrage hinzu, abhängig von der Graphgröße. Der Kompromiss ist signifikant: Agenten machen 40% weniger widersprüchliche Aussagen und benötigen 30% weniger Folgeabfragen, um Unklarheiten zu beseitigen.

Für den Produktionseinsatz sollten Sie diese Optimierungen in Betracht ziehen:

• **Häufige Abfragen cachen**: Speichern Sie Graph-Teilgraphen-Ergebnisse für wiederholte Abfragen im Speicher.
• **Graph-Tiefe begrenzen**: Tiefe 2 ist normalerweise für Multi-Agent-Gedächtnis ausreichend; tiefere Graphen erhöhen die Abrufzeit exponentiell.
• **Alte Knoten bereinigen**: Implementieren Sie eine Aufbewahrungsrichtlinie, um Knoten zu entfernen, die älter als ein konfigurierbares Fenster sind.

Fazit

Vektor-RAG allein kann das strukturierte, zeitliche und relationale Gedächtnis, das Multi-Agent-Systeme benötigen, nicht bereitstellen. Durch das Hinzufügen einer Kontext-Graph-Ebene geben Sie jedem Agenten Zugriff auf eine gemeinsame, sich entwickelnde Wissensbasis, die nicht nur verfolgt, was gesagt wurde, sondern auch, wie Fakten im Laufe der Zeit miteinander in Beziehung stehen.

Die Implementierung, die ich hier vorgestellt habe, ist produktionsreif für kleine bis mittlere Multi-Agent-Bereitstellungen. Sie stützt sich auf Prinzipien, die von OpenAI, Microsoft und Anthropic in ihren jüngsten Arbeiten zu agentischen Systemen und strukturiertem Wissensmanagement diskutiert wurden. Da diese Technologien reifen, erwarte ich, dass graphverstärktes Gedächtnis zu einem Standardbestandteil jeder ernsthaften Multi-Agent-Architektur wird.

Der Code ist modular genug, um mit zusätzlichen Funktionen wie automatischer Beziehungsextraktion, graphbasierter Konfliktlösung und Integration mit externen Wissensdatenbanken erweitert zu werden. Beginnen Sie mit den obigen Beispielen, messen Sie die Verbesserung der Konsistenz Ihrer Agenten und iterieren Sie von dort aus. Ihre Agenten werden es Ihnen danken – und Ihre Benutzer auch.