How do I use mcp-openmemory?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-openmemory Remember that I like coffee." 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.

mcp-openmemory

by baryhuang

Overview Schema Related Servers Score Discussions

JavaScript

Local

MCP OpenMemory Server

npm version License: MIT MCP

Gives Claude the ability to remember your conversations and learn from them over time.

https://github.com/user-attachments/assets/aef82b8e-3793-4ebd-b993-ddaef14d52d1

Features

Memory Storage: Save and recall conversation messages
Memory Abstracts: Maintain summarized memory context across conversations
Recent History: Access recent conversations within configurable time windows
Local Database: Uses SQLite for persistent storage without external dependencies

Related MCP server: memcp

⚠️ Important

You must configure MEMORY_DB_PATH to a persistent location to avoid losing your conversation history when Claude Desktop closes. If not configured, the database defaults to ./memory.sqlite in a temporary location that may be cleared when the application restarts.

Configuration

Prerequisites

Node.js: Required to run the MCP server. Verify installation with:
```
node --version
```
If not installed, download from nodejs.org
Claude Desktop: Download the latest version for macOS or Windows

Claude Desktop Integration

Configuration File Location

The Claude Desktop configuration file is located at:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

To access: Open Claude Desktop → Claude menu → Settings → Developer → Edit Config

macOS/Linux

Run directly using npm

{
  "mcpServers": {
    "mcp-openmemory": {
      "command": "npx",
      "args": [
        "@peakmojo/mcp-openmemory@latest"
      ],
      "env": {
        "MEMORY_DB_PATH": "/Users/username/mcp-memory.sqlite"
      }
    }
  }
}

Windows

Run directly using npm

{
  "mcpServers": {
    "mcp-openmemory": {
      "command": "npx",
      "args": [
        "@peakmojo/mcp-openmemory@latest"
      ],
      "env": {
        "MEMORY_DB_PATH": "C:\\Users\\username\\mcp-memory.sqlite"
      }
    }
  }
}

Run from source (all platforms)

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["/path/to/your/repo/server.js"],
      "env": {
        "MEMORY_DB_PATH": "/path/to/your/memory.sqlite"
      }
    }
  }
}

Environment Variables

MEMORY_DB_PATH: Path to SQLite database file (default: ./memory.sqlite)

Verification

After configuring and restarting Claude Desktop, you should see:

Slider Icon (🔧) in the bottom left of the input box
Available Tools when clicking the slider:
- save_memory
- recall_memory_abstract
- update_memory_abstract
- get_recent_memories

Troubleshooting

Server Not Showing Up

Restart Claude Desktop completely
Check JSON syntax in your configuration file
Verify paths are absolute (not relative) and exist

Test manual server start:

# Test if the server runs correctly
npx @peakmojo/mcp-openmemory@latest

Check Logs

Log Locations:

macOS: ~/Library/Logs/Claude/
Windows: %APPDATA%\Claude\logs\

View recent logs:

# macOS/Linux
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

# Windows  
type "%APPDATA%\Claude\logs\mcp*.log"

Common Issues

ENOENT errors on Windows: Add APPDATA to your env configuration
Tool calls failing: Check server logs for errors
NPM not found: Install NPM globally with npm install -g npm

For detailed troubleshooting, see the official MCP documentation.

Security Note

⚠️ Claude Desktop runs MCP servers with your user account permissions. Only install servers from trusted sources.

Available Tools

save_memory: Store individual conversation messages
recall_memory_abstract: Get current memory summary
update_memory_abstract: Update the memory summary
get_recent_memories: Retrieve recent conversation history

Usage

The server starts automatically when configured with Claude Desktop. The database will be created automatically on first use.

Example System Prompt

# Memory Usage Guidelines

You should use memory tools thoughtfully to enhance conversation continuity and context retention:

## When to Save Memory
- **save_memory**: Store significant conversation exchanges, important decisions, user preferences, or key context that would be valuable to remember in future conversations
- Focus on information that has lasting relevance rather than temporary details
- Save when users share important personal information, project details, or ongoing work context

## When to Update Memory Abstract  
- **update_memory_abstract**: After processing recent conversations, combine new important information with existing context to create an improved summary
- Update when there are meaningful developments in ongoing projects or relationships
- Consolidate related information to maintain coherent context over time

## When to Recall Memory
- **recall_memory_abstract**: Use at the beginning of conversations to understand previous context, or when you need background information to better assist the user
- **get_recent_memories**: Access when you need specific details from recent exchanges that aren't captured in the abstract
- Recall when the user references previous conversations or when context would significantly improve your assistance

## What Constitutes Critical Information
- User preferences and working styles
- Ongoing projects and their current status  
- Important personal or professional context
- Decisions made and their rationale
- Key relationships or collaborations mentioned
- Technical specifications or requirements for recurring tasks

Use these tools to build continuity and provide more personalized assistance, not as error-prevention mechanisms or intent-guessing systems.

🔀 Namespacing Memory by Project

You can separate memory per project in two ways:

1. Hard Separation (Claude vs Cursor)

Use different MEMORY_DB_PATH in each app's config:

Claude (claude_desktop_config.json):

"mcpServers": {
  "claude-memory": {
    "command": "npx",
    "args": ["@peakmojo/mcp-openmemory@latest"],
    "env": {
      "MEMORY_DB_PATH": "/Users/you/claude-memory.sqlite"
    }
  }
}

Cursor (.cursor/config.json or tool config):

"mcpServers": {
  "cursor-memory": {
    "command": "npx",
    "args": ["@peakmojo/mcp-openmemory@latest"],
    "env": {
      "MEMORY_DB_PATH": "/Users/you/cursor-memory.sqlite"
    }
  }
}

Each app runs its own instance, storing to its own DB.

2. Soft Namespacing via context

When calling memory tools, pass a custom "context":

{ "context": "project-x", "message": "Notes from project X." }

Use this to segment memory logically within the same database.

🔍 Semantic search is not supported yet. Open a GitHub issue if needed.

References

Model Context Protocol (MCP) Official Documentation - Complete MCP specification and guides
MCP Quickstart for Claude Desktop Users - Step-by-step setup guide
MCP Server Development Guide - For building custom MCP servers
MCP GitHub Repository - Official MCP implementation and examples
Claude Desktop - Download Claude Desktop application
Node.js - Required runtime for MCP servers

License

MIT License

Available Tools

4 tools

get_recent_memoriesA

Retrieve recent raw conversation messages from the last few days. Use this when you need to see actual conversation history rather than the processed summary. Helpful for creating or updating memory abstracts, or when you need specific details from recent exchanges. This gives you the unprocessed message data to work with.

ParametersJSON Schema

Name	Required	Description	Default
`max_days`	No
`force_refresh`	No

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that messages are 'raw' and 'unprocessed' and limited to 'the last few days'. However, it does not mention pagination, rate limits, or what form the data is returned in, nor does it specify behavior when no messages are found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Four sentences, each adding value: the first states the core purpose, the second specifies when to use, the third gives concrete use cases, and the fourth reinforces the unprocessed nature. No wasted words and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has low complexity with two optional parameters and no output schema. The description covers purpose, use cases, and contrasts with alternatives. It does not explain parameter behavior or return format, but given the simplicity, it is mostly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Context signals indicate schema description coverage is 0%, meaning the schema itself provides no parameter descriptions. The tool description does not mention the two parameters ('max_days', 'force_refresh') at all, failing to compensate for the low schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Retrieve', the resource 'raw conversation messages', and the scope 'from the last few days'. It distinguishes itself from processed summaries, which aligns with sibling tools like 'recall_memory_abstract'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use this tool ('when you need to see actual conversation history rather than the processed summary') and provides clear use cases ('creating or updating memory abstracts', 'specific details from recent exchanges'). It does not explicitly state when not to use it, but the contrast with processed summary is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

recall_memory_abstractA

Retrieve the current memory abstract that summarizes past conversations and context. Use this at the beginning of conversations to understand what has been discussed before, or when you need to check existing memory context. This gives you the processed summary of previous interactions, not raw messages. Call this to "remember" previous conversations with this user.

ParametersJSON Schema

Name	Required	Description	Default
`force_refresh`	No

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description should cover behavior. It mentions processed summary vs raw messages but does not discuss caching, side effects, or the force_refresh parameter. Limited disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Four sentences, front-loaded with purpose. The last sentence is slightly redundant but overall efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Explains what the tool returns and when to use it. Missing details on the optional parameter and behavior when memory is empty. Adequate for a simple tool but could be more complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% per context, yet the description does not mention the force_refresh parameter or its effect. Description adds no value beyond the schema for the parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool 'retrieve the current memory abstract' and explains it summarizes past conversations and context. It distinguishes from siblings by noting it gives a processed summary not raw messages.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says when to use: 'at the beginning of conversations' and 'when you need to check existing memory context'. Lacks explicit comparison to alternatives like get_recent_memories, but provides clear guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

save_memoryB

Save individual conversation messages to memory storage. Use this when you want to persist important parts of our current conversation. Call this for each significant message or exchange that should be remembered for future conversations. Typically used during or at the end of conversations to store key information, decisions, or context.

ParametersJSON Schema

Name	Required	Description	Default
`speaker`	Yes
`message`	Yes
`context`	Yes

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must disclose behavioral traits. It only says 'save' and 'persist', implying write operations, but lacks details on side effects, permissions, success states, or limits. Agent gains little insight beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each adding value. Front-loaded with action 'Save individual conversation messages to memory storage'. No fluff or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description lacks information about return values, error handling, or behavioral details. It covers usage timing but omits important operational context for a storage tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description should compensate. The description adds no new information about parameters beyond what the schema already provides (e.g., speaker, message, context descriptions exist in schema). It reiterates the general purpose but does not clarify parameter usage or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool saves individual conversation messages to memory, which is distinct from retrieving or updating memories. It specifies when to use it (persist important parts, for each significant message), but does not explicitly contrast with siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context on when to use: 'when you want to persist important parts' and 'during or at the end of conversations'. However, no exclusions or alternative tools are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_memory_abstractA

Save a new or updated memory abstract after processing recent conversations. Use this when you have reviewed recent messages, combined them with existing memory context, and created an improved summary. The typical workflow is: 1) Get current memory abstract, 2) Get recent memories, 3) Process and combine them, 4) Save the updated abstract here. This maintains the evolving memory summary over time.

ParametersJSON Schema

Name	Required	Description	Default
`abstract`	Yes
`last_processed_timestamp`	No

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It describes the write operation and maintains evolving summary, but lacks details on side effects, permissions, or rollback behavior. Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with front-loaded action and a bullet-point workflow. Every sentence adds value with no repetition or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 2 parameters and no output schema, the description adequately explains the tool's role in the workflow. However, it lacks parameter-level detail (e.g., what format abstract should be in). Still, it provides sufficient context for an agent to use it correctly within the described workflow.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description must compensate. It does not directly explain parameters beyond implying 'abstract' is the updated summary and 'last_processed_timestamp' tracks progress. No format or constraints mentioned.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states the verb 'Save' and resource 'memory abstract', and differentiates from siblings by specifying it's for saving the updated abstract after processing, not for retrieving or saving individual memories.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides a clear 4-step workflow that explicitly states when to use this tool (after processing) and implies not to use it as a standalone operation. References sibling tools (get_recent_memories, recall_memory_abstract) as preceding steps.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

4 tool updatesv0.1.4Jun 10, 2026
- First observedget_recent_memories
- First observedrecall_memory_abstract
- First observedsave_memory
- First observedupdate_memory_abstract

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Disambiguation5/5

Each tool has a clear, distinct purpose: raw message retrieval, summary retrieval, individual message storage, and summary update. No overlap in functionality.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with lowercase snake_case (e.g., get_recent_memories, update_memory_abstract). No deviations.

Tool Count5/5

With 4 tools, the server is well-scoped for memory management: covering retrieval of raw and summary data, saving individual messages, and updating the summary. Neither too many nor too few.

Completeness4/5

The toolset covers core read and write operations for both raw messages and summaries. Missing a delete operation, but the described workflow is complete for typical use.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

suma-memory A
io.github.sumanaddanki
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Knowledge & Memory Developer Tools Autonomous Agents
2
mifactory-agent-memory C
io.github.mifactory-bot
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Knowledge & Memory Autonomous Agents Agent Orchestration
22
MemoryRouter A
ai.memoryrouter
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Knowledge & Memory Search
101
mcpOAuth
ai.butlerbrain
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
Knowledge & Memory RAG Systems Workplace & Productivity
2

Related MCP Servers

acheron-mcp-server
Knowledge & Memory Developer Tools File Systems
timmx7
A
license
A
quality
D
maintenance
Cross-surface persistent memory for Claude. Bridges context between Claude Chat, Code, and Cowork via local SQLite with full-text search.
Updated 5 months ago (2026-03-26 15:36 UTC)
6
21
6
MIT
memcp
moshez
-
license
Not graded
quality
D
maintenance
Provides persistent memory for AI assistants like Claude, storing and retrieving information across conversations using a local SQLite database.
Updated a year ago (2025-06-30 14:35 UTC)
-
ccRecall
Knowledge & Memory RAG Systems
tznthou
A
license
Not graded
quality
A
maintenance
Enables Claude Code to query and store memories from past conversations using FTS5 search and topic-based retrieval, with no API costs.
Updated 13 days ago (2026-08-24 08:56 UTC)
114
1
Apache 2.0
Remember Me MCP Server
Knowledge & Memory AI & Machine Learning
ksred
F
license
Not graded
quality
D
maintenance
Enables persistent memory for Claude Desktop, allowing Claude to remember and recall information across conversations using PostgreSQL and OpenAI embeddings.
Updated a year ago (2025-09-22 10:12 UTC)
9
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/baryhuang/mcp-openmemory'

If you have feedback or need assistance with the MCP directory API, please join our Discord server