# a-mem-mcp [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/DiaaAj/a-mem-mcp  
**GitHub Stars:** 35  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/a-mem-mcp

## Description
Self-evolving memory system for AI agents

## Tools
Capabilities this server exposes over MCP:

- **add_memory_note** — Store new knowledge (async, returns immediately)
- **search_memories** — Semantic search across all memories
- **search_memories_agentic** — Search + follow graph connections
- **search_memories_by_time** — Search within a time range
- **read_memory_note** — Get full details (supports bulk reads)
- **update_memory_note** — Modify existing memory
- **delete_memory_note** — Remove a memory
- **check_task_status** — Check async task completion

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "a-mem-mcp": {
    "command": "uvx",
    "args": ["a-mem"],
    "env": {
      "LLM_BACKEND": "",
      "LLM_MODEL": "",
      "OPENAI_API_KEY": "",
      "OPENROUTER_API_KEY": "",
      "EMBEDDING_MODEL": "",
      "CHROMA_DB_PATH": "",
      "EVO_THRESHOLD": ""
    }
  }
}
```

**Requires environment variables:** `LLM_BACKEND`, `LLM_MODEL`, `OPENAI_API_KEY`, `OPENROUTER_API_KEY`, `EMBEDDING_MODEL`, `CHROMA_DB_PATH`, `EVO_THRESHOLD` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What a-mem-mcp MCP server does

a-mem-mcp MCP server provides persistent memory tools for coding agents. It stores notes, enriches them with keywords, context, and tags through an LLM, and connects related notes in a graph. The resulting memory can be searched by semantic similarity or explored through relationships between notes.

The default storage scope is per project, using a `./chroma_db` directory. A shared memory store can be configured by changing the ChromaDB path to a common location. This makes the server suitable for retaining implementation details, architectural decisions, conventions, and other project knowledge between agent sessions.

## How it works

Adding a note starts an asynchronous operation and immediately returns a task identifier. The system processes the note, searches for semantically similar existing memories, and decides whether to create or strengthen links, update related context, or evolve tags. ChromaDB stores the note metadata and relationships.

Search can begin with lightweight metadata such as identifiers, context, keywords, and tags. After locating relevant results, an agent can use `read_memory_note` to retrieve complete note details. The agentic search operation combines semantic retrieval with graph traversal to follow connected memories. `check_task_status` reports the state of asynchronous operations.

## Setup and configuration

Install the Python package with `pip install a-mem`, then register the `a-mem-mcp` executable with an MCP client. The documented setup is tested with Claude Code and passes the LLM backend, model, and credentials as environment settings. A session-start hook is installed automatically for Claude Code to remind the agent to use the memory tools.

The default backend is OpenAI with model `gpt-4o-mini`, which requires an OpenAI API key. The server also documents Ollama, sGLang, and OpenRouter backends. Ollama can run locally, while OpenRouter uses its own API key. `EMBEDDING_MODEL` controls the sentence-transformer model, `CHROMA_DB_PATH` changes the storage location, and `EVO_THRESHOLD` controls the evolution trigger threshold.

## Tools and capabilities

The server exposes eight MCP tools:

- `add_memory_note` stores knowledge asynchronously.
- `search_memories` performs semantic search.
- `search_memories_agentic` searches and follows graph connections.
- `search_memories_by_time` searches within a specified time range.
- `read_memory_note` retrieves full details and supports bulk reads.
- `update_memory_note` changes an existing memory.
- `delete_memory_note` removes a memory.
- `check_task_status` checks asynchronous task completion.

The underlying Python API is also available through `AgenticMemorySystem`, allowing applications to add, search, and read notes without using MCP.

## Limitations and notes

a-mem-mcp MCP server is currently documented as tested with Claude Code; support for other MCP-compatible agents is described as planned rather than confirmed. Memory is project-specific by default, so separate projects do not share notes unless they are configured to use the same ChromaDB path. LLM behavior and required credentials depend on the selected backend. The server implements concepts from the A-MEM research paper, but the supplied material does not specify a license.

_Full upstream README: https://allmcps.com/mcp/a-mem-mcp/readme_