Back to blog

MCP Memoria - Unlimited Local AI Memory

January 12, 2026 mcp, claude, ai, memory, qdrant, ollama, python ai

Introducing MCP Memoria

I’m excited to announce the release of MCP Memoria, a Model Context Protocol (MCP) server that provides persistent, unlimited memory capabilities for Claude Code and Claude Desktop.

Why Memoria?

When working with AI assistants like Claude, context is everything. But conversations are ephemeral - once a session ends, all that context is lost. MCP Memoria solves this by giving Claude a persistent memory that survives across sessions.

Unlike cloud-based alternatives with storage limits and privacy concerns, Memoria is:

  • 100% Local: All data stays on your machine
  • Unlimited Storage: No 50MB limits like cloud services
  • Zero Cost: Completely free and open source
  • Private: Your memories never leave your computer

How It Works

Memoria uses Qdrant for vector storage and Ollama for local embeddings. This means semantic search - finding relevant memories by meaning, not just keywords.

┌──────────────────────────────────────┐
│         Claude Code/Desktop          │
└───────────────┬──────────────────────┘
                │ MCP Protocol
                ▼
┌────────────────────────────────────────┐
│         MCP Memoria Server             │
├────────────────────────────────────────┤
│  Tools: store, recall, search, etc.    │
├────────────────────────────────────────┤
│          Memory Manager                │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐   │
│  │Episodic │ │Semantic │ │Procedure│   │
│  └─────────┘ └─────────┘ └─────────┘   │
├────────────────────────────────────────┤
│  Ollama (embeddings) │ Qdrant (vectors)│
└────────────────────────────────────────┘

Three Types of Memory

Memoria organizes knowledge into three cognitive categories:

  • Episodic Memory: Events, conversations, decisions made, problems encountered
  • Semantic Memory: Facts, knowledge, API endpoints, configurations, best practices
  • Procedural Memory: Workflows, deployment steps, build commands, common patterns

Key Features

  • Semantic Search: Find relevant memories by meaning
  • Memory Consolidation: Automatic merging of similar memories
  • Forgetting Curve: Natural decay of unused, low-importance memories
  • Project Context: Associate memories with specific projects
  • Export/Import: Backup and share your memories

Example Usage

Once configured, just talk naturally to Claude:

# Store memories
Remember that the API endpoint for users is /api/v1/users
Save this procedure: To deploy, run ./scripts/deploy.sh --env prod

# Recall memories
What do you know about the database?
How do we handle authentication in this project?

# Manage memories
Show me the memoria stats
Consolidate memories to merge duplicates
Export all memories to backup.json

Get Started

The repository is available on GitHub: github.com/trapias/memoria

Prerequisites

  • Python 3.11+
  • Ollama with nomic-embed-text model
  • Docker (optional, for Qdrant server)

Option A: Local Storage (No Docker)

The simplest setup - everything runs locally without Docker:

git clone https://github.com/trapias/memoria.git
cd memoria
./scripts/install.sh

The install script will:

  • Check and install Ollama if needed
  • Pull the nomic-embed-text embedding model
  • Create a Python virtual environment
  • Set up local Qdrant storage in ~/.mcp-memoria/qdrant
  • Generate the Claude Code configuration

Add to your Claude Code config (~/.claude/config.json):

{
  "mcp_servers": {
    "memoria": {
      "command": "/path/to/memoria/venv/bin/python",
      "args": ["-m", "mcp_memoria"],
      "env": {
        "MEMORIA_QDRANT_PATH": "~/.mcp-memoria/qdrant",
        "MEMORIA_OLLAMA_HOST": "http://localhost:11434"
      }
    }
  }
}

Option B: Docker with Qdrant Server

For better performance and scalability, run Qdrant as a Docker container:

git clone https://github.com/trapias/memoria.git
cd memoria

# Install Python package
pip install -e .

# Start Qdrant container (persistent storage)
cd docker
docker-compose -f docker-compose.qdrant-only.yml up -d

Add to your Claude Code config (~/.claude/config.json):

{
  "mcp_servers": {
    "memoria": {
      "command": "python",
      "args": ["-m", "mcp_memoria"],
      "env": {
        "MEMORIA_QDRANT_HOST": "localhost",
        "MEMORIA_QDRANT_PORT": "6333",
        "MEMORIA_OLLAMA_HOST": "http://localhost:11434"
      }
    }
  }
}

Qdrant data persists in a Docker volume - your memories survive container restarts.

Feedback

This is the first public release. Your feedback is invaluable! Please open an issue on GitHub for bugs, feature requests, or suggestions.

License

MCP Memoria is released under the Apache 2.0 license.