Free Long-Term Memory for Open Core Using Memu

Mem0 — What It Is

• Official name: Mem0 (pronounced "mem-zero")
• GitHub: https://github.com/mem0ai/mem0
• Stars: 49,443 (as of March 2026, per GitHub org page)
• License: Apache 2.0
• Last commit: March 11, 2026
• Authors: Taranjeet Singh and Deshraj Yadav (YC-backed, $24M Series A, October 2025)
• Official docs: https://docs.mem0.ai
• OpenClaw integration docs: https://docs.mem0.ai/integrations/openclaw
• npm package: @mem0/openclaw-mem0
• Version: mem0ai v1.0.0 (major release with API modernization, improved vector store support, GCP integration)

Mem0 enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions — it remembers user preferences, adapts to individual needs, and continuously learns over time. It was created by Taranjeet Singh and Deshraj Yadav to address the memory limitations of modern AI systems. The company is YC-backed with a $24M Series A (October 2025) from Peak XV and Basis Set Ventures.

How It Works

Mem0 operates as a memory layer that sits between AI applications and language models, capturing and storing relevant information from user interactions — enabling AI applications to provide personalized, context-aware responses without requiring users to repeatedly establish context.

The OpenClaw problem Mem0 solves: OpenClaw agents are stateless between sessions. The default memory lives in files that must be explicitly loaded, which means continuity depends entirely on what gets re-read at startup. Context compaction — the mechanism that summarizes older context to save tokens — makes anything injected into the context window lossy. Large memory files and learned facts are compressed, rewritten, or dropped entirely.

How the plugin fixes this: The plugin runs two processes on every conversation turn: Auto-Recall searches Mem0 for memories relevant to the current message before the agent responds, injecting matching context (preferences, past decisions, project details) into the agent's working context. This happens every turn, so even after compaction truncates the conversation window, the next response still has access to everything the agent has learned. Auto-Capture sends each exchange to Mem0 after the agent responds — Mem0's extraction layer determines what's worth persisting: new facts get stored, outdated ones get updated, duplicates get merged.

Memory scopes: Long-term memories are user-scoped and persist across all sessions (your name, tech stack, project structure, decisions). Short-term memories are session-scoped and track what you're actively working on without polluting the long-term store. Both scopes are searched during recall, with long-term memories surfaced first.

Technical architecture (self-hosted): Mem0's open-source server packages the full self-hosting stack into three Docker containers: FastAPI for the REST API, PostgreSQL with pgvector for embeddings, and Neo4j for entity relationships. Mem0 requires an LLM to function, with gpt-4.1-nano as the default, but supports a variety of LLMs. Vector database options include 24+ choices including Qdrant, Chroma, Pinecone, PostgreSQL (pgvector), and MongoDB; LLM providers include 16+ options including OpenAI, Anthropic, Ollama, Groq, and local models.

Benchmark claims: In benchmarks using the LOCOMO evaluation framework, Mem0 achieved 26% higher accuracy compared to OpenAI's memory system while maintaining 91% lower latency than full-context approaches, and delivers 90% token cost savings by sending only relevant memory information rather than entire conversation histories.

Try It Yourself

Option A: Cloud (Fastest — 30 seconds)

# Step 1: Install the plugin into OpenClaw
openclaw plugins install @mem0/openclaw-mem0

# Step 2: Get a free API key at https://app.mem0.ai (no credit card required)
# Step 3: Set your environment variable
export MEM0_API_KEY="your-api-key-here"

Then add to your ~/.openclaw/openclaw.json under plugins.entries:

"openclaw-mem0": {
  "enabled": true,
  "config": {
    "apiKey": "${MEM0_API_KEY}",
    "userId": "your-unique-user-id"
  }
}

Restart OpenClaw. Auto-recall and auto-capture are enabled by default — no further configuration needed.

Option B: Fully Self-Hosted (No API key, no cloud)

# Requires OPENAI_API_KEY for default embeddings/LLM
export OPENAI_API_KEY="sk-..."

In openclaw.json:

"openclaw-mem0": {
  "enabled": true,
  "config": {
    "mode": "open-source",
    "userId": "your-user-id",
    "oss": {
      "embedder": {
        "provider": "openai",
        "config": { "model": "text-embedding-3-small" }
      },
      "vectorStore": {
        "provider": "qdrant",
        "config": { "host": "localhost", "port": 6333 }
      },
      "llm": {
        "provider": "openai",
        "config": { "model": "gpt-4o" }
      }
    }
  }
}

Option C: Full Docker Self-Host (No external API calls at all)

# Clone and spin up the full Mem0 server stack
git clone https://github.com/mem0ai/mem0
cd mem0
docker compose up
# Runs FastAPI + PostgreSQL/pgvector + Neo4j locally
# Then point the plugin to http://localhost:8000

Verify Memory Is Working

# Tell your agent something memorable
# "I usually build backend APIs in Python"

# Stop and restart OpenClaw (new session)
# Ask: "Suggest a project idea for me"
# Expected: Agent references Python without being told again

# CLI memory inspection
openclaw mem0 search "what languages does the user know"
openclaw mem0 stats

Python SDK (standalone, no OpenClaw)

pip install mem0ai

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
    system_prompt = f"You are a helpful AI. Answer based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
    assistant_response = response.choices[0].message.content
    messages.append({"role": "assistant", "content": assistant_response})
    memory.add(messages, user_id=user_id)
    return assistant_response

What The Creator Didn't Mention

1. The tool is called Mem0, not "Memu"
The creator mispronounced the name. It is "Mem0" (mem-zero). Searching for "Memu" will return nothing useful.

2. "Free" has hard limits on the managed platform
The free tier gives you 10K memories and 1K retrieval calls/month. After that, it's $19/mo for 50K memories, then $249/mo for Pro. For a solo developer or small project, that $19→$249 jump is rough. Graph memory is paywalled — the most interesting feature requires Pro ($249/mo). On free/starter, you get basic vector memory only. The self-hosted open-source version is genuinely free but requires your own infrastructure.

3. It does NOT run "24/7 in the background" autonomously
Mem0 is not a background daemon. It is triggered per conversation turn — it runs when OpenClaw processes a message. There is no autonomous background learning process.

4. LLM dependency adds cost and latency
Every memory add/update requires an LLM call, adding latency and cost that partially offsets token savings. Memory quality is LLM-dependent — fact extraction accuracy varies with the underlying model; garbage in, garbage out.

5. Known bugs in the official plugin
The official @mem0/openclaw-mem0 has issues that break self-hosted deployments: auto-recall silently discards memories due to a wrong property name in the hook return (mem0ai/mem0#4037), and embeddings ignore custom baseURL configuration. A community fork at github:tensakulabs/openclaw-mem0 exists specifically to fix these self-hosted bugs.

6. Benchmark claims are disputed
Competitors like Letta and Zep have publicly challenged Mem0's benchmark methodology, signaling a contested space.

7. Real alternatives exist
- Zep / Graphiti — graph-based temporal memory, stronger for entity relationships, but cloud-only for the full platform
- LangMem — free and open source, pip install langmem and you're done — no API keys, no accounts, no monthly bills. If you're budget-constrained, this is hard to beat. Best for LangGraph users.
- MemOS (MemTensor) — also has an OpenClaw plugin (memos-cloud-openclaw-plugin) with similar auto-recall/capture architecture
- OpenMemory MCP — runs Mem0 as a local MCP server that gives memory to coding tools like Cursor and Claude Desktop without needing a cloud deployment

8. Self-hosting minimum hardware
A t3.medium instance (2 vCPU, 4 GB RAM, ~$30/month on-demand) is the minimum for Neo4j + pgvector + the API server running side by side.