Hey! We're Paul, Preston, and Daniel from Zep AI. We've just open-sourced Graphiti, a Python library for building temporal Knowledge Graphs using LLMs.

https://youtu.be/sygRBjILDn8

Graphiti helps you create and query graphs that evolve over time. Think of a knowledge graph as a network of interconnected facts, such as “Kendra loves Adidas shoes.” Each fact is a “triplet, represented by two entities, or nodes (”Kendra,” “Adidas shoes”), and their relationship, or edge (”loves”). Knowledge Graphs have been explored extensively for information retrieval. What makes Graphiti unique is its ability to autonomously build a knowledge graph while handling changing relationships and maintaining historical context.

At Zep, we build a memory layer for LLM applications. Developers use Zep to recall relevant user information from past conversations without including the entire chat history in a prompt. Accurate context is crucial for LLM applications. If an AI agent doesn't remember that you've changed jobs or confuses the chronology of events, its responses can be jarring or irrelevant, or worse, inaccurate.

Zep’s Suboptimal Fact Pipeline

Before Graphiti, our approach to storing and retrieving user “memory” was, in effect, a specialized RAG pipeline. An LLM extracted “facts” from a user’s chat history. Semantic search, reranking, and other techniques then surfaced facts relevant to the current conversation back to a developer for inclusion in their prompt.

Unfortunately, this approach became problematic. Reconciling facts from increasingly complex conversations challenged even frontier LLMs such as gpt-4o. We saw incomplete facts, poor recall, and hallucinations. Our RAG search also failed at times to capture the nuanced relationships between facts, leading to irrelevant or contradictory information being retrieved.

We tried fixing these issues with prompt optimization but saw diminishing returns on effort. We realized that a graph would help model a user’s complex world, potentially addressing these challenges.

Building Graphiti

We were intrigued by Microsoft’s GraphRAG, which expanded on RAG text chunking with a graph to better model a document corpus. However, it didn't solve our core problem: GraphRAG is designed for static documents and doesn't natively handle temporality.

So, we built Graphiti, a temporal Knowledge Graph library, which is designed from the ground up to handle constantly changing information, hybrid semantic and graph search, and scale:

• Temporal Awareness: Tracks changes in facts and relationships over time. Graph edges include temporal metadata to record relationship lifecycles.
• Episodic Processing: Ingests data as discrete episodes, maintaining data provenance and enabling incremental processing.
• Hybrid Search: Semantic and BM25 full-text search, with the ability to rerank results by distance from a central node.
• Scalable: Designed for large datasets, parallelizing LLM calls for batch processing while preserving event chronology.
• Varied Sources: Ingests both unstructured text and structured data.

Getting Started

Graphiti is open-source and available on GitHub: https://git.new/graphiti

Quick Start: pip install graphiti-core

While we developed Graphiti for our needs at Zep, we believe it could be useful for any application dealing with evolving, interconnected data, such as:

• Personal AI assistants that need to maintain user context over time
• Knowledge management systems for rapidly changing domains
• Social network analysis tools
• Financial systems tracking changing relationships and transactions

If you try, we'd love to hear your thoughts, questions, and experiences. Please also consider contributing!