This assumes you already have Graphiti installed and connected to a graph database. If not, start with the knowledge-graph setup guide — here we look at the agent integration.

Why is a vector store not enough for agent memory?

A vector store returns the most similar text regardless of when it was written. Ask “what plan is the customer on?” and it can return both the old plan and the new one, leaving the model to guess. Temporal graphs rank by recency and validity, so outdated facts are filtered out rather than mixed in.

How do you wire Graphiti into an agent loop?

1. After each user turn, add the turn as an episode.
2. Before answering, query the graph for relevant, currently-valid facts.
3. Inject those facts into the model’s context as structured notes.
4. Let the model answer; store the reply as the next episode.

The graph grows with the conversation and stays current without re-summarizing history.

How do you handle facts that change?

When a new episode contradicts an old edge, Graphiti invalidates the old one instead of deleting it. You can ask “what was the plan last quarter?” and still get the historical answer, while current queries see only the fresh value. This history is exactly what a summary-based memory loses.

How do you control cost and noise?

• Don’t ingest everything — store decisions and state changes, not chit-chat.
• Batch episodes where you can, since extraction costs tokens per episode.
• Prune entities the agent never queries.
• Use a smaller, cheaper model for extraction if your accuracy tolerates it.

How do you retrieve the right facts?

Use hybrid search: semantic similarity to find candidate entities, plus graph traversal to pull in their relationships, plus a time filter to keep only valid edges. Then cap the number of facts you inject — flooding the context with 50 facts hurts answer quality more than it helps.

What are the limitations?

You now run a graph database alongside your app, and extraction can misread ambiguous statements, planting wrong edges. The system is as good as the data you feed it. For a short-lived chat assistant, this is more machinery than the problem needs; for an agent that tracks a customer or project over months, it pays off.

Key Takeaways

• Graphiti gives agents time-aware memory that filters out stale facts.
• Add each turn as an episode; query valid facts before answering.
• Superseded facts are invalidated, not deleted, keeping history queryable.
• Ingest sparingly and cap injected facts to protect quality.
• Overkill for short chats; valuable for long-lived agent state.

Last updated October 2026. More at Graphiti.

It is Python, runs against Neo4j or FalkorDB, and pairs with a Neo4j graph database you host yourself. If you are building memory for an agent that needs to reason about state over time — subscriptions, org charts, inventory — Graphiti is built for exactly that.

What is Graphiti?

Graphiti is a library that ingests data as “episodes” and extracts entities and relationships into a graph, timestamping each fact. It supports incremental updates, so new episodes merge into the existing graph, and hybrid search that mixes semantic and keyword retrieval.

What do you need before starting?

• Python 3.10 or newer.
• A running Neo4j (or FalkorDB) instance with credentials.
• An LLM API key for entity extraction (OpenAI or compatible).
• Optionally an embedding model for semantic search.

Neo4j Aura’s free tier works for testing.

How do you install and connect?

1. pip install graphiti-core
2. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD in your environment.
3. Set your model API key.
4. Initialize the client pointed at the graph.
5. Build indexes once before the first ingest.

Index building takes a bit the first time, then ingests are fast.

How do you add data?

You add episodes — text, JSON or message objects. Graphiti runs entity extraction, links new nodes to existing ones, and records when each relationship became valid. Point it at a stream of updates (a CRM feed, a changelog) and it keeps the graph current instead of rebuilding it.

How do you query it?

Search combines semantic similarity with keyword and graph traversal. You can ask for an entity and get its current relationships, or ask a time-bounded question and get only facts valid in that window. This temporal filter is the part that separates it from a plain vector store, which would return stale chunks alongside fresh ones.

What are the trade-offs?

You run and pay for a graph database, and entity extraction costs LLM tokens per episode, so ingesting everything is expensive. Noisy input produces a noisy graph. It also adds real complexity — for a simple FAQ bot, a vector database is easier and cheaper. Graphiti earns its keep when relationships and time matter.

Key Takeaways

• Graphiti builds temporally-aware knowledge graphs for AI agents.
• Every edge has a validity window; old facts are invalidated, not deleted.
• Needs Python 3.10+, Neo4j/FalkorDB and an LLM key.
• Ingests data as episodes with incremental updates.
• Worth it when time and relationships matter; overkill for simple search.

Last updated October 2026. Details at Graphiti.