What is Graphiti MCP Server?

Graphiti MCP Server is a coding tool. MCP server from Zep exposing Graphiti temporal knowledge graphs as agent memory.

What is Graphiti MCP Server best for?

ai-agents, mcp-server, memory. It is filed under Coding.

Graphiti MCP Server · Scriptiii AI Tools

Component	What it stores
Entities (nodes)	People, products, policies, concepts — with summaries that evolve over time
Facts / Relationships (edges)	Triplets (Entity → Relationship → Entity) with temporal validity windows
Episodes (provenance)	Raw data as ingested — the ground truth stream. Every derived fact traces back here
Custom Types (ontology)	Developer-defined entity and edge types via Pydantic models

Aspect	Zep	Graphiti
What it is	The unified context layer for enterprises	An open-source framework for building temporal context graphs
Scope	Unifies data from across an enterprise into governed context and serves it to agents	Builds and queries graphs inside your own application
Context graphs	Manages millions of context graphs with governance	Builds and queries the graphs you define
Graph database	Konig, Zep's graph database service, built for millions of context graphs with low-latency retrieval; no third-party graph database required	Bring your own: Neo4j, FalkorDB, or Amazon Neptune
Users, threads, and ingestion	Built-in users, threads, and ingestion for messages and business data	Build your own
Retrieval & performance	Pre-configured, production-ready retrieval with sub-200ms performance at scale	Custom implementation required; performance depends on your setup
Developer tools	Dashboard with graph visualization, debug logs, API logs; CLI; SDKs for Python, TypeScript, and Go	Build your own tools
Enterprise features	SLAs, support, security guarantees	Self-managed
Deployment	Fully managed or in your cloud (BYOC)	Self-hosted only

Aspect	GraphRAG	Graphiti
Primary Use	Static document summarization	Dynamic, evolving temporal knowledge graphs
Data Handling	Batch-oriented processing	Continuous, incremental updates
Knowledge Structure	Entity clusters & community summaries	Temporal context graph — entities, facts with validity windows, episodes, 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 with automatic fact invalidation
Contradiction Handling	LLM-driven summarization judgments	Automatic fact invalidation with temporal history preserved
Query Latency	Seconds to tens of seconds	Typically sub-second latency
Custom Entity Types	No	Yes, customizable via Pydantic models
Scalability	Moderate	High, optimized for large datasets

[!TIP]
The simplest way to install Neo4j is via Neo4j Desktop. It provides a user-friendly
interface to manage Neo4j instances and databases.
Alternatively, you can use FalkorDB on-premises via Docker and instantly start with the quickstart example:
docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest

pip install graphiti-core[falkordb]

## or with uv
uv add graphiti-core[falkordb]

## or embedded version (requires Python 3.12+)
pip install graphiti-core[falkordblite]
## or with uv
uv add graphiti-core[falkordblite]

## Install with Anthropic support
pip install graphiti-core[anthropic]

## Install with Groq support
pip install graphiti-core[groq]

## Install with Google Gemini support
pip install graphiti-core[google-genai]

## Install with multiple providers
pip install graphiti-core[anthropic,groq,google-genai]

## Install with FalkorDB and LLM providers
pip install graphiti-core[falkordb,anthropic,google-genai]

## Install with Amazon Neptune
pip install graphiti-core[neptune]

Neo4j Docker:
```
docker compose up
```
This will start the Neo4j Docker service and related components.
FalkorDB Docker:
```
docker compose --profile falkordb up
```
This will start the FalkorDB Docker service and related components.

from graphiti_core import Graphiti
from graphiti_core.driver.neo4j_driver import Neo4jDriver

## Create a Neo4j driver with custom database name
driver = Neo4jDriver(
    uri="bolt://localhost:7687",
    user="neo4j",
    password="password",
    database="my_custom_database"  # Custom database name
)

## Pass the driver to Graphiti
graphiti = Graphiti(graph_driver=driver)

from graphiti_core import Graphiti
from graphiti_core.driver.falkordb_driver import FalkorDriver

## Create a FalkorDB driver with custom database name
driver = FalkorDriver(
    host="localhost",
    port=6379,
    username="falkor_user",  # Optional
    password="falkor_password",  # Optional
    database="my_custom_graph"  # Custom database name
)

## Or use embedded FalkorDB Lite (requires Python 3.12+)
## from redislite.async_falkordb_client import AsyncFalkorDB
## falkordb_client = AsyncFalkorDB(dbfilename='/path/to/database.db')
## driver = FalkorDriver(falkor_db=falkordb_client)

## Pass the driver to Graphiti
graphiti = Graphiti(graph_driver=driver)

from graphiti_core import Graphiti
from graphiti_core.driver.kuzu_driver import KuzuDriver

## Create a Kuzu driver
driver = KuzuDriver(db="/tmp/graphiti.kuzu")

## Pass the driver to Graphiti
graphiti = Graphiti(graph_driver=driver)

from graphiti_core import Graphiti
from graphiti_core.driver.neptune_driver import NeptuneDriver

## Create a Neptune driver
driver = NeptuneDriver(
    host='<NEPTUNE_ENDPOINT>',
    aoss_host='<AMAZON_OPENSEARCH_SERVERLESS_HOST>',
    port=8182,      # Optional, defaults to 8182
    aoss_port=443,  # Optional, defaults to 443
)

## Pass the driver to Graphiti
graphiti = Graphiti(graph_driver=driver)

from openai import AsyncOpenAI
from graphiti_core import Graphiti
from graphiti_core.llm_client.azure_openai_client import AzureOpenAILLMClient
from graphiti_core.llm_client.config import LLMConfig
from graphiti_core.embedder.azure_openai import AzureOpenAIEmbedderClient

## Initialize Azure OpenAI client using the standard OpenAI client
## with Azure's v1 API endpoint
azure_client = AsyncOpenAI(
    base_url="https://your-resource-name.openai.azure.com/openai/v1/",
    api_key="your-api-key",
)

## Create LLM and Embedder clients
llm_client = AzureOpenAILLMClient(
    azure_client=azure_client,
    config=LLMConfig(model="gpt-5-mini", small_model="gpt-5-mini")  # Your Azure deployment name
)
embedder_client = AzureOpenAIEmbedderClient(
    azure_client=azure_client,
    model="text-embedding-3-small"  # Your Azure embedding deployment name
)

## Initialize Graphiti with Azure OpenAI clients
graphiti = Graphiti(
    "bolt://localhost:7687",
    "neo4j",
    "password",
    llm_client=llm_client,
    embedder=embedder_client,
)

## Now you can use Graphiti with Azure OpenAI

from graphiti_core import Graphiti
from graphiti_core.llm_client.gemini_client import GeminiClient, LLMConfig
from graphiti_core.embedder.gemini import GeminiEmbedder, GeminiEmbedderConfig
from graphiti_core.cross_encoder.gemini_reranker_client import GeminiRerankerClient

## Google API key configuration
api_key = "<your-google-api-key>"

## Initialize Graphiti with Gemini clients
graphiti = Graphiti(
    "bolt://localhost:7687",
    "neo4j",
    "password",
    llm_client=GeminiClient(
        config=LLMConfig(
            api_key=api_key,
            model="gemini-2.0-flash"
        )
    ),
    embedder=GeminiEmbedder(
        config=GeminiEmbedderConfig(
            api_key=api_key,
            embedding_model="embedding-001"
        )
    ),
    cross_encoder=GeminiRerankerClient(
        config=LLMConfig(
            api_key=api_key,
            model="gemini-2.5-flash-lite"
        )
    )
)

## Now you can use Graphiti with Google Gemini for all components

from graphiti_core import Graphiti
from graphiti_core.llm_client.config import LLMConfig
from graphiti_core.llm_client.openai_generic_client import OpenAIGenericClient
from graphiti_core.embedder.openai import OpenAIEmbedder, OpenAIEmbedderConfig
from graphiti_core.cross_encoder.openai_reranker_client import OpenAIRerankerClient

## Configure Ollama LLM client
llm_config = LLMConfig(
    api_key="ollama",  # Ollama doesn't require a real API key, but some placeholder is needed
    model="deepseek-r1:7b",
    small_model="deepseek-r1:7b",
    base_url="http://localhost:11434/v1",  # Ollama's OpenAI-compatible endpoint
)

llm_client = OpenAIGenericClient(config=llm_config)

## Initialize Graphiti with Ollama clients
graphiti = Graphiti(
    "bolt://localhost:7687",
    "neo4j",
    "password",
    llm_client=llm_client,
    embedder=OpenAIEmbedder(
        config=OpenAIEmbedderConfig(
            api_key="ollama",  # Placeholder API key
            embedding_model="nomic-embed-text",
            embedding_dim=768,
            base_url="http://localhost:11434/v1",
        )
    ),
    cross_encoder=OpenAIRerankerClient(client=llm_client, config=llm_config),
)

## Now you can use Graphiti with local Ollama models

from graphiti_core import Graphiti
from graphiti_core.prompts import ChatPrompt, SystemMessage, UserMessage, create_prompt_library

def custom_extract_message(context: dict) -> ChatPrompt:
    return ChatPrompt(
        system=SystemMessage(content='Extract entities for my domain.'),
        user=UserMessage(content=str(context.get('episode_content', ''))),
    )

prompt_library = create_prompt_library({
    'extract_nodes': {
        'extract_message': custom_extract_message,
    },
})

graphiti = Graphiti(..., prompt_library=prompt_library)

from typing import Literal

from graphiti_core import Graphiti
from graphiti_core.llm_client.anthropic_client import AnthropicClient
from graphiti_core.llm_client import (
    LLMRuntime,
    LLMTransport,
    OpenAIClient,
    PromptRoutes,
)

OpenAIModels = Literal['gpt-5.1', 'gpt-5-nano']
openai = LLMTransport[OpenAIModels](
    OpenAIClient(),
    models=['gpt-5.1', 'gpt-5-nano'],
)

AnthropicModels = Literal['claude-sonnet-5', 'claude-haiku-5-5']
anthropic = LLMTransport[AnthropicModels](
    AnthropicClient(),
    models=['claude-sonnet-5', 'claude-haiku-5-5'],
)

main = openai.model('gpt-5.1')
nano = openai.model('gpt-5-nano')
haiku = anthropic.model('claude-haiku-5-5')
runtime = LLMRuntime(
    model=main,
    routes=PromptRoutes(
        extract_nodes=PromptRoutes.ExtractNodes(extract_attributes=nano),
        dedupe_edges=PromptRoutes.DedupeEdges(
            resolve_edge=haiku,
        ),
    ),
)

graphiti = Graphiti(..., llm_runtime=runtime)

from graphiti_core import Graphiti
from graphiti_core.llm_client import (
    JevClient,
    LLMRuntime,
    LLMTransport,
    OpenAIClient,
    PromptRoutes,
    jev_prompt_overrides,
)

openai = LLMTransport(OpenAIClient(), models=['gpt-6-luna'])
jev = LLMTransport(JevClient(), models=['jev-latest'])
jev_dedupe = jev.model('jev-latest', prompt_overrides=jev_prompt_overrides())

runtime = LLMRuntime(
    model=openai.model('gpt-6-luna'),
    routes=PromptRoutes(
        dedupe_nodes=PromptRoutes.DedupeNodes(nodes=jev_dedupe),
        dedupe_edges=PromptRoutes.DedupeEdges(resolve_edge=jev_dedupe),
    ),
)
graphiti = Graphiti(..., llm_runtime=runtime)

## For bash users (~/.bashrc or ~/.bash_profile)
echo 'export GRAPHITI_TELEMETRY_ENABLED=false' >> ~/.bashrc

## For zsh users (~/.zshrc)
echo 'export GRAPHITI_TELEMETRY_ENABLED=false' >> ~/.zshrc

Graphiti MCP Server

What it does

Graphiti

A Framework for Building Temporal Knowledge Graphs

Graphiti MCP Server

What it does

Graphiti

A Framework for Building Temporal Knowledge Graphs

What is a Context Graph?

Graphiti and Zep

Zep vs Graphiti

When to choose which

Why Graphiti?

Graphiti vs. GraphRAG

Installation

Installing with FalkorDB Support

Installing with Kuzu Support

Installing with Amazon Neptune Support

You can also install optional LLM providers as extras:

Default to Low Concurrency; LLM Provider 429 Rate Limit Errors

Quick Start

Running with Docker Compose

Reference MCP and REST servers

MCP Server

REST Service

Optional Environment Variables

Database Configuration

Neo4j with Custom Database Name

FalkorDB with Custom Database Name

Kuzu

Amazon Neptune

Using Graphiti with Azure OpenAI

Quick Start

Using Graphiti with Google Gemini

Using Graphiti with OpenAI-compatible providers and local LLMs

Structured output and small models

Configurable Prompts

Jev dedupe

OpenAI Decisions dedupe

Documentation

Telemetry

What We Collect

What We Don't Collect

Why We Collect This Data

View the Telemetry Code

How to Disable Telemetry

Technical Details

Contributing

Support

At a glance

Questions & answers

Graphiti MCP Server alternatives

Weaviate

vLLM

Stagehand

Direct comparisons