Graphiti MCP

Overview

Graphiti MCP is the official Model Context Protocol (MCP) server implementation for Graphiti, an open-source Python framework by Zep for building real-time, temporally-aware knowledge graphs tailored for AI agents.

It bridges AI coding assistants and agents with a dynamic knowledge graph backend, allowing them to store conversations and information as structured episodes, entities, and relationships with timestamps. This provides persistent memory, reduces hallucinations, enables better long-term reasoning, and supports multi-tenant isolation via groups.

The MCP server exposes Graphiti's core capabilities as discoverable tools, making advanced agentic memory accessible to tools like Claude Desktop, Cursor, Gemini CLI, and other MCP clients.

Key Features

• Episode Management: Add, retrieve, update, and delete conversation episodes with temporal metadata.
• Entity & Relationship Extraction: Automatically extract entities and relationships from text and store them in the graph.
• Semantic & Hybrid Search: Powerful search across nodes, edges, and temporal context.
• Group Management: Multi-tenancy support with group_id to isolate data between users, projects, or sessions.
• Graph Maintenance: Tools for pruning, cleaning, and optimizing the knowledge graph.
• Temporal Awareness: Tracks when information was added or updated for time-sensitive reasoning.
• Backend Flexibility: Works with FalkorDB (default in many setups), Neo4j, and other graph databases.
• MCP Native: Full compatibility with the Model Context Protocol for seamless tool calling.

How It Works

1. Run the Graphiti MCP server (via Docker Compose, Python, or community forks).
2. Connect your MCP client (e.g., Claude Desktop) by adding the server to its configuration.
3. The AI agent calls tools like add_episode, search_nodes, get_entities, or delete_group.
4. Graphiti processes the request: extracts structured knowledge from text, stores it with timestamps, and returns relevant context or graph data.

This creates a shared, queryable long-term memory that persists across sessions and improves with every interaction.

Use Cases

• Agentic Memory & Long-Term Context: Maintain conversation history, user preferences, and learned facts as a structured graph.
• Personalized AI Assistants: Remember user details, project context, or past decisions without token bloat.
• Complex Reasoning Workflows: Agents query relationships and historical data for deeper analysis.
• Multi-Session Applications: Persistent memory for coding agents, research assistants, or customer support bots.
• Multi-Tenant Systems: Isolate knowledge graphs per user or project using groups.
• Hybrid Agent Systems: Combine with other MCP servers (search, databases, DevTools) for full agentic capabilities.

Getting Started

Official Repository

• Main Graphiti project (includes MCP server in /mcp_server): https://github.com/getzep/graphiti

Quick Setup (Docker recommended)

git clone https://github.com/getzep/graphiti.git
cd graphiti/mcp_server
# Follow README for Docker Compose (includes FalkorDB + Graphiti MCP)
docker compose up

Add to your MCP client config (example for SSE/HTTP transport) and configure LLM keys (OpenAI, Anthropic, etc.).

Detailed instructions are in the MCP Server README and Zep Documentation.

Community variants exist for Neo4j, Ollama support, or enhanced multi-project setups.

Benefits

Graphiti MCP transforms stateless AI interactions into stateful, memory-rich experiences. By turning raw text into a queryable, temporal knowledge graph, agents gain dramatically better context retention, relationship understanding, and reasoning consistency over time.

It is widely used in agentic applications and has seen rapid adoption in the MCP ecosystem, with version 1.0 of the MCP server marking a major milestone.