docs: update README for real-time capabilities and GraphRAG comparison (#299)

* update intro and add graphrag

* small nits
This commit is contained in:
Daniel Chalef 2025-03-22 09:41:42 -07:00 committed by GitHub
parent d91aaa052c
commit f00fb2a8a0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -7,7 +7,7 @@
<h1 align="center">
Graphiti
</h1>
<h2 align="center"> Temporal Knowledge Graphs for Agentic Applications</h2>
<h2 align="center"> Build Real-Time Knowledge Graphs for AI Agents</h2>
<br />
[![Discord](https://dcbadge.vercel.app/api/server/W8Kw6bsgXQ?style=flat)](https://discord.com/invite/W8Kw6bsgXQ)
@ -19,9 +19,13 @@ Graphiti
:star: _Help us reach more developers and grow the Graphiti community. Star this repo!_
<br />
Graphiti builds dynamic, temporally aware Knowledge Graphs that represent complex, evolving relationships between
entities over time. Graphiti ingests both unstructured and structured data, and the resulting graph may be queried using
a fusion of time, full-text, semantic, and graph algorithm approaches, effectively serving as a powerful memory layer for AI applications.
Graphiti is a framework for building and querying temporally-aware knowledge graphs, specifically tailored for AI agents operating in dynamic environments. Unlike traditional retrieval-augmented generation (RAG) methods, Graphiti continuously integrates user interactions, structured and unstructured enterprise data, and external information into a coherent, queryable graph. The framework supports incremental data updates, efficient retrieval, and precise historical queries without requiring complete graph recomputation, making it suitable for developing interactive, context-aware AI applications.
Use Graphiti to:
- Integrate and maintain dynamic user interactions and business data.
- Facilitate state-based reasoning and task automation for agents.
- Query complex, evolving data with semantic, keyword, and graph-based search methods.
<br />
@ -31,23 +35,14 @@ a fusion of time, full-text, semantic, and graph algorithm approaches, effective
<br />
Graphiti helps you create and query Knowledge Graphs that evolve over time. A knowledge graph is a network of
interconnected facts, such as _“Kendra loves Adidas shoes.”_ Each fact is a “triplet” represented by two entities, or
A knowledge graph is 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.
With Graphiti, you can build LLM applications such as:
- Assistants that learn from user interactions, fusing personal knowledge with dynamic data from business systems like
CRMs and billing platforms through robust conversation history management.
- Agents that autonomously execute complex tasks, reasoning with state changes from multiple dynamic sources through persistent memory.
Graphiti supports a wide range of applications in sales, customer service, health, finance, and more, enabling long-term recall and state-based reasoning for both assistants and agents.
## Graphiti and Zep Memory
Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.
Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for AI Agents.
Using Graphiti, we've demonstrated Zep is
the [State of the Art in Agent Memory](https://blog.getzep.com/state-of-the-art-agent-memory/).
@ -62,28 +57,35 @@ We're excited to open-source Graphiti, believing its potential reaches far beyon
## Why Graphiti?
We were intrigued by Microsoft's GraphRAG, which expanded on RAG (Retrieval-Augmented Generation) text chunking by using a graph to better model a
document corpus and making this representation available via semantic and graph search techniques. However, GraphRAG did
not address our core problem: It's primarily designed for static documents and doesn't inherently handle temporal
aspects of data.
Traditional RAG approaches often rely on batch processing and static data summarization, making them inefficient for frequently changing data. Graphiti addresses these challenges by providing:
Graphiti 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, enabling point-in-time queries. Graph
edges include temporal metadata to record relationship lifecycles, creating a comprehensive context window extension.
- **Episodic Processing:** Ingests data as discrete episodes, maintaining data provenance and allowing incremental
entity and relationship extraction, ideal for chat state management.
- **Hybrid Search:** Combines semantic and BM25 full-text search, with the ability to rerank results by distance from a
central node e.g. "Kendra".
- **Scalable:** Designed for processing large datasets, with parallelization of LLM calls for bulk processing while
preserving the chronology of events and enabling efficient knowledge retrieval.
- **Supports Varied Sources:** Can ingest both unstructured text and structured JSON data.
- **Real-Time Incremental Updates:** Immediate integration of new data episodes without batch recomputation.
- **Bi-Temporal Data Model:** Explicit tracking of event occurrence and ingestion times, allowing accurate point-in-time queries.
- **Efficient Hybrid Retrieval:** Combines semantic embeddings, keyword (BM25), and graph traversal to achieve low-latency queries without reliance on LLM summarization.
- **Custom Entity Definitions:** Flexible ontology creation and support for developer-defined entities through straightforward Pydantic models.
- **Scalability:** Efficiently manages large datasets with parallel processing, suitable for enterprise environments.
<p align="center">
<img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">
</p>
## Graphiti vs. GraphRAG
| Aspect | GraphRAG | Graphiti |
| -------------------------- | ------------------------------------- | ------------------------------------------------ |
| **Primary Use** | Static document summarization | Dynamic data management |
| **Data Handling** | Batch-oriented processing | Continuous, incremental updates |
| **Knowledge Structure** | Entity clusters & community summaries | Episodic data, semantic entities, communities |
| **Retrieval Method** | Sequential LLM summarization | Hybrid semantic, keyword, and graph-based search |
| **Adaptability** | Low | High |
| **Temporal Handling** | Basic timestamp tracking | Explicit bi-temporal tracking |
| **Contradiction Handling** | LLM-driven summarization judgments | Temporal edge invalidation |
| **Query Latency** | Seconds to tens of seconds | Typically sub-second latency |
| **Custom Entity Types** | No | Yes, customizable |
| **Scalability** | Moderate | High, optimized for large datasets |
Graphiti is specifically designed to address the challenges of dynamic and frequently updated datasets, making it particularly suitable for applications requiring real-time interaction and precise historical queries.
## Installation
Requirements:
@ -258,6 +260,7 @@ Graphiti is under active development. We aim to maintain API stability while wor
- Allow developers to provide their own defined node and edge classes when ingesting episodes
- Enable more flexible knowledge representation tailored to specific use cases
- [x] Enhancing retrieval capabilities with more robust and configurable options
- [ ] Graphiti MCP Server
- [ ] Expanding test coverage to ensure reliability and catch edge cases
## Contributing