Memory

You run a high-performance memory graph server built in Rust that stores entities, relations, and observations in SQLite. It provides fast search, automatic data integrity, and MCP protocol support so clients can query and mutate a persistent knowledge base used for memory and context in AI workflows.

How to use

You connect MCP clients to memory-optimized memory graphs either locally via standard input/output or remotely over HTTP. Use the stdio mode for local clients or the HTTP stream mode for remote access, debugging, or testing. You can create entities, define relations, add observations, and read or search the graph. With full MCP protocol support, you can interchange data with compatible tools while benefiting from ACID-safe storage and fast, indexed queries.

Practical patterns you can follow: start the server in stdio mode during development for quick iterations, then switch to HTTP stream mode to expose endpoints for web apps or remote clients. Use the health endpoint to verify the server is responsive, and perform common operations like creating entities, linking them with relations, and searching the graph to retrieve relevant nodes.

How to install

Prerequisites: you need Rust tooling (cargo) and SQLite installed on your system. Ensure you have a compatible Rust toolchain (stable) and that you can build native binaries.

Step-by-step setup to build and run the server locally:

# Install Rust toolchain if you don’t have it
# https://rustup.rs/

# Build the memory MCP server in release mode
cargo build --release

# The binary will be at target/release/memory-mcp-rs on Unix-like systems
# On Windows it will be target\release\memory-mcp-rs.exe

Configuration and running modes

Two transport modes are available. Choose stdio mode for local clients or HTTP stream mode for remote access.

Stdio Mode (default) when you run memory-mcp-rs directly from a terminal without additional flags, the protocol uses JSON-RPC over stdin/stdout. Logging is silent by default to avoid handshake issues, but you can enable file logging with --log.

HTTP Stream Mode exposes an HTTP server with Server-Sent Events for the MCP protocol and a health endpoint for quick checks.

API endpoints and common commands

In stdio mode you interact through the memory-mcp-rs binary directly from your terminal or a launcher script.

In HTTP stream mode you expose two endpoints: /mcp for the MCP protocol and /health for a simple health check.

Examples of common runs

# Default stdio mode (no extra flags)
memory-mcp-rs

# With file logging in stdio mode
memory-mcp-rs --log memory.log

# Start HTTP stream mode on the default port 8000
memory-mcp-rs --stream

# Start HTTP stream mode on a custom port and bind address
memory-mcp-rs --stream --port 9000 --bind 0.0.0.0

# Enable logging to a file in HTTP mode
memory-mcp-rs --stream --log server.log

# Health check
curl http://localhost:8000/health
# Returns: OK

MCP server configuration (examples)

{
  "mcpServers": {
    "memory": {
      "command": "memory-mcp-rs",
      "args": []
    }
  }
}

Notes on usage with clients

When using Claude Desktop or Claude Code, you can add the stdio mode server by pointing the MCP client to the memory-mcp-rs executable. In HTTP mode, configure the client to connect to the /mcp endpoint and use the health endpoint for readiness checks.

Troubleshooting and tips

If you encounter handshake or logging issues, try enabling --log to capture startup messages and verify the server starts successfully in the expected mode. Use the health endpoint to confirm the server is responsive after starting in HTTP mode. If you see database errors, ensure SQLite is available and that the server can access the database file path you provide or that the default path has the correct permissions.

Notes and considerations

This server uses SQLite with full-text search via FTS5 and supports cascade deletes for maintaining referential integrity. It is designed to be ACID-compliant and to provide fast, indexed queries for graph-like data. Use the HTTP stream mode for remote clients and the stdio mode for local development and experiments.

Available tools

create_entities

Create new entities in the knowledge graph.

create_relations

Create relations between entities.

add_observations

Add observations to an entity.

delete_entities

Delete entities (cascade deletes relations).

delete_observations

Delete specific observations.

delete_relations

Delete specific relations.

read_graph

Read the entire knowledge graph.

search_nodes

Full-text search across entities.

open_nodes

Open specific nodes by name.