MCP Graphiti

The Graphiti MCP Server is a server based on multi - project knowledge graphs, supporting the rapid construction and management of temporary knowledge graphs for AI agents to query through the model context protocol. This project extends the official getzep/graphiti MCP Server, adds support for multiple servers and a single database, and provides a CLI tool with an optimized developer experience.

Knowledge management and memory Developer tools #Knowledge graph #Multi - project #AI agent #Neo4j .Python

rating : 2.5 points

downloads : 21

update time : 2025-04-29

What is the Graphiti MCP Server?

The Graphiti MCP Server is a time - series - based knowledge graph generation tool. It extracts entities and relationships from text through natural language processing (NLP) technology and stores them in the Neo4j database. Each project has an independent timeline, supporting version control and historical queries.

How to use the Graphiti MCP Server?

Users only need to install the Graphiti CLI tool, then generate a configuration file according to the guidance and start the service to begin using it. It supports multi - project management, and each project has an independent group ID and model configuration.

Applicable scenarios

It is suitable for knowledge graph construction tasks that require cross - project collaboration, such as enterprise knowledge management, intelligent customer service systems, data analysis platforms, etc.

Main Features

Multi - project supportAllows multiple independent knowledge graph projects to run simultaneously, and each project has its own group ID and model configuration.

Time - series storageAll operations are recorded as timestamp events, facilitating historical backtracking and version management.

Visual interfaceIt has a built - in Neo4j browser, and users can directly view and edit the knowledge graph on the Web interface.

Model hot updateSupports dynamically replacing the LLM model without restarting the entire service.

Advantages and Limitations

Advantages

Powerful multi - project isolation ability to ensure that data from different projects does not interfere with each other.

Efficient incremental update mechanism to reduce unnecessary computational overhead.

Friendly developer experience, integrating mainstream IDE tools such as VS Code, etc.

Flexible scalability, allowing configuration files to be adjusted according to requirements to adapt to complex business logic.

Limitations

Higher hardware resources may be required for large - scale data sets.

Some advanced features may depend on specific versions of dependencies.

The initial setup process is relatively cumbersome and requires a certain technical background.

How to Use

Install the Graphiti CLI tool

First, ensure that Python 3.x is installed in your environment, and then install the Graphiti CLI through the pipx tool.

Generate a configuration file

Run the graphiti compose command to generate a docker - compose.yml file suitable for your project.

Start the service

Use the graphiti up command to start the Graphiti MCP Server and related dependent components.

Usage Examples

Create an enterprise knowledge baseSuppose we are providing an internal knowledge management system for a large enterprise. We can quickly build a knowledge graph supporting multi - department collaboration through the Graphiti MCP Server.

Migrate existing dataIf you already have data from an old - version knowledge management system, you can use the Graphiti MCP Server to easily import this data and convert it into a new knowledge graph.

Frequently Asked Questions

Does the Graphiti MCP Server support multi - language input?

How to ensure data security?

Can I shut down the knowledge graph service of a certain project?

Related Resources

Official Documentation

Get detailed installation guides and technical references.

GitHub Repository

Access the source code and participate in contributions.

Community Forum

Exchange experiences with other users.

🚀 Graphiti Project Introduction

Graphiti is a knowledge graph construction tool based on Docker and GraphQL. It aims to extract information from various sources (such as documents, code comments, etc.) in a simple and easy - to - use way and build semantic networks. This project is designed for developers to help them quickly set up and manage knowledge graphs.

🚀 Quick Start

1. Clone the project and configure the environment

git clone https://github.com/rawr-ai/mcp-graphiti.git
cd mcp-graphiti
cp .env.example .env   # Copy the example environment file

⚠️ Important Note

If NEO4J_PASSWORD is set to the default value 'password', the program will refuse to start unless GRAPHITI_ENV=dev or GRAPHITI_ENV=development is explicitly set.

Ensure a strong password is configured for NEO4J_PASSWORD in non - development environments.

2. Install the CLI tool

pipx install . --include-deps   # Recommended installation method for users
# Or for contributors:
python -m venv .venv && source .venv/bin/activate && pip sync uv.lock && pip install -e .

3. Start the service

graphiti compose   # Generate the docker-compose.yml file
graphiti up -d     # Start the service in the background

4. Create a project

cd ~/code
graphiti init acme-support-bot   # Run this command in the root directory of the new project
cd acme-support-bot
# Add entity YAML files to the ai/graph/entities/ directory

✨ Features

Graphiti offers the following main features:

Knowledge graph construction: Extract information from multiple sources and automatically build semantic networks.
GraphQL query support: Query and retrieve knowledge graph data through the GraphQL interface.
Extensible plugin system: Support custom plugins for easy function expansion.
Visual interface: Provide an intuitive graphical interface for viewing and managing knowledge graphs.

📦 Installation

The installation steps are included in the "Quick Start" section above.

📚 Documentation

Project Configuration (`mcp-projects.yaml`)

The mcp-projects.yaml file is used to define and manage the configurations of multiple projects, including the following:

Project list: List all knowledge graphs to be built.
Data source configuration: Specify the sources of documents, code comments, etc. for each project.
Plugin extension: Define the usage of custom plugins.

Security Tips

Ensure that all sensitive information (such as API keys and database credentials) is not stored in plain text in the code.
Regularly back up knowledge graph data to prevent accidental loss.

Frequently Asked Questions

Q: How to extend functionality?

A: You can extend functionality by writing custom plugins and adding them to mcp-projects.yaml.

Q: How to optimize performance?

A: You can optimize performance in the following ways:

Configure an appropriate caching strategy.
Use an efficient storage backend (such as Redis).
Process data extraction tasks in parallel.

Danger Zone

Experimental features: Some new features may not have been fully tested. Please carefully evaluate the risks before using them.
Data cleaning: Ensure that important data has been backed up before performing data cleaning operations.

Future Development Plans

Enhance the plugin system: Provide more built - in plugins and support more flexible extension methods.
Optimize performance: Improve the efficiency of building and querying large - scale knowledge graphs.
Improve documentation: Provide more detailed usage guides and technical documentation to lower the learning curve.

For more information, please visit the project's official website or refer to the relevant technical documentation.