Provides memory and knowledge graph operations using Neo4j database, including adding memories, searching entities and relationships, managing episodes, and querying historical data through natural language interfaces.
Optional integration for enhanced entity extraction from memories and episodes stored in the knowledge graph.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Graphiti-Memory MCP Server add memory about our team meeting where we decided to prioritize the AI roadmap"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides memory and knowledge graph operations using Neo4j and the Graphiti framework.
📝 Add Memories: Store episodes and information in the knowledge graph with automatic entity extraction
🧠 Search Nodes: Query entities in your knowledge graph using natural language
🔗 Search Facts: Find relationships and connections between entities
📚 Retrieve Episodes: Get historical episodes and memories
🗑️ Management Tools: Delete episodes, edges, and clear the graph
🤖 AI-Powered: Optional OpenAI integration for enhanced entity extraction
📊 Real-time Data: Direct connection to your Neo4j database
🛠️ Built-in Diagnostics: Comprehensive error messages and troubleshooting
Related MCP server: Graphiti Knowledge Graph MCP Server
Neo4j Database: You need a running Neo4j instance
# Install Neo4j (via Homebrew on macOS)
brew install neo4j
# Start Neo4j
neo4j startPython 3.10+: Required for the MCP server
pip install graphiti-memorygit clone https://github.com/alankyshum/graphiti-memory.git
cd graphiti-memory
pip install -e .Add to your MCP client configuration file (e.g., Claude Desktop config):
{
"mcpServers": {
"graphiti-memory": {
"command": "graphiti-mcp-server",
"env": {
"NEO4J_URI": "neo4j://127.0.0.1:7687",
"NEO4J_USER": "neo4j",
"NEO4J_PASSWORD": "your-password-here",
"OPENAI_API_KEY": "your-openai-key-here",
"GRAPHITI_GROUP_ID": "default"
}
}
}
}Set Password (first-time setup):
neo4j-admin dbms set-initial-password YOUR_PASSWORDTest Connection:
# HTTP interface
curl http://127.0.0.1:7474
# Bolt protocol
nc -zv 127.0.0.1 7687Add an episode or memory to the knowledge graph. This is the primary way to add information.
Example:
{
"name": "add_memory",
"arguments": {
"name": "Project Discussion",
"episode_body": "We discussed the new AI feature roadmap for Q2. Focus on improving entity extraction.",
"source": "text",
"group_id": "project-alpha"
}
}Parameters:
name: Name of the episode (required)
episode_body: Content to store - text, message, or JSON (required)
source: Type of content - "text", "message", or "json" (default: "text")
group_id: Optional namespace for organizing data
source_description: Optional description
Search for nodes (entities) in the knowledge graph using natural language.
Example:
{
"name": "search_memory_nodes",
"arguments": {
"query": "machine learning",
"max_nodes": 10
}
}Returns: List of nodes with UUID, name, summary, labels, and timestamps.
Search for facts (relationships) between entities in the knowledge graph.
Example:
{
"name": "search_memory_facts",
"arguments": {
"query": "what technologies are related to AI",
"max_facts": 10
}
}Returns: List of fact triples with source, target, and relationship details.
Retrieve recent episodes for a specific group.
Example:
{
"name": "get_episodes",
"arguments": {
"group_id": "project-alpha",
"last_n": 10
}
}Delete an episode from the knowledge graph.
Example:
{
"name": "delete_episode",
"arguments": {
"uuid": "episode-uuid-here"
}
}Delete a fact (entity edge) from the knowledge graph.
Example:
{
"name": "delete_entity_edge",
"arguments": {
"uuid": "edge-uuid-here"
}
}Retrieve a specific entity edge by UUID.
Example:
{
"name": "get_entity_edge",
"arguments": {
"uuid": "edge-uuid-here"
}
}Clear all data from the knowledge graph (DESTRUCTIVE).
Example:
{
"name": "clear_graph",
"arguments": {}
}Configure in ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"graphiti-memory": {
"command": "graphiti-mcp-server",
"env": {
"NEO4J_URI": "neo4j://127.0.0.1:7687",
"NEO4J_USER": "neo4j",
"NEO4J_PASSWORD": "your-password",
"OPENAI_API_KEY": "your-openai-key-here",
"GRAPHITI_GROUP_ID": "default"
}
}
}
}Note: OPENAI_API_KEY is optional. Without it, entity extraction will be limited but the server will still work.
Test the server directly from command line:
export NEO4J_URI="neo4j://127.0.0.1:7687"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your-password"
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | graphiti-mcp-serverError: Connection refused or ServiceUnavailable
Solutions:
Check Neo4j is running: neo4j status
Start Neo4j: neo4j start
Verify port 7687 is accessible: nc -zv 127.0.0.1 7687
Error: Unauthorized or authentication failure
Solutions:
Verify password is correct
Reset password: neo4j-admin dbms set-initial-password NEW_PASSWORD
Update password in MCP configuration
Use test tool to verify: test_neo4j_auth
Error: neo4j package not installed
This package automatically installs the neo4j dependency. If you see this error:
pip install neo4jgit clone https://github.com/alankyshum/graphiti-memory.git
cd graphiti-memory
pip install -e ".[dev]"# Test the server
python -m graphiti_memory.server << 'EOF'
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}
EOFMCP Client (Claude Desktop / Cline / etc.)
↓
Graphiti-Memory Server
↓
Neo4j DatabaseThe server:
Listens on stdin for JSON-RPC messages
Logs diagnostics to stderr
Responds on stdout with JSON-RPC
Maintains persistent Neo4j connection
Contributions welcome! Please:
Fork the repository
Create a feature branch
Make your changes
Submit a pull request
MIT License - see LICENSE file for details.
Issues: https://github.com/alankyshum/graphiti-memory/issues
MCP Specification: https://modelcontextprotocol.io
Built for use with:
Graphiti - Knowledge graph framework
Add an episode/memory to the knowledge graph. This is the primary way to add information.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the episode | |
| episode_body | Yes | Content of the episode (text, message, or JSON) | |
| group_id | No | Optional group ID for organizing data | |
| source | No | Source type (default: text) | |
| source_description | No | Optional description of the source |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool adds to a knowledge graph, implying a write operation, but lacks details on permissions, side effects (e.g., overwriting), rate limits, or response format. This is a significant gap for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences that directly state the purpose and primary role. It's front-loaded with the core action and avoids unnecessary details, though the second sentence could be more informative about alternatives or context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a write operation with 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks behavioral context (e.g., how additions affect the graph), usage scenarios, or error handling, making it inadequate for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description adds no parameter-specific information beyond what the schema provides, such as examples or usage context. The baseline score of 3 is appropriate when the schema handles all parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Add an episode/memory to the knowledge graph' with a specific verb ('add') and resource ('episode/memory'), and distinguishes it from siblings by calling it 'the primary way to add information.' However, it doesn't explicitly differentiate from other write operations like 'clear_graph' or 'delete_episode' beyond being 'primary.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance, stating only that this is 'the primary way to add information,' which implies usage but doesn't specify when to use it versus alternatives like 'clear_graph' or 'delete_episode,' nor does it mention prerequisites or exclusions. No explicit when/when-not instructions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clear all data from the knowledge graph (DESTRUCTIVE)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns that the operation is 'DESTRUCTIVE' (all caps for emphasis), which clearly communicates this is a high-risk mutation that permanently removes all data. This goes beyond what the zero-parameter schema alone would indicate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise - a single sentence that front-loads the core action ('Clear all data from the knowledge graph') followed by the critical warning ('DESTRUCTIVE'). Every word earns its place with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter destructive operation with no output schema, the description provides adequate context by clearly stating what the tool does and its destructive nature. However, it doesn't mention what 'all data' specifically includes or whether the operation is reversible, which could be helpful given the high-risk nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the behavioral implications of the operation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Clear all data') and target resource ('from the knowledge graph'), distinguishing it from sibling tools that perform selective deletions or queries. It uses precise language that leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly provides usage guidance by labeling the operation as 'DESTRUCTIVE' in all caps, which signals it should be used with extreme caution. However, it doesn't explicitly state when to use this versus alternatives like delete_entity_edge or delete_episode for more targeted deletions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete an entity edge (fact) from the knowledge graph
| Name | Required | Description | Default |
|---|---|---|---|
| uuid | Yes | UUID of the entity edge to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive mutation, it doesn't specify whether this is reversible, what permissions are required, how it affects related data, or what happens on success/failure. This is a significant gap for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized for a tool with one parameter and clear scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion, whether there are side effects, what the response looks like, or any error conditions. Given the complexity and risk of deletion operations, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'uuid' fully documented in the schema. The description doesn't add any additional parameter context beyond what's already in the schema, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and the resource ('entity edge/fact from the knowledge graph'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'clear_graph' or 'delete_episode', but the specificity of 'entity edge' provides some implicit distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives like 'clear_graph' (which might delete multiple edges) or 'delete_episode'. The description only states what it does, not when it's appropriate or what prerequisites might exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete an episode from the knowledge graph
| Name | Required | Description | Default |
|---|---|---|---|
| uuid | Yes | UUID of the episode to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether deletion is permanent or reversible, what permissions are required, whether there are confirmation prompts, or what happens to related data. This leaves significant behavioral gaps for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's appropriately sized for a simple tool and front-loads the essential information about what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It doesn't address critical context like deletion consequences, error conditions, or return values. Given the complexity of a deletion operation and lack of structured coverage, more completeness is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single parameter 'uuid' well-documented in the schema. The description doesn't add any parameter semantics beyond what the schema already provides, so it meets the baseline for high schema coverage without adding value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and target resource ('an episode from the knowledge graph'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'delete_entity_edge' or 'clear_graph', which also perform deletion operations on the knowledge graph.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'delete_entity_edge' or 'clear_graph', nor does it mention prerequisites or conditions for deletion. It simply states what the tool does without contextual usage information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get an entity edge by UUID
| Name | Required | Description | Default |
|---|---|---|---|
| uuid | Yes | UUID of the entity edge to retrieve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this requires authentication, has rate limits, returns null for missing UUIDs, or provides error details. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential information immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read operation with no output schema, the description provides the minimum viable information about what the tool does. However, without annotations or output details, it doesn't fully address behavioral aspects like error handling or return format, leaving some context gaps despite the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'uuid' fully documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema (e.g., format examples, validation rules, or edge cases), meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('entity edge by UUID'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'get_episodes' or 'search_memory_nodes', but the specific resource type (entity edge) provides adequate clarity for standalone understanding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. With siblings like 'get_episodes' and 'search_memory_nodes' available, the description doesn't indicate whether this is for retrieving specific edges by ID versus searching or listing operations, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent episodes for a group
| Name | Required | Description | Default |
|---|---|---|---|
| group_id | No | Group ID to retrieve episodes from | |
| last_n | No | Number of recent episodes to retrieve (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving 'recent episodes' but doesn't specify ordering (e.g., chronological), pagination, rate limits, authentication needs, or error handling. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action ('Get recent episodes'), making it easy to scan. Every word earns its place, achieving optimal conciseness for this level of detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain what an 'episode' entails, the return format, or error cases. For a retrieval tool with no structured output documentation, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for both parameters (group_id and last_n). The description adds minimal value beyond the schema, as it doesn't explain parameter interactions (e.g., how 'recent' relates to last_n) or provide examples. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('recent episodes for a group'), making the purpose understandable. It distinguishes from siblings like 'delete_episode' or 'search_memory_facts' by focusing on retrieval rather than modification or broader search. However, it lacks specificity about what 'recent' means or the exact scope of episodes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid group_id), exclusions, or comparisons to sibling tools like 'search_memory_nodes' for different types of data retrieval. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for facts (relationships) in the knowledge graph
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| group_ids | No | Optional list of group IDs to filter results | |
| max_facts | No | Maximum number of facts to return (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('Search') without detailing aspects like permissions, rate limits, error handling, or response format. For a search tool with no annotation coverage, this is insufficient to inform the agent about behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of a single, direct sentence: 'Search for facts (relationships) in the knowledge graph.' Every word contributes to the purpose, with no wasted information, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a search tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and return values, which are crucial for an agent to operate effectively. The high schema coverage doesn't compensate for these gaps in overall context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents all parameters. The description adds no additional meaning beyond the schema, such as explaining how the query is processed or what 'facts' entail. This meets the baseline for high schema coverage but doesn't enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for facts (relationships) in the knowledge graph.' It specifies the verb ('Search'), resource ('facts (relationships)'), and context ('knowledge graph'). However, it doesn't explicitly differentiate from sibling tools like 'search_memory_nodes' (which searches nodes rather than relationships), leaving room for ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_memory_nodes' or clarify scenarios where searching facts is preferred over other operations. This lack of context leaves the agent without explicit usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for nodes (entities) in the knowledge graph
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| group_ids | No | Optional list of group IDs to filter results | |
| max_nodes | No | Maximum number of nodes to return (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the search function but doesn't describe key traits like whether this is a read-only operation, potential rate limits, authentication needs, or what happens if no results are found. This leaves significant gaps for a tool with three parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a search tool with three parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the search returns (e.g., node details, types), how results are ordered, or error conditions, which are critical for effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so all parameters are documented in the input schema. The description adds no additional meaning about parameters beyond what the schema provides (e.g., it doesn't explain what 'nodes' or 'group_ids' represent semantically). This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search for') and resource ('nodes (entities) in the knowledge graph'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'search_memory_facts' or 'get_episodes', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_memory_facts' or 'get_entity_edge'. It lacks context about use cases, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most tools have distinct purposes, such as add_memory for adding, clear_graph for clearing, and search_memory_facts for searching facts. However, get_entity_edge and search_memory_nodes could be slightly ambiguous since both involve retrieving entity-related information, but their descriptions clarify the difference (specific vs. search).
The naming follows a consistent verb_noun pattern with snake_case throughout, such as add_memory and delete_episode. There are minor deviations like get_entity_edge using 'entity_edge' instead of a more uniform term like 'fact', but overall the pattern is clear and predictable.
With 8 tools, the count is well-scoped for a memory/knowledge graph server, covering core operations like add, delete, get, search, and clear. Each tool serves a distinct function without bloat, making it manageable and purposeful for the domain.
The tool set provides good coverage for a knowledge graph domain, including add, delete, get, and search operations for episodes and entities. A minor gap is the lack of update tools for modifying existing memories or entities, but agents can work around this by deleting and re-adding, and core workflows are supported.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Shared long-term memory for AI agents: save and recall context as a searchable knowledge graph.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Persistent memory and knowledge graph for AI assistants — keyword + vector + graph search.
Company brain for AI agents — temporal knowledge graph search, exploration, and durable memory.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/alankyshum/graphiti-memory'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
