Temporaler Wissensgraph: Wie KI-Agenten wissen, was gerade gilt

Ein temporaler Wissensgraph ist ein Wissensgraph, in dem jeder Fakt Zeit trägt: wann er in der Welt galt und wann das System ihn erfahren hat. Widerspricht ein neuer Fakt einem alten, wird der alte geschlossen und nicht gelöscht. Ein KI-Agent kann dann fragen, was heute gilt, und eine Prüferin kann fragen, was der Agent an einem bestimmten Tag wusste.

Diese eine Eigenschaft entscheidet, ob ein Agent aus dem aktuellen Stand Ihres Unternehmens antwortet oder aus der Passage, die der Frage am meisten ähnelt.

Das Problem: ähnlich ist nicht aktuell

Nehmen Sie einen Kunden, dessen Ansprechpartner im Juni gewechselt hat. Die E-Mail aus dem März nennt Jana Keller, das Ticket aus dem Juni nennt Tom Berger. Eine Vektorsuche nach „Wer ist der Ansprechpartner bei Acme“ liefert beide Passagen, weil beide der Frage ähneln. Das Modell wählt dann eine, meist die, die überzeugter klingt, und nichts im gefundenen Text sagt, welche noch stimmt.

Dokumente laufen nicht ab. Fakten schon. Jedes System, das einen Agenten aus Chat, Tickets, Wiki und CRM versorgt, stößt innerhalb weniger Wochen darauf, weil diese Quellen voller Entscheidungen sind, die später revidiert wurden.

So funktioniert er: Fakten mit zwei Uhren

Ein temporaler Wissensgraph speichert drei Arten von Dingen:

• Entitäten sind die Knoten: ein Kunde, eine Person, ein Projekt, ein System.
• Fakten sind die Kanten zwischen Entitäten, in Klartext, etwa „Tom Berger ist Ansprechpartner von Acme für den Rollout“.
• Episoden sind die Rohdaten, aus denen die Fakten stammen: ein Ticket-Kommentar, eine Meeting-Notiz, eine CRM-Änderung. Jeder Fakt verweist auf seine Episoden.

Jeder Fakt trägt zwei Zeitachsen. Die Gültigkeitszeit sagt, wann der Fakt in der Welt galt. Die Erfassungszeit sagt, wann das System ihn gespeichert hat und wann es aufgehört hat, ihn als aktuell zu behandeln. Ein Modell mit beiden Achsen heißt bitemporal. In Graphiti trägt jede Faktkante dafür vier Zeitstempel: valid_at und invalid_at für die Welt, created_at und expired_at für das System.

Kommt das Ticket aus dem Juni an, überschreibt der Graph nichts. Er legt den neuen Fakt an und schließt den alten:

Eine Abfrage nach dem aktuellen Stand liefert die zweite Zeile. Eine Abfrage zum Stand 1. Mai liefert die erste. Beide Antworten tragen ihre Quelle, sodass eine Person die E-Mail oder das Ticket öffnen und prüfen kann.

Temporaler Wissensgraph, Vektor-RAG und GraphRAG im Vergleich

GraphRAG von Microsoft baut Community-Zusammenfassungen über eine Dokumentensammlung und passt zu Fragen über die Sammlung als Ganzes. Ein temporaler Wissensgraph passt zu Fragen nach dem aktuellen Stand von Dingen, die sich laufend ändern: Kunden, Projekte, Systeme, Entscheidungen.

Wie Graphiti ihn baut

Graphiti ist ein quelloffenes Framework für temporale Wissensgraphen von Zep, unter der Apache-2.0-Lizenz, im September 2026 in Version 0.30.2 und mit rund 30.800 GitHub-Sternen. Die Teile, auf die es für einen Agenten ankommt:

• Episoden rein, Fakten raus. Sie fügen eine Episode (Text, eine Nachricht oder JSON) mit einem Referenzzeitpunkt hinzu. Ein Sprachmodell extrahiert Entitäten und Fakten, gleicht sie mit dem ab, was der Graph schon weiß, und schließt Fakten, denen die neue Episode widerspricht. Entitäts- und Kantentypen lassen sich mit Pydantic-Modellen vorgeben oder aus den Daten entstehen.
• Hybride Suche ohne Modell auf dem Lesepfad. Die Suche kombiniert Embeddings, BM25-Stichwortsuche und Graph-Traversierung, optional mit Neusortierung nach Graph-Distanz, und liefert Fakten statt einer generierten Zusammenfassung.
• Backends. Neo4j ab 5.26, FalkorDB ab 1.1.2 und Amazon Neptune. Der Kuzu-Treiber ist abgekündigt, weil das Upstream-Projekt nicht mehr gepflegt wird.
• Modelle. Standardmäßig OpenAI, mit Clients für Azure OpenAI, Anthropic, Google Gemini und Groq sowie für jeden OpenAI-kompatiblen Endpunkt wie Ollama oder vLLM. Das README sagt deutlich, dass Graphiti am besten mit Modellen läuft, die strukturierte Ausgaben beherrschen, und dass kleinere Modelle zu Fehlern bei der Übernahme führen.
• Zwei Voreinstellungen, die Sie kennen sollten. Anonyme Telemetrie ist standardmäßig an und lässt sich mit GRAPHITI_TELEMETRY_ENABLED=false abschalten. Der offizielle MCP-Server bietet Werkzeuge zum Schreiben und Löschen an, darunter eines, das eine ganze Gruppe leert.

Ein minimaler Durchlauf:

import asyncio
from datetime import datetime, timezone

from graphiti_core import Graphiti
from graphiti_core.nodes import EpisodeType


async def main():
    graphiti = Graphiti("bolt://localhost:7687", "neo4j", "password")
    await graphiti.build_indices_and_constraints()

    await graphiti.add_episode(
        name="jira-kommentar-4711",
        episode_body="Ab heute ist Tom Berger Ansprechpartner von Acme für den Rollout. "
                     "Jana Keller ist in den Einkauf gewechselt.",
        source=EpisodeType.text,
        source_description="Jira-Kommentar",
        reference_time=datetime(2026, 6, 3, tzinfo=timezone.utc),
    )

    for edge in await graphiti.search("Wer ist Ansprechpartner von Acme für den Rollout?"):
        print(edge.fact, edge.valid_at, edge.invalid_at)

    await graphiti.close()


asyncio.run(main())

Den Vergleich mit Mem0 und den Betrieb in Produktion beschreibe ich auf Englisch: Graphiti vs Mem0 und Graphiti in production.

Was der Betrieb kostet

Die Leseseite ist günstig. Die Kosten sitzen auf der Schreibseite: Jede Episode bedeutet Modellaufrufe für die Extraktion und für den Abgleich von Entitäten und Fakten mit dem bestehenden Graphen, und dieser Kontext wächst mit dem Graphen. Im Issue-Tracker von Graphiti gibt es Threads zu hohen Übernahmekosten und zu Abgleich-Prompts, die mit der Zahl der Knoten wachsen. Planen Sie dafür:

• Bündeln, was warten kann. Eine nächtliche Übernahme eines Wiki-Bereichs kostet dasselbe wie eine laufende und ist leichter zu überwachen.
• Anfangs mit wenig Parallelität fahren. Graphiti startet bewusst mit niedriger Parallelität, um unter den Rate-Limits der Anbieter zu bleiben; erhöhen Sie sie, sobald Sie Ihr Kontingent kennen.
• Das Extraktionsmodell nach strukturierter Ausgabe wählen, nicht nur nach Preis. Ein günstiges Modell, das fehlerhaftes JSON liefert, kostet in Wiederholungen und verlorenen Fakten mehr als ein Modell der Mittelklasse, das dem Schema folgt.
• Die Embedding-Breite ausdrücklich setzen. Ein lokaler Embedder wie nomic-embed-text liefert 768 Dimensionen, graphiti-core nimmt ohne EMBEDDING_DIM aber 1.024 an, und eine Abweichung verdirbt jeden geschriebenen Vektor ohne Fehlermeldung.

Wann ein temporaler Wissensgraph das falsche Werkzeug ist

• Statische Referenztexte wie Handbücher und Richtlinien: Einfache Suche ist schlanker und günstiger.
• Gedächtnis innerhalb einer Unterhaltung: Das Kontextfenster hält es bereits.
• Zahlen und Aggregate: Ein Data Warehouse beantwortet „Umsatz pro Quartal“ besser als jeder Graph aus Fakten.

Setzen Sie einen ein, wenn Fakten sich ändern, wenn zwei Quellen sich widersprechen können und wenn jemand fragen wird „seit wann“ oder „wer sagt das“.

Drei Regeln aus dem Betrieb

Ich betreibe temporale Wissensgraphen in zwei Umgebungen: die operative Kontextschicht eines Unternehmens auf dessen eigenem Cloud-Tenant und meine eigenen Arbeitsgraphen auf FalkorDB, dazu ein LadybugDB-Graph in einer einzigen Datei auf meinem Laptop. Drei Regeln sind aus beiden entstanden:

1. Der Agent schlägt vor, eine Person gibt frei. Ein Datensatz aus einem führenden System, mit eigener Quell-ID, darf automatisch übernommen werden. Eine Interpretation wie „dieser Kunde ist gefährdet“ wartet in einer Warteschlange auf eine Person. Schreibzugriffe laufen über einen eigenen Befehl, nie über die Werkzeuge, mit denen der Agent liest.
2. Auf dem Lesepfad wird nichts generiert. Der Agent bekommt Fakten mit Gültigkeitszeitraum und Quelle, und das Modell formuliert nur die Antwort. Das hält Antworten prüfbar und das Lesen schnell.
3. Lesen und Schreiben auf denselben Stand festlegen. Halten Sie Leser und Schreiber auf derselben graphiti-core-Version, und nehmen Sie die Embeddings der Abfrage vom selben Embedding-Modell, auf dieselbe Weise ausgeliefert, das den Index gebaut hat. In meinen Graphen lieferte ein Leser, der eine Patch-Version hinter dem Schreiber lag, gar keine Ergebnisse, ohne Fehlermeldung. Und dasselbe Embedding-Modell aus zwei verschiedenen Ollama-Builds erzeugte Vektoren mit einer Kosinus-Ähnlichkeit von nur 0,80 zueinander, genug, um Treffer zu verlieren.

Diese Regeln stecken in Graphiti Local, der quelloffenen Schnittstelle, die ich pflege: sechs reine Lese-Werkzeuge über MCP, eine kg-Kommandozeile und ein Schreibpfad, der auf eine Person wartet. In der Arbeit mit Kunden werden sie zur Kontextschicht für KI-Agenten: dieselbe Art Graph, gespeist aus den Systemen, die ein Unternehmen schon betreibt, auf dessen eigenem Tenant.

Graphiti Local ist ein unabhängiges Community-Projekt auf Basis von Graphiti. Es steht in keiner Verbindung zu Zep und wird von Zep weder unterstützt noch empfohlen. Versionen und Zahlen mit Stand 11. September 2026.