Introduction

Developers building AI agents often face the “goldfish problem”: the model forgets everything the moment a session ends. While context windows are expanding, stuffing every past interaction into a prompt is inefficient and costly. Mem0, with over 59k GitHub stars, provides a dedicated, intelligent memory layer that extracts and stores only the high-signal facts, preferences, and relationships from conversations to enable truly personalized AI interactions across sessions.

What Is Mem0?

Mem0 is a universal memory layer for AI agents and applications that allows them to remember user preferences, adapt to individual needs, and continuously learn over time. It acts as a persistent state management system that sits between your application and the LLM, distilling conversations into structured memories rather than just storing raw chat history.

Maintained as an open-source project under the Apache 2.0 License, Mem0 is available as a Python and TypeScript SDK, a self-hosted REST API server, and a fully managed cloud platform. It integrates with a wide array of LLM providers (including OpenAI, Anthropic, and Ollama) and vector databases (such as Qdrant, Pinecone, and PostgreSQL with pgvector).

Why Mem0 Matters

Traditional RAG (Retrieval-Augmented Generation) and simple conversation history are not true AI memory. RAG retrieves documents, but it doesn’t “learn” from the user. Conversation history eventually hits a context window limit and becomes expensive. Mem0 fills this gap by implementing a self-improving system that extracts discrete facts and updates them as the user’s preferences change.

With the rise of autonomous agents, the need for persistent context is critical. An agent that remembers a user’s coding style, project architecture, and past mistakes avoids repetitive questions and reduces token usage. Benchmarks indicate that agents using Mem0 can achieve up to 90% lower token usage and 91% faster responses compared to full-context approaches by injecting only the most relevant memories.

The project’s massive traction—nearly 60,000 stars—reflects a shift in AI engineering from focusing solely on model intelligence to focusing on the infrastructure of persistence and personalization.

Key Features

• Multi-Level Memory Scoping: Mem0 can partition memories by user_id, agent_id, or run_id, allowing for a mix of personal user preferences and shared agent-specific knowledge.
• Intelligent Fact Extraction: Instead of storing raw text, Mem0 uses LLMs to distill conversations into discrete, structured facts and relationships, which are then stored as vector embeddings.
• Self-Improving Memory: The system automatically resolves conflicting facts on write. If a user says “I prefer Python” and later says “I’ve switched to Rust,” Mem0 updates the preference rather than just adding a new, conflicting entry.
• Hybrid Search Capabilities: It supports vector similarity search combined with BM25 keyword matching for high-precision retrieval of memories.
• Graph Memory (Pro/Cloud): Advanced versions of Mem0 utilize knowledge graphs to link entities and relationships, enabling multi-hop queries and deeper contextual understanding.
• Broad Infrastructure Support: It integrates with 16+ LLM providers and 24+ vector store options, including fully local setups using Ollama and Qdrant.
• Cross-Platform SDKs: Full support for Python and TypeScript/Node.js, making it easy to integrate into any modern backend stack.
• Developer-First Tooling: Includes a CLI for quick memory management and a self-hosted dashboard for auditing and managing stored memories.

How Mem0 Compares

When choosing a memory layer, developers typically compare Mem0 against general-purpose vector databases or specialized context engineering platforms like Zep.

Mem0’s primary differentiator is its focus on personalization and fact-based extraction. While Zep is exceptional for temporal context (tracking how facts change over time), Mem0 is designed to be a drop-in memory layer that can be embedded directly into an application via SDK or run as a standalone server. For developers who want full control over their vector store and LLM provider, Mem0’s open-source flexibility is a significant advantage.

Compared to LangChain’s built-in memory, Mem0 is a dedicated infrastructure piece. LangChain memory typically manages chat history in a database; Mem0 manages knowledge about the user. This means Mem0 can reduce prompt bloat significantly more than a simple history buffer.

Getting Started: Installation

Mem0 can be integrated as a library or deployed as a self-hosted server. Depending on your needs, choose one of the following methods.

Library Installation (Python)

For most developers, the simplest way to start is by installing the Python SDK. For enhanced hybrid search and entity extraction, install with NLP support:

pip install mem0ai[nlp]

python -m spacy download en_core_web_sm

Library Installation (Node.js)

Use the npm package to integrate Mem0 into your TypeScript or JavaScript applications:

npm install mem0ai

Self-Hosted Server (Docker)

To run Mem0 as a standalone REST API server with a dashboard, use the Docker Compose stack. This is the recommended path for teams needing centralized memory management.

cd server && make bootstrap

This command starts the stack, creates an admin account, and issues your first API key. You can also run the stack manually using docker compose up -d and completing the setup via the browser wizard at http://localhost:3000.

Prerequisites

You will need an LLM API key (e.g., OPENAI_API_KEY) as Mem0 requires an LLM to perform the fact extraction process. By default, it uses gpt-5-mini (or the latest available mini model) and text-embedding-3-small.

How to Use Mem0

The core workflow of Mem0 involves three primary operations: Add, Search, and Delete. The system automatically handles the extraction of facts from the provided messages.

Once initialized, you can store a memory for a specific user. Mem0 will analyze the text, extract the relevant facts (e.g., “User prefers Python over JavaScript”), and store them as embeddings in your chosen vector store.

At query time, you use the search method to retrieve only the most relevant memories for that user. This retrieved context is then injected into your LLM prompt, providing the agent with the necessary context without needing the entire chat history.

Code Examples

The following examples demonstrate the basic memory lifecycle using the Python SDK.

Basic Memory Operation

from mem0 import Memory

# Initialize Mem0
memory = Memory()

# Store a memory for a user
memory.add("I prefer Python over JavaScript and use Railway for deployments", 
           user_id="alex", 
           metadata={"category": "tech_stack"})

# Search for relevant memories
result = memory.search("What are Alex's programming preferences?", 
                      user_id="alex")

print(result)

In this example, Mem0 extracts the preference for Python and the use of Railway as separate facts and stores them under the user ID “alex”.

Advanced Memory Management

You can manage memories across different scopes (user, agent, and run) to create a complex hierarchy of context.

from mem0 import Memory

memory = Memory()

# Store agent-level memory (shared across all users)
memory.add("The company policy is to use PostgreSQL for all databases", 
           agent_id="support_agent_v1", 
           metadata={"type": "policy"})

# Store user-specific memory
memory.add("I am a beginner in Python", 
           user_id="alex", 
           metadata={"category": "skill_level"})

# Retrieve combined context
# Mem0 will retrieve memories from both the agent and user scopes
context = memory.search("How should I set up my database?", 
                      user_id="alex", 
                      agent_id="support_agent_v1")

This demonstrates how to combine global agent knowledge with personalized user data to generate a highly tailored response.

Advanced Configuration

Mem0 allows you to override the default components (LLM, Embedder, Vector Store) to fit your infrastructure. This is typically done through a configuration object or environment variables.

For the self-hosted server, you can use environment variables to change the default models:

# Example .env file for self-hosted server
OPENAI_API_KEY=sk-your-key
MEM0_DEFAULT_LLM_MODEL=gpt-4o
MEM0_DEFAULT_EMBEDDER_MODEL=text-embedding-3-small
AUTH_DISABLED=true # For local development only

You can also use Memory.from_config in the Python SDK to specify a custom vector store like Qdrant or Chroma:

from mem0 import Memory

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o"
        }
    }
}

memory = Memory.from_config(config)

Real-World Use Cases

• Personalized AI Tutors: An AI tutor that remembers a student’s current skill level, past mistakes, and learning goals across sessions, allowing it to adapt the curriculum in the day without repeating basic concepts.
• Customer Support Agents: A support bot that recalls past tickets, user preferences, and specific technical configurations of the user’s environment, reducing the need for the user to repeat information.
• AI Coding Companions: A companion that remembers project architecture, coding preferences (e.g., “I prefer functional style over OOP”), and previously fixed bugs to provide more accurate, context-aware suggestions.
• Healthcare AI Assistants: An AI assistant that can track patient history and preferences over time, providing personalized care summaries and maintaining a persistent understanding of the user’s health goals.

Contributing to Mem0

Mem0 is a polyglot monorepo containing the Python SDK, TypeScript SDK, and the self-hosted server. Contributions are welcome and encouraged through the standard GitHub flow.

The maintainers request that you open an issue first to discuss the change and avoid duplicate work. Every pull request must link to an issue using Closes #<issue-number>. Additionally, all contributors must sign the Contributor License Agreement (CLA) which is triggered by the CLA bot upon the first PR.

You can find the detailed contributor checklist in the CONTRIBUTING.md file in the repository root.

Community and Support

Mem0 has a rapidly growing community of AI engineers. You can find official support and discussion channels through the following:

• GitHub Discussions: The primary place for reporting bugs, requesting features, and technical troubleshooting.
• Discord: The official community server for real-time collaboration and discussion.
• Official Documentation: The comprehensive guide available at docs.mem0.ai.
• Mem0 Platform: For those who want a zero-ops managed version, the cloud platform is available at app.mem0.ai.

Conclusion

Mem0 provides the missing infrastructure for production AI agents. By moving beyond simple chat history and implementing a structured, self-improving memory layer, developers can create AI experiences that feel truly personalized and adaptive. It is the right choice for any project where the user interaction spans multiple sessions and where the lapped context is needed for high-quality responses.

While the open-source version is the most flexible, the managed platform offers a faster path to production for teams who don’t want to manage their own vector databases and LLM configurations. Whether you are building a tutor, a companion, or an enterprise support agent, Mem0 is the most comprehensive tool for solving the “goldfish problem” in AI.

Star the repo, try the quickstart, and join the community to start building smarter, remembering agents.

Resources

• Mem0 GitHub Repository
• Official Mem0 Documentation
• Mem0 Cloud Platform
• Example: Personalized AI Tutor with Mem0