MCPgee
MCPgee
MCPgeeMCPgee

Persistent Agent Memory

v1.0.0•Knowledge & Memory•stable

Shared Memory That Never Forgets — persistent memory for AI agents with Space-based sharing across agents and teams. Plugins for OpenCode, Claude Code, OpenClaw, MCP Server.

ai-agentai-memoryclaude-codelancedbllm
Share:
197
Stars
0
Downloads
0
Weekly
0/5
View on GitHub

What is Persistent Agent Memory?

Persistent Agent Memory is a Model Context Protocol (MCP) server that allows AI assistants like Claude, Cursor, and VS Code to shared memory that never forgets — persistent memory for ai agents with space-based sharing across agents and teams. plugins for opencode, claude code, openclaw, mcp server.

Shared Memory That Never Forgets — persistent memory for AI agents with Space-based sharing across agents and teams. Plugins for OpenCode, Claude Code, OpenClaw, MCP Server.

This server falls under the Knowledge & Memory category on MCPgee, the world's largest MCP server directory with 33,000+ servers.

Features

  • Shared Memory That Never Forgets — persistent memory for AI

Use Cases

Shared memory across multiple agents
Space-based memory sharing
Team collaboration with memory
ourmem

Maintainer

LicenseNOASSERTION
Languagerust
Versionv1.0.0
UpdatedMay 22, 2026
Statushealthy
Maintenanceactive

Works with

ClaudeOpenAIwindowsmacoslinux
View SourceBrowse All Servers

Installation

Manual Installation

npx omem

Configuration

Configuration Details

Config File

claude_desktop_config.json

Performance

Response Metrics

Response Time< 200ms
ThroughputMedium

Resource Usage

Memory UsageLow
CPU UsageLow

How to Set Up and Use Persistent Agent Memory

Omem (ourmem) is a persistent, shared memory system for AI agents that stores facts, preferences, and conversation history in a searchable vector store (powered by LanceDB) so agents never lose context between sessions. Its Space-based sharing model lets multiple agents or team members share memory pools, enabling collaborative workflows where one agent's discoveries are immediately available to others. It ships as an MCP server, an OpenCode plugin, and a Claude Code plugin, and supports both a hosted cloud service and a fully self-hosted Docker deployment with configurable embedding providers.

Prerequisites

  • An Omem API key — obtain one by creating a tenant via the hosted API or by running the self-hosted Docker image
  • Node.js with npx available (for MCP server usage)
  • Optional for self-hosting: Docker and either AWS Bedrock credentials or an OpenAI-compatible embedding API key
  • An MCP-compatible client such as Claude Desktop, Cursor, VS Code, or Claude Code
1

Create a tenant and get your API key (hosted)

Call the hosted API to create a tenant. The response includes your API key which you will use in all subsequent requests.

curl -sX POST https://api.ourmem.ai/v1/tenants \
  -H "Content-Type: application/json" \
  -d '{"name": "my-workspace"}' | jq .
2

Alternative: run self-hosted with Docker

Run the Omem server locally using Docker. Set OMEM_EMBED_PROVIDER to bedrock or openai-compatible and pass the appropriate credentials. Then create a tenant against localhost.

docker run -d -p 8080:8080 \
  -e OMEM_EMBED_PROVIDER=openai-compatible \
  -e OMEM_EMBED_API_KEY=sk-your-key \
  ghcr.io/ourmem/omem-server:latest

curl -sX POST http://localhost:8080/v1/tenants \
  -H "Content-Type: application/json" \
  -d '{"name": "my-workspace"}' | jq .
3

Add the MCP server to your client configuration

Register the @ourmem/mcp package in your MCP client config. Set OMEM_API_URL and OMEM_API_KEY from the tenant creation step.

{
  "mcpServers": {
    "ourmem": {
      "command": "npx",
      "args": ["-y", "@ourmem/mcp"],
      "env": {
        "OMEM_API_URL": "https://api.ourmem.ai",
        "OMEM_API_KEY": "your-api-key-here"
      }
    }
  }
}
4

Restart your MCP client

Restart Claude Desktop or reload your MCP client. The Omem server exposes memory tools including memory_store, memory_search, memory_get, memory_update, memory_delete, memory_list, memory_ingest, and sharing tools.

5

Store and search memories

Ask your AI assistant to store facts or preferences. The agent will call memory_store automatically. You can also explicitly ask it to search for past memories using semantic queries.

Persistent Agent Memory Examples

Client configuration

Claude Desktop / Cursor MCP config for the hosted Omem service using the @ourmem/mcp package.

{
  "mcpServers": {
    "ourmem": {
      "command": "npx",
      "args": ["-y", "@ourmem/mcp"],
      "env": {
        "OMEM_API_URL": "https://api.ourmem.ai",
        "OMEM_API_KEY": "your-api-key-here"
      }
    }
  }
}

Prompts to try

Example prompts for storing, searching, and sharing memories across agents and sessions.

- "Remember that I prefer TypeScript over JavaScript for new projects"
- "What do you know about my coding preferences?"
- "Store that the production database host is db.prod.example.com"
- "Search your memory for anything related to our API rate limits"
- "Share all my architecture decisions with my teammate's agent"
- "Show me my memory stats and storage usage"

Troubleshooting Persistent Agent Memory

401 Unauthorized when calling memory tools

Verify your OMEM_API_KEY is correct and matches the key returned during tenant creation. For self-hosted deployments, ensure OMEM_API_URL points to your local instance (e.g. http://localhost:8080) rather than the hosted URL.

Self-hosted Docker container fails to start with embedding provider errors

Ensure OMEM_EMBED_PROVIDER is set to either bedrock or openai-compatible, and that the corresponding credentials are provided: AWS_REGION + AWS credentials for Bedrock, or OMEM_EMBED_API_KEY for OpenAI-compatible providers.

memory_search returns empty results despite stored memories

Check that the embedding provider is correctly configured and healthy — embedding failures during memory_store silently prevent vectors from being indexed. Re-store a test memory and check the API response for any embedding errors.

Frequently Asked Questions about Persistent Agent Memory

What is Persistent Agent Memory?

Persistent Agent Memory is a Model Context Protocol (MCP) server that shared memory that never forgets — persistent memory for ai agents with space-based sharing across agents and teams. plugins for opencode, claude code, openclaw, mcp server. It connects AI assistants to external tools and data sources through a standardized interface.

How do I install Persistent Agent Memory?

Follow the installation instructions on the Persistent Agent Memory GitHub repository. Clone the repo, install dependencies, and add the server config to your AI client.

Which AI clients work with Persistent Agent Memory?

Persistent Agent Memory works with all major MCP-compatible AI clients including Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf, and Cline.

Is Persistent Agent Memory free to use?

Yes, Persistent Agent Memory is open source and available under the NOASSERTION license. You can use it freely in both personal and commercial projects.

Learn More About MCP Servers

Getting Started with MCP

Set up your first MCP server in minutes

MCP Setup Guide

Configure MCP in Claude, Cursor & VS Code

All MCP Tutorials

18+ hands-on guides for developers

MCP FAQ

40+ answers about Model Context Protocol

Persistent Agent Memory Alternatives — Similar Knowledge & Memory Servers

Looking for alternatives to Persistent Agent Memory? Here are other popular knowledge & memory servers you can use with Claude, Cursor, and VS Code.

MemPalace

★ 52.6k

A local AI memory system that stores all conversations verbatim and organizes them into navigable structures. It provides 19 MCP tools for AI assistants to search and retrieve past decisions, debugging sessions, and architecture debates automatically

Kratos

★ 25.7k

🏛️ Memory System for AI Coding Tools - Never explain your codebase again. MCP server with perfect project isolation, 95.8% context accuracy, and the Four Pillars Framework.

Context Mode

★ 15.4k

An MCP server that preserves LLM context by intercepting large data outputs and returning only concise summaries or relevant sections. It enables efficient sandboxed code execution, file processing, and documentation indexing across multiple programm

Memu

★ 13.7k

Memory for 24/7 proactive agents like OpenClaw.

MemOS

★ 9.3k

MemOS (Memory Operating System) is a memory management operating system designed for AI applications. Its goal is: to enable your AI system to have long-term memory like a human, not only remembering what users have said but also actively invoking, u

Everos

★ 5.4k

Build, evaluate, and integrate long-term memory for self-evolving agents.

Browse More Knowledge & Memory MCP Servers

Explore all knowledge & memory servers available in the MCPgee directory. Each server includes setup guides for Claude, Cursor, and VS Code.

Knowledge & MemoryBrowse All Servers

Quick Config Preview

{ "mcpServers": { "omem": { "command": "npx", "args": ["-y", "omem"] } } }

Add this to your claude_desktop_config.json or .cursor/mcp.json

Read the full setup guide →

Ready to use Persistent Agent Memory?

Browse our complete directory of 33,000+ MCP servers, read setup guides for your editor, and start building with the Model Context Protocol.

33,000+ ServersFree & Open SourceStep-by-Step Guides
Explore All ServersRead Our Guides