MCP100 verdict
Not currently recommended. Strong knowledge-graph MCP with useful persistent-memory workflows, but current default HTTP exposure and write/delete tools are too risky for Selected.
MCP100 Assessment
Editorial verdict
Reviewed September 11, 2026
Task Fit
Mapped
Local files and knowledge
Trust
Status warning
Editorial trust review has not been completed.
Maintenance
Date unavailable
No dated repository or package update is currently stored.
Popularity
Signals unavailable
No independently comparable adoption metric is currently stored.
Evidence scope
No MCP-specific repository metric is stored
No MCP-specific package metric is stored
Stars observation date unavailable · Downloads observation date unavailable
Publisher activity observed September 11, 2026
Current source snapshot
Source relationship: First-party MCP
Reviewed September 11, 2026
Evidence-backed setup
Choose your MCP client. A client connects to the MCP server; the language model is selected inside that client. Only stored, source-backed configurations are shown.
Transport not recorded
No sufficient client-specific setup evidence has been stored from the publisher or client documentation.
Publisher-documented setup is not the same as MCP100 execution testing. “MCP100 logic checked” means the stored configuration shape was reviewed, not that third-party MCP software was run.
Evidence checked 2026-09-11T00:00:00.000Z
Type-appropriate, source-backed setup for this mcp server profile.
Loading optional publisher installation details…
Clone getzep/graphiti, configure mcp_server/.env, then docker compose up or uv run main.py.Capability
Strong knowledge-graph MCP with useful persistent-memory workflows, but current default HTTP exposure and write/delete tools are too risky for Selected.
Not measured yet
Estimated token footprint of the MCP tool schemas exposed to the agent.
Reviewed access
Review the exact access boundary before connecting this MCP to accounts, credentials, or sensitive data.
Related reviewed MCPs
Codebase knowledge graph for AI agents — 159 languages, sub-ms queries, 99% fewer tokens.
Choose this instead if
Choose Codebase Memory instead if repository indexing, symbol search, call-path tracing, impact analysis, and architecture queries across many languages.
Recommended for repeated structural exploration of medium or large local repositories where a persistent code knowledge graph saves context and search time.
Give MCP clients scoped access to a local Obsidian vault.
Choose this instead if
Choose MCPVault for Obsidian instead if obsidian users who want local search and supervised note maintenance.
Give MCP clients scoped access to a local Obsidian vault.
Read, create, format, chart, and update XLSX workbooks, worksheets, formulas, and pivot tables.
Choose this instead if
Choose Excel MCP Server instead if reading, creating, formatting, charting, and updating XLSX workbooks and worksheets, including formulas and pivot tables.
Recommended for controlled creation and editing of Excel workbooks without desktop Excel, using a current patched release and a dedicated file directory.
Zep / getzep is listed as First-party MCP in MCP100’s current evidence.
Current official resources:
From the publisher README
Original client setup and configuration retained from the publisher documentation.
Publisher-documented clients
These names appear in the publisher's installation documentation. MCP100-verified configurations are shown separately above when available.
git clone https://github.com/getzep/graphiti.git
or
gh repo clone getzep/graphiti
stdio only clientscd graphiti && pwd
Install the Graphiti prerequisites.
Configure Claude, Cursor, or other MCP client to use Graphiti with a stdio transport. See the client documentation on where to find their MCP configuration files.
mcp_server directorycd graphiti/mcp_server
docker compose up
This starts both FalkorDB and the MCP server in a single container.
Alternative: Run with separate containers using Neo4j:
docker compose -f docker/docker-compose-neo4j.yml up
http://localhost:8000/mcp/uv to create a virtual environment and install dependencies:# Install uv if you don't have it already
curl -LsSf https://astral.sh/uv/install.sh | sh
# Create a virtual environment and install dependencies in one step
uv sync
# Optional: Install additional LLM providers (anthropic, gemini, groq, voyage, sentence-transformers)
uv sync --extra providers
Original product, capability, tool, and usage documentation from the MCP publisher. Installation sections appear under Install & Agents.
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.
This is an experimental Model Context Protocol (MCP) server implementation for Graphiti. The MCP server exposes Graphiti's key functionality through the MCP protocol, allowing AI assistants to interact with Graphiti's knowledge graph capabilities.
The Graphiti MCP server provides comprehensive knowledge graph capabilities:
/mcp/ for broad client compatibilityThe server can be configured using a config.yaml file, environment variables, or command-line arguments (in order of precedence).
The MCP server comes with sensible defaults:
http://localhost:8000/mcp/)FalkorDB is a Redis-based graph database that comes bundled with the MCP server in a single Docker container. This is the default and recommended setup.
database:
provider: "falkordb" # Default
providers:
falkordb:
uri: "redis://localhost:6379"
password: "" # Optional
database: "default_db" # Optional
For production use or when you need a full-featured graph database, Neo4j is recommended:
database:
provider: "neo4j"
providers:
neo4j:
uri: "bolt://localhost:7687"
username: "neo4j"
password: "your_password"
database: "neo4j" # Optional, defaults to "neo4j"
FalkorDB is another graph database option based on Redis:
database:
provider: "falkordb"
providers:
falkordb:
uri: "redis://localhost:6379"
password: "" # Optional
database: "default_db" # Optional
The server supports multiple LLM providers (OpenAI, Anthropic, Gemini, Groq) and embedders. Edit config.yaml to configure:
server:
transport: "http" # Default. Options: stdio, http
llm:
provider: "openai" # or "anthropic", "gemini", "groq", "azure_openai"
model: "gpt-5.5" # Default model
# Optional for OpenAI-compatible providers: "json_schema" (default) or "json_object"
structured_output_mode: "json_schema"
database:
provider: "falkordb" # Default. Options: "falkordb", "neo4j"
To use Ollama with the MCP server, configure it as an OpenAI-compatible endpoint:
llm:
provider: "openai"
model: "gpt-oss:120b" # or your preferred Ollama model
api_base: "http://localhost:11434/v1"
api_key: "ollama" # dummy key required
structured_output_mode: "json_object" # use when json_schema is accepted but not enforced
embedder:
provider: "sentence_transformers" # recommended for local setup
model: "all-MiniLM-L6-v2"
Make sure Ollama is running locally with: ollama serve
[!IMPORTANT] Graphiti relies on structured (JSON) output for entity/edge extraction and deduplication, and reliability varies on small or local models. Prefer the most capable model your hardware can run — very small models frequently emit JSON that doesn't match the expected schema, which surfaces as ingestion failures. For background and the
structured_output_mode(json_schemavsjson_object) trade-off, see the core README's Structured output and small models section. If an OpenAI-compatible endpoint acceptsjson_schemabut returns objects that miss fields such asextracted_entities, setstructured_output_mode: "json_object"so Graphiti injects the schema into the prompt instead of relying on provider-side schema enforcement.
Graphiti MCP Server includes built-in entity types for structured knowledge extraction. These entity types are always enabled and configured via the entity_types section in your config.yaml:
Available Entity Types:
These entity types are defined in config.yaml and can be customized by modifying the descriptions:
graphiti:
entity_types:
- name: "Preference"
description: "User preferences, choices, opinions, or selections"
- name: "Requirement"
description: "Specific needs, features, or functionality"
# ... additional entity types
The MCP server automatically uses these entity types during episode ingestion to extract and structure information from conversations and documents.
Upgrade note: These built-in types are now registered as rich models with typed attributes (e.g. a
description), so extraction stores those attributes on entities. The shipped defaultconfig.yamlenables them, so an existing deployment on the default config switches from attribute-free to rich-attribute extraction. To keep the previous behavior, setgraphiti.entity_typesto an empty list (or remove the entries).
The config.yaml file supports environment variable expansion using ${VAR_NAME} or ${VAR_NAME:default} syntax. Key variables:
NEO4J_URI: URI for the Neo4j database (default: bolt://localhost:7687)NEO4J_USER: Neo4j username (default: neo4j)NEO4J_PASSWORD: Neo4j password (default: demodemo)NEO4J_DATABASE: Neo4j database name (default: neo4j)OPENAI_API_KEY: OpenAI API key (required for OpenAI LLM/embedder)ANTHROPIC_API_KEY: Anthropic API key (for Claude models)GOOGLE_API_KEY: Google API key (for Gemini models)GROQ_API_KEY: Groq API key (for Groq models)AZURE_OPENAI_API_KEY: Azure OpenAI API keyAZURE_OPENAI_ENDPOINT: Azure OpenAI endpoint URLAZURE_OPENAI_DEPLOYMENT: Azure OpenAI deployment nameAZURE_OPENAI_EMBEDDINGS_ENDPOINT: Optional Azure OpenAI embeddings endpoint URLAZURE_OPENAI_EMBEDDINGS_DEPLOYMENT: Optional Azure OpenAI embeddings deployment nameAZURE_OPENAI_API_VERSION: Optional Azure OpenAI API versionUSE_AZURE_AD: Optional use Azure Managed Identities for authenticationSEMAPHORE_LIMIT: Episode processing concurrency. See You can set these variables in a .env file in the project directory.
To run the Graphiti MCP server with the default FalkorDB setup:
docker compose up
This starts a single container with:
http://localhost:8000/mcp/localhost:6379http://localhost:3000The easiest way to run with Neo4j is using the provided Docker Compose configuration:
# This starts both Neo4j and the MCP server
docker compose -f docker/docker-compose.neo4j.yaml up
If you have Neo4j already running:
# Set environment variables
export NEO4J_URI="bolt://localhost:7687"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your_password"
# Run with Neo4j
uv run main.py --database-provider neo4j
Or use the Neo4j configuration file:
uv run main.py --config config/config-docker-neo4j.yaml
# This starts both FalkorDB (Redis-based) and the MCP server
docker compose -f docker/docker-compose.falkordb.yaml up
# Set environment variables
export FALKORDB_URI="redis://localhost:6379"
export FALKORDB_PASSWORD="" # If password protected
# Run with FalkorDB
uv run main.py --database-provider falkordb
Or use the FalkorDB configuration file:
uv run main.py --config config/config-docker-falkordb.yaml
--config: Path to YAML configuration file (default: config.yaml)--llm-provider: LLM provider to use (openai, anthropic, gemini, groq, azure_openai)--embedder-provider: Embedder provider to use (openai, azure_openai, gemini, voyage)--database-provider: Database provider to use (falkordb, neo4j) - default: falkordb--model: Model name to use with the LLM client--temperature: Temperature setting for the LLM (0.0-2.0)--transport: Choose the transport method (http or stdio, default: http)--group-id: Set a namespace for the graph (optional). If not provided, defaults to "main"--destroy-graph: If set, destroys all Graphiti graphs on startupGraphiti's ingestion pipelines are designed for high concurrency, controlled by the SEMAPHORE_LIMIT environment variable. This setting determines how many episodes can be processed simultaneously. Since each episode involves multiple LLM calls (entity extraction, deduplication, summarization), the actual number of concurrent LLM requests will be several times higher.
Default: SEMAPHORE_LIMIT=10 (suitable for OpenAI Tier 3, mid-tier Anthropic)
OpenAI:
SEMAPHORE_LIMIT=1-2SEMAPHORE_LIMIT=5-8SEMAPHORE_LIMIT=10-15SEMAPHORE_LIMIT=20-50Anthropic:
SEMAPHORE_LIMIT=5-8SEMAPHORE_LIMIT=15-30Azure OpenAI:
Ollama (local):
SEMAPHORE_LIMIT=1-5429 rate limit errorsSet this in your .env file:
SEMAPHORE_LIMIT=10 # Adjust based on your LLM provider tier
The Graphiti MCP server can be deployed using Docker with your choice of database backend. The Dockerfile uses uv for package management, ensuring consistent dependency installation.
A pre-built Graphiti MCP container is available at: zepai/knowledge-graph-mcp
Before running Docker Compose, configure your API keys using a .env file (recommended):
Create a .env file in the mcp_server directory:
cd graphiti/mcp_server
cp .env.example .env
Edit the .env file to set your API keys:
# Required - at least one LLM provider API key
OPENAI_API_KEY=your_openai_api_key_here
# Optional - other LLM providers
ANTHROPIC_API_KEY=your_anthropic_key
GOOGLE_API_KEY=your_google_key
GROQ_API_KEY=your_groq_key
# Optional - embedder providers
VOYAGE_API_KEY=your_voyage_key
Important: The .env file must be in the mcp_server/ directory (the parent of the docker/ subdirectory).
All commands must be run from the mcp_server directory to ensure the .env file is loaded correctly:
cd graphiti/mcp_server
Single container with both FalkorDB and MCP server - simplest option:
docker compose up
Separate containers with Neo4j and MCP server:
docker compose -f docker/docker-compose-neo4j.yml up
Default Neo4j credentials:
neo4jdemodemobolt://neo4j:7687http://localhost:7474Alternative setup with separate FalkorDB and MCP server containers:
docker compose -f docker/docker-compose-falkordb.yml up
FalkorDB configuration:
6379http://localhost:3000redis://falkordb:6379Once running, the MCP server is available at:
http://localhost:8000/mcp/http://localhost:8000/healthIf you run Docker Compose from the docker/ subdirectory instead of mcp_server/, you'll need to modify the .env file path in the compose file:
# Change this line in the docker-compose file:
env_file:
- path: ../.env # When running from mcp_server/
# To this:
env_file:
- path: .env # When running from mcp_server/docker/
However, running from the mcp_server/ directory is recommended to avoid confusion.
VS Code with GitHub Copilot Chat extension supports MCP servers. Add to your VS Code settings (.vscode/mcp.json or global settings):
{
"mcpServers": {
"graphiti": {
"uri": "http://localhost:8000/mcp/",
"transport": {
"type": "http"
}
}
}
}
To use the Graphiti MCP server with other MCP-compatible clients, configure it to connect to the server:
[!IMPORTANT] You will need the Python package manager,
uvinstalled. Please refer to theuvinstall instructions.Ensure that you set the full path to the
uvbinary and your Graphiti project folder.
{
"mcpServers": {
"graphiti-memory": {
"transport": "stdio",
"command": "/Users/<user>/.local/bin/uv",
"args": [
"run",
"--isolated",
"--directory",
"/Users/<user>>/dev/zep/graphiti/mcp_server",
"--project",
".",
"main.py",
"--transport",
"stdio"
],
"env": {
"NEO4J_URI": "bolt://localhost:7687",
"NEO4J_USER": "neo4j",
"NEO4J_PASSWORD": "password",
"OPENAI_API_KEY": "sk-XXXXXXXX",
"MODEL_NAME": "gpt-5.5"
}
}
}
}
For HTTP transport (default), you can use this configuration:
{
"mcpServers": {
"graphiti-memory": {
"transport": "http",
"url": "http://localhost:8000/mcp/"
}
}
}
The Graphiti MCP server exposes the following tools:
add_memory: Add an episode to the knowledge graph (supports text, JSON, and message formats).
Supports the bi-temporal reference_time, excluded_entity_types, custom_extraction_instructions,
previous_episode_uuids, update_communities, and saga / saga_previous_episode_uuid.add_triplet: Add a single fact (source entity -> fact -> target entity) directly, bypassing extraction.search_nodes: Search the knowledge graph for relevant entities; supports entity_types and center_node_uuid.search_memory_facts: Search for relevant facts (edges); supports edge_types, center_node_uuid,
and valid_at / invalid_at date-range filters.summarize_saga: Generate or refresh the running summary of a saga's episodes.build_communities: Detect entity communities and produce higher-level community summaries.get_episode_entities: Trace provenance — the entities and facts created by specific episode UUIDs.delete_entity_edge: Delete an entity edge from the knowledge graph.Custom entity types and edge (fact) types — including which edge types may connect which entity types —
can be configured under the graphiti section of config/config.yaml. See the entity_types,
edge_types, and edge_type_map keys there.
The Graphiti MCP server can process structured JSON data through the add_episode tool with source="json". This
allows you to automatically extract entities and relationships from structured data:
add_episode(
name="Customer Profile",
episode_body="{\"company\": {\"name\": \"Acme Technologies\"}, \"products\": [{\"id\": \"P001\", \"name\": \"CloudSync\"}, {\"id\": \"P002\", \"name\": \"DataMiner\"}]}",
source="json",
source_description="CRM data"
)
To integrate the Graphiti MCP Server with the Cursor IDE, follow these steps:
uv run main.py --group-id <your_group_id>
Hint: specify a group_id to namespace graph data. If you do not specify a group_id, the server will use "main" as the group_id.
or
docker compose up
{
"mcpServers": {
"graphiti-memory": {
"url": "http://localhost:8000/mcp/"
}
}
}
Add the Graphiti rules to Cursor's User Rules. See cursor_rules.md for details.
Kick off an agent session in Cursor.
The integration enables AI assistants in Cursor to maintain persistent memory through Graphiti's knowledge graph capabilities.
The Graphiti MCP Server uses HTTP transport (at endpoint /mcp/). Claude Desktop does not natively support HTTP transport, so you'll need to use a gateway like mcp-remote.
Run the Graphiti MCP server:
docker compose up
# Or run directly with uv:
uv run main.py
(Optional) Install mcp-remote globally:
If you prefer to have mcp-remote installed globally, or if you encounter issues with npx fetching the package, you can install it globally. Otherwise, npx (used in the next step) will handle it for you.
npm install -g mcp-remote
Configure Claude Desktop:
Open your Claude Desktop configuration file (usually claude_desktop_config.json) and add or modify the mcpServers section as follows:
{
"mcpServers": {
"graphiti-memory": {
// You can choose a different name if you prefer
"command": "npx", // Or the full path to mcp-remote if npx is not in your PATH
"args": [
"mcp-remote",
"http://localhost:8000/mcp/" // The Graphiti server's HTTP endpoint
]
}
}
}
If you already have an mcpServers entry, add graphiti-memory (or your chosen name) as a new key within it.
Restart Claude Desktop for the changes to take effect.
The Graphiti MCP server uses the Graphiti core library, which includes anonymous telemetry collection. When you initialize the Graphiti MCP server, anonymous usage statistics are collected to help improve the framework.
To disable telemetry in the MCP server, set the environment variable:
export GRAPHITI_TELEMETRY_ENABLED=false
Or add it to your .env file:
GRAPHITI_TELEMETRY_ENABLED=false
For complete details about what's collected and why, see the Telemetry section in the main Graphiti README.
This project is licensed under the same license as the parent Graphiti project.
delete_episodeget_entity_edge: Get an entity edge by its UUID.get_episodes: Get the most recent episodes for a specific group.clear_graph: Clear all data from the knowledge graph for the given group(s).get_status: Get the status of the Graphiti MCP server and database connection.