Mem0

Automatically extracts structured facts from unstructured conversational input using LLM-based parsing, deduplicating and normalizing information in a single forward pass rather than multi-stage processing. The system uses configurable LLM providers (OpenAI, Anthropic, Ollama) to identify entities, relationships, and user preferences, then stores them in a unified memory graph. This approach achieves 91.6 accuracy on LoCoMo benchmark while reducing token consumption by 3-4x compared to multi-pass extraction pipelines.

Provides hierarchical memory scoping across user, agent, and session boundaries, allowing developers to isolate and retrieve memories at different granularity levels. The Memory class and MemoryClient implement scope-aware filtering through query parameters and session context, enabling selective memory retrieval based on conversation context, user identity, or agent role. Supports advanced filtering with metadata predicates and temporal constraints to retrieve only relevant memories for a given interaction.

Provides a command-line interface for memory operations (add, search, update, delete, export) with an 'agent mode' that enables autonomous memory management through natural language commands. In agent mode, the CLI accepts free-form instructions (e.g., 'remember that I prefer decaf coffee') and automatically routes them to appropriate memory operations, making memory management accessible without API knowledge.

Exposes Mem0 as a Model Context Protocol (MCP) server, enabling AI coding agents (e.g., Devin, Claude with tools) to use memory operations as native tools. The MCP server implements standard tool schemas for add, search, update, and delete operations, allowing agents to autonomously manage memories as part of their reasoning and planning. This enables agents to build and maintain context across multiple coding tasks.

Provides built-in telemetry collection for memory operations, tracking metrics like token usage, latency, cache hit rates, and operation success rates. The system exposes these metrics through a dashboard and API, enabling developers to monitor memory system performance and optimize configurations. Token usage tracking helps teams understand and control costs associated with LLM calls for fact extraction and comparison.

Allows developers to customize the LLM prompts used for fact extraction, semantic comparison, and memory updates through a template system. Developers can define domain-specific extraction rules (e.g., for healthcare, finance) to improve extraction accuracy and relevance. The system supports prompt versioning and A/B testing to evaluate different extraction strategies.

Combines vector similarity search with graph-based entity-relationship retrieval to surface memories through both semantic relevance and structural connections. The system stores facts as nodes in a knowledge graph (using Neo4j, Kuzu, or other graph stores) while maintaining vector embeddings for semantic search, then performs hybrid retrieval by querying both backends and reranking results. This dual-index approach enables finding memories that are semantically similar OR structurally related to the query, improving recall for complex user intents.

Provides async/await patterns for memory operations (add, search, update, delete) with built-in batching to reduce API calls and improve throughput. The system queues memory operations and processes them in configurable batch sizes, with optional proxy integration for request routing and rate limiting. Supports both synchronous and asynchronous APIs, allowing developers to choose blocking or non-blocking semantics based on application requirements.

Automatically detects and merges semantically similar memories using configurable similarity thresholds and LLM-based fact comparison. When new information is added, the system searches for existing memories with similar semantic content, compares them using an LLM, and either merges them (updating the existing memory) or creates a new one. This prevents memory bloat and ensures the memory store remains concise and non-redundant, even as new information is continuously ingested.

Abstracts away LLM and embedding provider differences through a factory pattern that supports OpenAI, Anthropic, Ollama, Hugging Face, and other providers. Developers configure providers via a unified config interface and can swap providers without code changes. The system handles provider-specific API differences (e.g., function calling formats, token counting, rate limits) internally, exposing a consistent interface for fact extraction, similarity comparison, and reranking.

Provides comprehensive memory export capabilities (JSON, CSV, structured formats) with full audit trails tracking all memory modifications (add, update, delete) including timestamps, user IDs, and change deltas. The system maintains immutable history records for compliance and debugging, allowing developers to reconstruct memory state at any point in time. Supports selective export by scope, date range, or metadata filters.

Exposes memory operations through a REST API with built-in multi-tenant support via organizations and projects. The API implements role-based access control (RBAC) with API key authentication, allowing teams to manage multiple projects and users within organizations. Supports webhooks for event-driven integrations, enabling external systems to react to memory changes (e.g., trigger workflows on memory updates).

Provides native SDKs for Python and TypeScript/JavaScript with framework-specific adapters for Vercel AI, LangChain, and OpenClaw. These adapters integrate Mem0 as a drop-in memory layer for existing agent frameworks, automatically handling memory ingestion, retrieval, and context injection. The Vercel AI adapter, for example, integrates with the useChat hook, automatically capturing conversation history and user context.

Provides a self-hosted server option for on-premise or private cloud deployment, with built-in authentication (API key, OAuth), a web dashboard for memory management, and CLI tools for administration. The server exposes the same REST API as the hosted platform, enabling organizations to run Mem0 in their own infrastructure while maintaining feature parity with the cloud version.