Skip to main content
Glama

OpenMemory MCP Server

MCP (Model Context Protocol) server that provides Claude Desktop with access to your OpenMemory API running on Ubuntu server richard-XPS-15-9560.local:8892.

Architecture

Claude Desktop (Windows)
    ↓ stdio
MCP Server (Python - this package)
    ↓ HTTP REST
OpenMemory API (richard-XPS-15-9560.local:8892)
    ↓
Neo4j + Vector DB (Ubuntu Docker)

Related MCP server: Spomory

Features

The MCP server provides Claude Desktop with the following tools:

  • search_memories - Semantic search across OpenMemory graph

  • add_memory - Store new memories with sector classification

  • list_memories - Browse recent memories with pagination

  • get_memory - Retrieve specific memory by ID

  • reinforce_memory - Boost importance of a memory

  • delete_memory - Remove a memory

  • health_check - Verify OpenMemory API connectivity

Windows Installation

Prerequisites

  1. Python 3.10 or higher installed on Windows

  2. Claude Desktop installed on Windows

  3. Network access to richard-XPS-15-9560.local:8892 from your Windows PC

    • Test with: curl http://richard-XPS-15-9560.local:8892/health in PowerShell

    • Or open http://richard-XPS-15-9560.local:8892/health in browser

Step 1: Copy Files to Windows

Transfer the entire openmemory-mcp folder to your Windows PC. You can use:

  • Network share

  • USB drive

  • Git clone (if you push this to a repo)

  • Any file transfer method

Suggested location: C:\Users\YourUsername\openmemory-mcp

Step 2: Install Python Dependencies

Open PowerShell or Command Prompt and navigate to the folder:

cd C:\Users\YourUsername\openmemory-mcp

Install the package and dependencies:

pip install -e .

This will install:

  • mcp - Model Context Protocol SDK

  • httpx - HTTP client for API calls

  • python-dotenv - Environment variable management

Step 3: Configure Claude Desktop

  1. Locate your Claude Desktop configuration file:

    • Path: %APPDATA%\Claude\claude_desktop_config.json

    • Full path example: C:\Users\YourUsername\AppData\Roaming\Claude\claude_desktop_config.json

  2. Open the file in a text editor (create it if it doesn't exist)

  3. Add the OpenMemory MCP server configuration:

{
  "mcpServers": {
    "openmemory": {
      "command": "python",
      "args": ["-m", "openmemory_mcp"],
      "env": {
        "OPENMEMORY_URL": "http://richard-XPS-15-9560.local:8892"
      }
    }
  }
}

If you already have other MCP servers configured, add the openmemory entry to the existing mcpServers object:

{
  "mcpServers": {
    "existing-server": {
      "command": "...",
      "args": ["..."]
    },
    "openmemory": {
      "command": "python",
      "args": ["-m", "openmemory_mcp"],
      "env": {
        "OPENMEMORY_URL": "http://richard-XPS-15-9560.local:8892"
      }
    }
  }
}
  1. Save the file

Step 4: Restart Claude Desktop

  1. Completely quit Claude Desktop (check system tray)

  2. Restart Claude Desktop

  3. The MCP server should now be available

Testing

Test 1: Network Connectivity

From Windows PowerShell, verify you can reach the OpenMemory API:

curl http://richard-XPS-15-9560.local:8892/health

Expected response:

{"status": "ok", "timestamp": "..."}

Test 2: MCP Server in Claude Desktop

In Claude Desktop, try asking:

"Can you check if OpenMemory is healthy?"

Claude should use the health_check tool and report success.

Test 3: Search Memories

"Search my memories for 'dashboard'"

Test 4: Add Memory

"Add a memory: 'Configured OpenMemory MCP server on Windows' to the semantic sector"

Troubleshooting

"Cannot connect to OpenMemory API"

  1. Check network connectivity from Windows:

    ping richard-XPS-15-9560.local
    curl http://richard-XPS-15-9560.local:8892/health
  2. Verify OpenMemory container is running on Ubuntu:

    docker ps | grep openmemory
    docker logs openmemory
  3. Check firewall settings on both Windows and Ubuntu

"Python not found" or "Module not found"

  1. Verify Python is installed:

    python --version
  2. Reinstall dependencies:

    cd C:\Users\YourUsername\openmemory-mcp
    pip install -e . --force-reinstall

MCP Server Not Showing in Claude Desktop

  1. Check the config file path is correct:

    • %APPDATA%\Claude\claude_desktop_config.json

  2. Verify JSON syntax is valid (no trailing commas, proper quotes)

  3. Check Claude Desktop logs (if available)

  4. Completely quit and restart Claude Desktop

Memory Sectors

OpenMemory uses hierarchical memory sectors:

  • episodic - Event-based memories (what happened)

  • semantic - Conceptual knowledge (facts, concepts)

  • procedural - How-to information (processes, workflows)

  • emotional - User preferences, sentiment

  • reflective - Meta-learnings, insights

When adding memories, choose the most appropriate sector.

Development

Running Server Manually (for testing)

cd C:\Users\YourUsername\openmemory-mcp
python -m openmemory_mcp

The server will run in stdio mode and wait for MCP protocol messages.

Project Structure

openmemory-mcp/
├── pyproject.toml              # Package configuration
├── README.md                   # This file
├── .env.example                # Environment template
└── src/
    └── openmemory_mcp/
        ├── __init__.py         # Package entry point
        ├── __main__.py         # CLI entry point
        ├── client.py           # OpenMemory API client
        └── server.py           # MCP server implementation

Advanced Configuration

Using API Key Authentication

If your OpenMemory API requires authentication:

  1. Set the API key in Claude Desktop config:

{
  "mcpServers": {
    "openmemory": {
      "command": "python",
      "args": ["-m", "openmemory_mcp"],
      "env": {
        "OPENMEMORY_URL": "http://richard-XPS-15-9560.local:8892",
        "OPENMEMORY_API_KEY": "your-api-key-here"
      }
    }
  }
}

Using Custom OpenMemory URL

If your OpenMemory runs on a different host/port, update the URL:

"env": {
  "OPENMEMORY_URL": "http://different-host:8892"
}

Support

For issues:

  1. Check the troubleshooting section above

  2. Verify OpenMemory API is working directly (curl/browser)

  3. Check Claude Desktop and MCP server logs

  4. Ensure Python dependencies are correctly installed

License

MIT

Available Tools

8 tools
add_memoryA

Store a new memory. content: one self-contained fact, with absolute dates. sector: optional override of the automatic classification (episodic, semantic, procedural, emotional, reflective). tags/metadata optional; a metadata 'type' such as system_info, preference, decision, troubleshooting helps later filtering.

Inputs: content (required), tags, sector, metadata. Returns: result

delete_memoryA

Permanently delete a memory and its vectors/links. Prefer adding a corrected memory over deleting.

Inputs: memory_id (required). Returns: result

get_memoryB

Fetch one memory by id, with full metadata.

Inputs: memory_id (required). Returns: result

health_checkA

Backend health, embedding provider in use, and per-sector counts/average salience.

Inputs: no named parameters. Returns: result

list_memoriesB

List memories newest first, with pagination. sector optionally filters by primary sector.

Inputs: limit, offset, sector. Returns: result

reinforce_memoryB

Raise a memory's salience (importance) by boost (0..1, default 0.1) and mark it as seen now.

Inputs: memory_id (required), boost. Returns: result

search_memoriesA

Keyword (BM25) search over all memories: best for exact terms such as hostnames, ports, file paths, names. Works regardless of embedding provider; no side effects.

query: words to look for. sector: optional filter (episodic, semantic, procedural, emotional, reflective). require_all: if true, every query word must appear.

Inputs: query (required), k, sector, require_all. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 8 tools

    Disambiguation4/5

    search_memories and semantic_search are clearly differentiated by keyword vs. meaning-based, though reinforce_memory overlaps with semantic_search's side effect of marking memories as seen and raising salience. The other tools (add, list, get, delete, health_check) are distinct.

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern (search_memories, add_memory, list_memories, get_memory, delete_memory, reinforce_memory, health_check). health_check is a minor deviation but still clearly named.

    Tool Count5/5

    Eight tools form a well-scoped set for a memory management server, covering search, CRUD, and health checks without bloat.

    Completeness4/5

    Core lifecycle (create, read, list, delete, search) and utility (health_check, reinforce) are covered. Missing an explicit update_memory tool, though the description suggests adding a corrected memory as a workaround.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables personal AI memory management through MCP tools for adding, searching, exporting, and deleting memories, with knowledge-graph retrieval and multi-hop association for clients like Claude Desktop and Cursor.
      6
      1
      Apache 2.0
    • A
      license
      A
      quality
      B
      maintenance
      Enables Claude Desktop and compatible agents to search, read, add, update, and delete a locally stored, user-curated memory using hybrid retrieval with reranking and Qdrant. All processing runs locally without cloud services or API keys.
      9
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Gives every Claude surface (claude.ai, Desktop, mobile, Office add-ins, Claude Code) read and write access to the memories, transcripts and notes produced by Claude Code instances on all of your machines, with hybrid keyword and semantic search. Runs as a self-hosted remote MCP server with GitHub allowlist authentication, secret redaction and audit logging.
      MIT