# mem0.ai

> AI-optimized mirror of mem0.ai containing 484 pages totalling 511,815 words of clean markdown content, structured data, and semantic HTML. Original source: https://mem0.ai. Last updated: 2026-07-18T06:54:45.603Z.

Each page is available as HTML (with JSON-LD structured data) and Markdown (text-only, ideal for LLMs and RAG).

## Homepage

- [JustChat | Chat with AI](/content/multimodal-demo/index.html) (31 words)
- [
](/content/status/index.html) (25 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/site-root.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (439 words)
- [Mem0 Trust Center](/content/trust/index.html): Security and compliance information for Mem0. View certifications, policies, and security controls. (148 words)

## Articles & Blog Posts

- [Custom Prompts - Mem0](/content/docs/components/rerankers/custom-prompts/index.html): Customize the LLM reranker prompt template in Mem0 to control how search results are ranked and scored. (670 words)
- [Performance Optimization - Mem0](/content/docs/components/rerankers/optimization/index.html): Best practices for optimizing reranker performance in Mem0, covering candidate sizing, batching, and tuning. (719 words)
- [AWS Bedrock - Mem0](/content/docs/components/embedders/models/aws_bedrock/index.html): Configure AWS Bedrock as an embedding provider in Mem0 with IAM credentials and boto3 authentication. (743 words)
- [Vertex AI - Mem0](/content/docs/components/embedders/models/vertexai/index.html): Configure Google Cloud Vertex AI as an embedding provider in Mem0 with support for task-specific embedding types. (665 words)
- [LangChain - Mem0](/content/docs/components/embedders/models/langchain/index.html): Use LangChain as an embedding provider in Mem0 to access a wide range of models through a unified interface. (629 words)
- [Azure OpenAI - Mem0](/content/docs/components/embedders/models/azure_openai/index.html): Configure Azure OpenAI as an embedding provider in Mem0 with API key, deployment, and endpoint settings. (462 words)
- [FastEmbed - Mem0](/content/docs/components/embedders/models/fastembed/index.html): Configure FastEmbed as an embedding provider in Mem0 to generate embeddings locally using ONNX-based models without a GPU. (395 words)
- [Hugging Face - Mem0](/content/docs/components/embedders/models/huggingface/index.html): Configure Hugging Face as an embedding provider in Mem0 for local embedding generation with open-source models. (403 words)
- [Overview - Mem0](/content/docs/components/rerankers/overview/index.html): Pick the right reranker path to boost Mem0 search relevance. (146 words)
- [Ollama - Mem0](/content/docs/components/embedders/models/ollama/index.html): Configure Ollama as an embedding provider in Mem0 to generate embeddings locally using open-source models. (298 words)
- [Google AI - Mem0](/content/docs/components/embedders/models/google_ai/index.html): Configure Google AI as an embedding provider in Mem0 using Gemini models and the GOOGLE_API_KEY variable. (335 words)
- [Configurations - Mem0](/content/docs/components/embedders/config/index.html): Reference for embedder configuration options in Mem0, including provider selection and model settings. (405 words)
- [LM Studio - Mem0](/content/docs/components/embedders/models/lmstudio/index.html): Configure LM Studio as an embedding provider in Mem0 for local embedding generation with models like nomic-embed-text. (165 words)
- [OpenAI - Mem0](/content/docs/components/embedders/models/openai/index.html): Configure OpenAI as an embedding provider in Mem0 using models like text-embedding-3-large for vector generation. (235 words)
- [LLM Reranker - Mem0](/content/docs/components/rerankers/models/llm_reranker/index.html): Use any language model as a reranker with custom prompts (1,419 words)
- [Cookbook Template - Mem0](/content/docs/templates/cookbook_template/index.html): Narrative recipe structure for end-to-end Mem0 workflows. (595 words)
- [Memory Export - Mem0](/content/docs/platform/features/memory-export/index.html): Export memories in a structured format using customizable Pydantic schemas (653 words)
- [Hugging Face Reranker - Mem0](/content/docs/components/rerankers/models/huggingface/index.html): Access thousands of reranking models from Hugging Face Hub (889 words)
- [Memory Timestamps - Mem0](/content/docs/platform/features/timestamp/index.html): Add timestamps to your memories to maintain chronological accuracy and historical context (479 words)
- [MiniMax - Mem0](/content/docs/components/llms/models/minimax/index.html): Configure MiniMax as an LLM provider in Mem0 with API key setup and optional custom endpoint configuration. (358 words)
- [Sentence Transformer - Mem0](/content/docs/components/rerankers/models/sentence_transformer/index.html): Local reranking with HuggingFace cross-encoder models (607 words)
- [Together - Mem0](/content/docs/components/embedders/models/together/index.html): Configure Together AI as an embedding provider in Mem0 with support for 1024-dimensional embedding models. (326 words)
- [Config - Mem0](/content/docs/components/rerankers/config/index.html): Reference for shared and provider-specific reranker configuration options in Mem0, including top_k and API key settings. (471 words)
- [Zero Entropy - Mem0](/content/docs/components/rerankers/models/zero_entropy/index.html): Configure Zero Entropy neural reranking models in Mem0 with zerank-1 and zerank-1-small support. (390 words)
- [Group Chat - Mem0](/content/docs/platform/features/group-chat/index.html): Enable multi-participant conversations with automatic memory attribution to individual speakers (835 words)
- [Cohere - Mem0](/content/docs/components/rerankers/models/cohere/index.html): Configure Cohere as a reranker in Mem0 with support for English and multilingual reranking models. (427 words)
- [Azure OpenAI - Mem0](/content/docs/components/llms/models/azure_openai/index.html): Configure Azure OpenAI as an LLM provider in Mem0 with Azure Identity authentication and deployment settings. (569 words)
- [LangChain - Mem0](/content/docs/components/llms/models/langchain/index.html): Use LangChain as an LLM provider in Mem0 to integrate with various chat models through a unified interface. (456 words)
- [Overview - Mem0](/content/docs/components/llms/overview/index.html): Overview of all supported LLM providers in Mem0, including OpenAI, Anthropic, Groq, Ollama, and more. (270 words)
- [Configurations - Mem0](/content/docs/components/llms/config/index.html): Reference for LLM configuration options in Mem0 for Python and TypeScript, including value precedence rules. (557 words)
- [Feedback Mechanism - Mem0](/content/docs/platform/features/feedback-mechanism/index.html): Provide positive or negative feedback on generated memories to continuously improve accuracy and search results. (610 words)
- [xAI - Mem0](/content/docs/components/llms/models/xai/index.html): Configure xAI Grok models as an LLM provider in Mem0 with API key setup and usage examples. (279 words)
- [Parameters Reference Template - Mem0](/content/docs/templates/parameters_reference_template/index.html): Use this to document accepted fields, defaults, and example payloads. (505 words)
- [Webhooks - Mem0](/content/docs/platform/features/webhooks/index.html): Configure and manage webhooks to receive real-time notifications about memory events (477 words)
- [Anthropic - Mem0](/content/docs/components/llms/models/anthropic/index.html): Configure Anthropic Claude models as the LLM provider in Mem0 with API key setup and usage examples. (229 words)
- [DeepSeek - Mem0](/content/docs/components/llms/models/deepseek/index.html): Configure DeepSeek as an LLM provider in Mem0 with API key setup and optional custom endpoint configuration. (253 words)
- [Overview - Mem0](/content/docs/components/embedders/overview/index.html): Overview of all supported embedding model providers in Mem0, including OpenAI, Azure, Ollama, and more. (108 words)
- [Together - Mem0](/content/docs/components/llms/models/together/index.html): Configure Together AI as an LLM provider in Mem0 with API key setup and optional custom endpoint configuration. (285 words)
- [LM Studio - Mem0](/content/docs/components/llms/models/lmstudio/index.html): Configure LM Studio as an LLM provider in Mem0 for running local language models via an OpenAI-compatible API. (362 words)
- [AWS Bedrock - Mem0](/content/docs/components/llms/models/aws_bedrock/index.html): Configure AWS Bedrock as an LLM provider in Mem0 with IAM authentication and Claude model support. (405 words)
- [Quickstart Template - Mem0](/content/docs/templates/quickstart_template/index.html): Guidance and skeleton for Mem0 quickstart documentation. (751 words)
- [Feature Guide Template - Mem0](/content/docs/templates/feature_guide_template/index.html): Structure for explaining when and why to use a Mem0 feature. (719 words)
- [Groq - Mem0](/content/docs/components/llms/models/groq/index.html): Configure Groq as an LLM provider in Mem0 for high-speed inference using LPU-powered language models. (229 words)
- [LiteLLM - Mem0](/content/docs/components/llms/models/litellm/index.html): Use LiteLLM as an LLM provider in Mem0 to access over 100 language models through a unified interface. (242 words)
- [API Reference Template - Mem0](/content/docs/templates/api_reference_template/index.html): Standard layout for documenting Mem0 API endpoints. (631 words)
- [Google AI - Mem0](/content/docs/components/llms/models/google_ai/index.html): Configure Google Gemini as an LLM provider in Mem0 using the google.genai SDK and GOOGLE_API_KEY variable. (244 words)
- [Ollama - Mem0](/content/docs/components/llms/models/ollama/index.html): Configure Ollama as an LLM provider in Mem0 for running local language models with tool-calling support. (245 words)
- [Mistral AI - Mem0](/content/docs/components/llms/models/mistral_ai/index.html): Configure Mistral AI as an LLM provider in Mem0 using the litellm integration and Mixtral model family. (263 words)
- [Integration Guide Template - Mem0](/content/docs/templates/integration_guide_template/index.html): A reusable template for writing integration guides that pair Mem0 with third-party tools and services. (678 words)
- [Operation Guide Template - Mem0](/content/docs/templates/operation_guide_template/index.html): Checklist and skeleton for documenting a single Mem0 operation. (578 words)
- [Release Notes Template - Mem0](/content/docs/templates/release_notes_template/index.html): Format for concise launch summaries with clear CTAs. (470 words)
- [Section Overview Template - Mem0](/content/docs/templates/section_overview_template/index.html): Blueprint for landing pages with headline, card grid, and CTAs. (491 words)
- [OpenAI - Mem0](/content/docs/components/llms/models/openai/index.html): Configure OpenAI as an LLM provider in Mem0 with support for GPT models and Openrouter compatibility. (354 words)
- [Troubleshooting Playbook Template - Mem0](/content/docs/templates/troubleshooting_playbook_template/index.html): Runbook structure for diagnosing and fixing common issues. (412 words)
- [Concept Guide Template - Mem0](/content/docs/templates/concept_guide_template/index.html): Teach mental models and terminology before diving into implementation. (460 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/the-2026-token-optimization-playbook/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Build a Companion with Mem0 - Mem0](/content/docs/cookbooks/essentials/building-ai-companion/index.html): Spin up a fitness coach that remembers goals, adapts tone, and keeps sessions personal. (2,742 words)
- [Langchain - Mem0](/content/docs/integrations/langchain/index.html): Build personalized AI agents using LangChain for conversation flow and Mem0 for long-term memory retention. (562 words)
- [Memory Evaluation - Mem0](/content/docs/core-concepts/memory-evaluation/index.html): Understand how Mem0's memory system is evaluated, benchmark results, and how to run evaluations on your own data. (2,018 words)
- [Custom Categories - Mem0](/content/docs/platform/features/custom-categories/index.html): Replace default memory tags with custom category labels that match your product terminology, set once per project or per individual add call. (1,529 words)
- [Multimodal Support - Mem0](/content/docs/platform/features/multimodal-support/index.html): Integrate images and documents into your interactions with Mem0 (736 words)
- [Sarvam AI - Mem0](/content/docs/components/llms/models/sarvam/index.html): Configure Sarvam AI as an LLM provider in Mem0, specializing in Indian language support with the Sarvam-M model. (324 words)
- [Memory Filters - Mem0](/content/docs/platform/features/v2-memory-filters/index.html): Query and retrieve memories with powerful filtering capabilities. Filter by users, agents, content, time ranges, and more. (482 words)
- [Open Source: Migrating to the New Memory Algorithm - Mem0](/content/docs/migration/oss-v2-to-v3/index.html): Guide for self-hosted Mem0 users to upgrade to the new memory algorithm with ADD-only extraction, hybrid search, and entity linking. (2,398 words)
- [Reranker-Enhanced Search - Mem0](/content/docs/open-source/features/reranker-search/index.html): Boost relevance by reordering vector hits with reranking models. (1,527 words)
- [Migrate from Open Source to Platform - Mem0](/content/docs/migration/oss-to-platform/index.html): Migrate your Mem0 Open Source implementation to Mem0 Platform for managed infrastructure and advanced features. (1,096 words)
- [Async Client - Mem0](/content/docs/platform/features/async-client/index.html): Use the AsyncMemoryClient for non-blocking memory operations in high-concurrency Python applications. (377 words)
- [REST API Server - Mem0](/content/docs/open-source/features/rest-api/index.html): Reach every Mem0 OSS capability through a FastAPI-powered REST layer. (1,501 words)
- [OpenSearch - Mem0](/content/docs/components/vectordbs/dbs/opensearch/index.html): Use OpenSearch as a vector database in Mem0 with k-NN search support via AWS OpenSearch Service serverless collections. (692 words)
- [Control Memory Ingestion - Mem0](/content/docs/cookbooks/essentials/controlling-memory-ingestion/index.html): Filter speculation, enforce formats, and gate low-confidence data before it persists. (1,642 words)
- [Graph Memory - Mem0](/content/docs/platform/features/graph-memory/index.html): Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision. (947 words)
- [Pinecone - Mem0](/content/docs/components/vectordbs/dbs/pinecone/index.html): Use Pinecone as a fully managed vector database in Mem0 with serverless deployment and namespace-based multi-tenancy. (754 words)
- [OpenClaw - Mem0](/content/docs/integrations/openclaw/index.html): Add long-term memory to OpenClaw agents using the Mem0 plugin with skills-based memory extraction and recall. (1,750 words)
- [Healthcare Coach with ADK - Mem0](/content/docs/cookbooks/integrations/healthcare-google-adk/index.html): Guide patients with an assistant that remembers history across ADK sessions. (1,026 words)
- [Memory as OpenAI Tool - Mem0](/content/docs/cookbooks/integrations/openai-tool-calls/index.html): Wire Mem0 memories into OpenAI's inbuilt function-calling flow. (865 words)
- [CLI - Mem0](/content/docs/platform/cli/index.html): Manage memories from your terminal, for both humans and AI agents. (1,858 words)
- [Neptune Analytics - Mem0](/content/docs/components/vectordbs/dbs/neptune_analytics/index.html): Use AWS Neptune Analytics as a vector store in Mem0, combining graph analytics with vector search capabilities. (563 words)
- [Apache Cassandra - Mem0](/content/docs/components/vectordbs/dbs/cassandra/index.html): Use Apache Cassandra as a distributed vector store in Mem0 with semantic search over large-scale datasets. (638 words)
- [Partition Memories by Entity - Mem0](/content/docs/cookbooks/essentials/entity-partitioning-playbook/index.html): Keep memories separate by tagging each write and query with user, agent, app, and session identifiers. (981 words)
- [vLLM - Mem0](/content/docs/components/llms/models/vllm/index.html): Configure vLLM as an LLM provider in Mem0 for high-performance local inference with GPU-optimized serving. (450 words)
- [Gemini 3 with Mem0 MCP - Mem0](/content/docs/cookbooks/frameworks/gemini-3-with-mem0-mcp/index.html): Create snappy, smart, memory-aware agents by pairing Gemini 3 with Mem0 MCP server. (774 words)
- [Baidu VectorDB (Mochow) - Mem0](/content/docs/components/vectordbs/dbs/baidu/index.html): Use Baidu Mochow as an enterprise vector database in Mem0 for high-performance vector storage and retrieval. (452 words)
- [Turbopuffer - Mem0](/content/docs/components/vectordbs/dbs/turbopuffer/index.html): Use Turbopuffer as a serverless vector database in Mem0 for low-latency search at scale with native metadata filtering. (404 words)
- [Search with Personal Context - Mem0](/content/docs/cookbooks/integrations/tavily-search/index.html): Blend Tavily's realtime results with personal context stored in Mem0. (859 words)
- [Supabase - Mem0](/content/docs/components/vectordbs/dbs/supabase/index.html): Use Supabase as a vector store in Mem0, powered by PostgreSQL and pgvector with HNSW indexing support. (663 words)
- [Highlights - Mem0](/content/docs/changelog/highlights/index.html): Major product launches, headline features, and milestones for Mem0. (1,710 words)
- [Enhanced Metadata Filtering - Mem0](/content/docs/open-source/features/metadata-filtering/index.html): Fine-grained metadata queries for precise OSS memory retrieval. (1,143 words)
- [FAQs - Mem0](/content/docs/platform/faqs/index.html): Frequently asked questions about how Mem0 works, its key features, hybrid database architecture, and memory management. (1,173 words)
- [Elasticsearch - Mem0](/content/docs/components/vectordbs/dbs/elasticsearch/index.html): Use Elasticsearch as a vector database in Mem0 for distributed vector search using dense vectors and k-NN queries. (450 words)
- [Migration Guide Template - Mem0](/content/docs/templates/migration_guide_template/index.html): Plan → migrate → validate flow with rollback coverage. (541 words)
- [Respan - Mem0](/content/docs/integrations/respan/index.html): Combine Mem0 persistent memory with Respan observability for tracked, cost-optimized AI applications. (393 words)
- [Neon - Mem0](/content/docs/components/vectordbs/dbs/neon/index.html): Use Neon as a vector store in Mem0, powered by PostgreSQL and pgvector. (468 words)
- [Weaviate - Mem0](/content/docs/components/vectordbs/dbs/weaviate/index.html): Use Weaviate as an open-source vector search engine in Mem0 for storing and retrieving vector embeddings. (368 words)
- [Update Memory - Mem0](/content/docs/core-concepts/memory-operations/update/index.html): Modify an existing memory by updating its content or metadata. (687 words)
- [Content Creation Workflow - Mem0](/content/docs/cookbooks/operations/content-writing/index.html): Store voice guidelines once and apply them across every draft. (1,052 words)
- [Upstash Vector - Mem0](/content/docs/components/vectordbs/dbs/upstash-vector/index.html): Use Upstash Vector as a serverless vector database in Mem0 with optional built-in embedding models. (364 words)
- [LangChain - Mem0](/content/docs/components/vectordbs/dbs/langchain/index.html): Use LangChain as a unified vector store provider in Mem0 to access multiple vector databases through one interface. (535 words)
- [Advanced Memory Operations - Mem0](/content/docs/platform/advanced-memory-operations/index.html): Run richer add/search/update/delete flows on the managed platform with metadata, rerankers, and per-request controls. (395 words)
- [Amazon S3 Vectors - Mem0](/content/docs/components/vectordbs/dbs/s3_vectors/index.html): Use Amazon S3 Vectors as a cost-optimized vector storage service in Mem0 with AWS credential authentication. (462 words)
- [Self-Hosted Setup - Mem0](/content/docs/open-source/setup/index.html): Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included. (1,255 words)
- [Azure MySQL - Mem0](/content/docs/components/vectordbs/dbs/azure_mysql/index.html): Use Azure Database for MySQL as a vector store in Mem0 with JSON-based vector storage for semantic search. (355 words)
- [Voice-First AI Companion - Mem0](/content/docs/cookbooks/companions/voice-companion-openai/index.html): Pair the OpenAI Agents SDK with Mem0 to build a voice assistant that remembers. (998 words)
- [Vertex AI Vector Search - Mem0](/content/docs/components/vectordbs/dbs/vertex_ai/index.html): Use Google Cloud Vertex AI Vector Search as a managed vector store in Mem0 with endpoint and index configuration. (363 words)
- [Vercel AI SDK - Mem0](/content/docs/integrations/vercel-ai-sdk/index.html): Use the Mem0 AI SDK Provider with Vercel AI SDK for persistent memory in conversational AI applications. (1,348 words)
- [Configurations - Mem0](/content/docs/components/vectordbs/config/index.html): Reference for vector database configuration options in Mem0, including provider selection and connection settings. (502 words)
- [Qdrant - Mem0](/content/docs/components/vectordbs/dbs/qdrant/index.html): Use Qdrant as an open-source vector search engine in Mem0 for high-performance similarity search at scale. (408 words)
- [FAISS - Mem0](/content/docs/components/vectordbs/dbs/faiss/index.html): Use Facebook FAISS as a high-performance vector store in Mem0, optimized for memory usage and fast similarity search. (367 words)
- [ReAct Agents with Memory - Mem0](/content/docs/cookbooks/frameworks/llamaindex-react/index.html): Teach a ReAct agent to store and recall context via Mem0. (710 words)
- [MongoDB - Mem0](/content/docs/components/vectordbs/dbs/mongodb/index.html): Use MongoDB as a vector database in Mem0 with built-in vector search for high-dimensional similarity queries. (378 words)
- [Advanced Retrieval - Mem0](/content/docs/platform/features/advanced-retrieval/index.html): Advanced memory search with intelligent reranking for precise results (558 words)
- [Milvus - Mem0](/content/docs/components/vectordbs/dbs/milvus/index.html): Use Milvus as an open-source vector database in Mem0, scalable from local development to production workloads. (378 words)
- [Leaderboard — AGENTRUSH · Mem0](/content/agentrush/leaderboard/index.html): A 7-day mind-share rumble for AI agents. Three searches and three adds per day. The most memorable memory wins. (248 words)
- [Export Stored Memories - Mem0](/content/docs/cookbooks/essentials/exporting-memories/index.html): Retrieve, review, and migrate user memories with structured exports. (739 words)
- [How Mem0 Works - Mem0](/content/docs/core-concepts/how-it-works/index.html): What happens when you add, store, and search memories with Mem0. (685 words)
- [Memory-Powered Agent SDK - Mem0](/content/docs/cookbooks/integrations/agents-sdk-tool/index.html): Expose Mem0 memories as callable tools inside OpenAI agent workflows. (645 words)
- [Platform vs Open Source - Mem0](/content/docs/platform/platform-vs-oss/index.html): Compare Mem0 Platform and Open Source to choose the right solution for managed hosting or self-hosted deployment. (425 words)
- [Bedrock with Persistent Memory - Mem0](/content/docs/cookbooks/integrations/aws-bedrock/index.html): Pair Mem0 with AWS Bedrock and OpenSearch for a managed stack. (346 words)
- [Multimodal Support - Mem0](/content/docs/open-source/features/multimodal-support/index.html): Capture and recall memories from both text and images. (975 words)
- [Tag and Organize Memories - Mem0](/content/docs/cookbooks/essentials/tagging-and-organizing-memories/index.html): Let Mem0 auto-categorize support data so teams retrieve the right facts fast. (807 words)
- [Build a Node.js Companion - Mem0](/content/docs/cookbooks/companions/nodejs-companion/index.html): Build a JavaScript fitness coach that remembers user goals run after run. (495 words)
- [Memory Expiration - Mem0](/content/docs/platform/features/memory-expiration/index.html): Give a memory a shelf life: set an expiration date and it stops surfacing in search once that date passes, without deleting the record. (979 words)
- [Cloudflare Vectorize - Mem0](/content/docs/components/vectordbs/dbs/vectorize/index.html): Use Cloudflare Vectorize as a vector database in Mem0 for building AI-powered applications at the edge. (161 words)
- [Collaborative Task Assistant - Mem0](/content/docs/cookbooks/operations/team-task-agent/index.html): Coordinate multi-user projects with shared memories and roles. (415 words)
- [Vibecoding with Mem0 - Mem0](/content/docs/vibecoding/index.html): Agent skills, starter prompts, and setup for building with Mem0 using AI coding tools. (663 words)
- [Development - Mem0](/content/docs/contributing/development/index.html): Guide to contributing code to Mem0, covering the issue-first workflow, the CLA, environment setup for the Python and TypeScript SDKs, and code quality checks. (582 words)
- [Configure the OSS Stack - Mem0](/content/docs/open-source/configuration/index.html): Configure Mem0 OSS in Python or TypeScript with your own LLM, embedder, and vector store. (607 words)
- [Memory-Powered Support Agent - Mem0](/content/docs/cookbooks/operations/support-inbox/index.html): Build a support assistant that keeps past tickets and resolutions at its fingertips. (409 words)
- [Get Memories - Mem0](/content/docs/api-reference/memory/get-memories/index.html): Retrieve memories with paginated results and advanced filtering using logical operators like AND, OR, NOT, and comparison queries. (529 words)
- [Persistent Eliza Characters - Mem0](/content/docs/cookbooks/frameworks/eliza-os-character/index.html): Bring persistent personality to Eliza OS agents using Mem0. (281 words)
- [Google ADK - Mem0](/content/docs/integrations/google-ai-adk/index.html): Integrate Mem0 with Google Agent Development Kit for persistent memory across multi-agent workflows. (1,146 words)
- [ChatDev - Mem0](/content/docs/integrations/chatdev/index.html): Add persistent, cloud-managed memory to ChatDev multi-agent workflows with Mem0: no code required, just YAML configuration. (1,127 words)
- [Personalized AI Tutor - Mem0](/content/docs/cookbooks/companions/ai-tutor/index.html): Keep student progress and preferences persistent across tutoring sessions. (450 words)
- [Update Organization Member - Mem0](/content/docs/api-reference/organization/update-org-member/index.html): Update an existing member's role within an organization to change their permissions and access level. (352 words)
- [Custom Instructions - Mem0](/content/docs/open-source/features/custom-instructions/index.html): Tailor fact extraction so Mem0 stores only the details you care about. (640 words)
- [Multi-Session Research Agent - Mem0](/content/docs/cookbooks/operations/deep-research/index.html): Run multi-session investigations that remember past findings and preferences. (235 words)
- [OpenAI Compatibility - Mem0](/content/docs/open-source/features/openai_compatibility/index.html): Use Mem0 with the same chat-completions flow you already built for OpenAI. (545 words)
- [Memory Decay - Mem0](/content/docs/platform/features/memory-decay/index.html): Boost recently-used memories and gently dampen stale ones at search time, without filtering anything out. (1,444 words)
- [Self-Hosted AI Companion - Mem0](/content/docs/cookbooks/companions/local-companion-ollama/index.html): Run Mem0 end-to-end on your machine using Ollama-powered LLMs and embedders. (319 words)
- [ElevenLabs - Mem0](/content/docs/integrations/elevenlabs/index.html): Create voice-based conversational AI agents with ElevenLabs and Mem0 for context-aware voice interactions. (1,127 words)
- [Overview - Mem0](/content/docs/integrations/index.html): Overview of Mem0 integrations with popular AI frameworks and tools for persistent memory and context management. (336 words)
- [Livekit - Mem0](/content/docs/integrations/livekit/index.html): Build memory-enabled voice assistants with LiveKit, Deepgram, OpenAI, and Mem0 for context-aware conversations. (874 words)
- [Get Event - Mem0](/content/docs/api-reference/events/get-event/index.html): Retrieve details of a specific event by ID, including status and payload for async memory operations. (369 words)
- [Add Member - Mem0](/content/docs/api-reference/organization/add-org-member/index.html): Add a new member to an organization with a specified role such as READER or OWNER access level. (60 words)
- [Visual Memory Retrieval - Mem0](/content/docs/cookbooks/frameworks/multimodal-retrieval/index.html): Store and recall visual context alongside text conversations. (147 words)
- [Persistent Mastra Agents - Mem0](/content/docs/cookbooks/integrations/mastra-agent/index.html): Extend Mastra agents with persistent memories powered by Mem0. (176 words)
- [Batch Update Memories - Mem0](/content/docs/api-reference/memory/batch-update/index.html): Update multiple memories in a single batch request using the Mem0 API PUT endpoint. (378 words)
- [Batch Delete Memories - Mem0](/content/docs/api-reference/memory/batch-delete/index.html): Delete multiple memories in a single batch request using the Mem0 API DELETE endpoint. (363 words)
- [Research Assistant for YouTube - Mem0](/content/docs/cookbooks/companions/youtube-research/index.html): Layer personalized context over any video using the Mem0 YouTube assistant. (326 words)
- [Delete Memories - Mem0](/content/docs/api-reference/memory/delete-memories/index.html): Delete all memories matching specified filters from the Mem0 memory store using the DELETE endpoint. (509 words)
- [Contribution Hub - Mem0](/content/docs/platform/contribute/index.html): Follow the shared playbook for writing and updating Mem0 documentation. (250 words)
- [OpenAI Agents SDK - Mem0](/content/docs/integrations/openai-agents-sdk/index.html): Integrate Mem0 with the OpenAI Agents SDK for persistent memory across multi-agent workflows. (803 words)
- [Add Memories - Mem0](/content/docs/api-reference/memory/add-memories/index.html): Add facts, messages, or metadata to a user memory store with async processing and event tracking via the V3 additive pipeline. (658 words)
- [Get Organization - Mem0](/content/docs/api-reference/organization/get-org/index.html): Retrieve details of a specific organization by its ID from the Mem0 platform using the GET endpoint. (406 words)
- [Get Members - Mem0](/content/docs/api-reference/organization/get-org-members/index.html): Retrieve a list of all members belonging to a specific organization on the Mem0 platform. (268 words)
- [Update Memory - Mem0](/content/docs/api-reference/memory/update-memory/index.html): Update the content, metadata, timestamp, or expiration date of a single memory by its unique ID using the PUT endpoint. (583 words)
- [Pi Agent - Mem0](/content/docs/integrations/pi-agent/index.html): Add persistent memory to Pi Agent with the Mem0 plugin semantic search, auto-capture, and dream consolidation. (871 words)
- [Temporal Reasoning - Mem0](/content/docs/platform/features/temporal-reasoning/index.html): Time-aware memory retrieval for Mem0 Platform v3 so queries like 'last week', 'upcoming', and 'right now' return the right memories. (709 words)
- [Server: Upgrading the pgvector Docker Image - Mem0](/content/docs/migration/server-pgvector-upgrade/index.html): Migrate your self-hosted Mem0 server from the archived ankane/pgvector image to the official pgvector/pgvector image. (497 words)
- [Get Events - Mem0](/content/docs/api-reference/events/get-events/index.html): List recent events for your organization and project, useful for dashboards, alerting, and audit logging. (339 words)
- [Get Users - Mem0](/content/docs/api-reference/entities/get-users/index.html): Retrieve a list of all user entities stored in the Mem0 platform using the GET endpoint. (336 words)
- [Remove Organization Member - Mem0](/content/docs/api-reference/organization/remove-org-member/index.html): Remove a member from an organization to revoke their access to its projects and resources. (325 words)
- [OpenCode - Mem0](/content/docs/integrations/opencode/index.html): Add persistent memory to OpenCode with the Mem0 plugin: native SDK-backed memory tools, lifecycle hooks, and skills. (844 words)
- [Delete User - Mem0](/content/docs/api-reference/entities/delete-user/index.html): Remove a user entity from the Mem0 platform by entity type and ID using the DELETE endpoint. (275 words)
- [Create Organization - Mem0](/content/docs/api-reference/organization/create-org/index.html): Create a new organization on the Mem0 platform to manage projects, members, and memory resources. (307 words)
- [Get Memory Export - Mem0](/content/docs/api-reference/memory/get-memory-export/index.html): Retrieve the latest structured memory export after submitting an export job, with optional entity filters. (414 words)
- [Feedback - Mem0](/content/docs/api-reference/memory/feedback/index.html): Submit positive or negative feedback on memory results to help improve memory accuracy and relevance. (341 words)
- [Get Organizations - Mem0](/content/docs/api-reference/organization/get-orgs/index.html): Retrieve a list of all organizations associated with your Mem0 account using the GET endpoint. (382 words)
- [Mem0 Enterprise — Book A Call](/content/app/enterprise/index.html): Mem0 helps AI applications store and retrieve memory at low latency and minimal cost. Talk to our team about enterprise pricing. (161 words)
- [Documentation - Mem0](/content/docs/contributing/documentation/index.html): Guide to contributing documentation to Mem0, including Mintlify setup, prerequisites, and local preview steps. (104 words)
- [Pipecat - Mem0](/content/docs/integrations/pipecat/index.html): Integrate Mem0 with Pipecat for conversational memory in AI agents (666 words)
- [Overview - Mem0](/content/docs/open-source/features/overview/index.html): Self-hosting features that extend Mem0 beyond basic memory storage (141 words)
- [Search Memories - Mem0](/content/docs/api-reference/memory/search-memories/index.html): Search memories with hybrid retrieval (semantic + BM25 + entity matching) and advanced filtering using logical and comparison operators. (405 words)
- [Get Memory - Mem0](/content/docs/api-reference/memory/get-memory/index.html): Retrieve a single memory by its unique memory ID from the Mem0 platform using the GET endpoint. (283 words)
- [Search Memory - Mem0](/content/docs/core-concepts/memory-operations/search/index.html): Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities. (882 words)
- [Build AI apps that remember - Mem0](/content/docs/introduction/index.html): Add persistent, self-improving memory to your AI app with Mem0 Platform or self-hosted Open Source. (113 words)
- [Memory History - Mem0](/content/docs/api-reference/memory/history-memory/index.html): Retrieve the full change history of a specific memory to track how it has evolved over time. (333 words)
- [docs/llms-txt.html](/content/docs/llms-txt.html) (731 words)
- [Organizations & Projects - Mem0](/content/docs/api-reference/organizations-projects/index.html): Manage multi-tenant applications with organization and project APIs (591 words)
- [Page Not Found](/content/docs/integrations/keywords/index.html) (23 words)
- [Agno - Mem0](/content/docs/integrations/agno/index.html): Add persistent multimodal memory to Agno-based agents using Mem0 for text and image interactions. (712 words)
- [Delete Memory - Mem0](/content/docs/api-reference/memory/delete-memory/index.html): Delete a single memory by its unique memory ID from the Mem0 platform using the DELETE endpoint. (269 words)
- [Quickstart - Mem0](/content/docs/platform/quickstart/index.html): Set up your Mem0 Platform account, install the SDK, and store your first memory in under five minutes. (349 words)
- [Overview - Mem0](/content/docs/cookbooks/overview/index.html): Browse cookbook examples and tutorials for building AI applications with Mem0, from companion chatbots to AI agents. (295 words)
- [Flowise - Mem0](/content/docs/integrations/flowise/index.html): Add persistent Mem0 memory to Flowise chatflows for context-aware conversations in the low-code builder. (392 words)
- [LlamaIndex - Mem0](/content/docs/integrations/llama-index/index.html): Use Mem0 as a memory store in LlamaIndex with support for ReAct and FunctionCalling agent types. (594 words)
- [AgentOps - Mem0](/content/docs/integrations/agentops/index.html): Integrate Mem0 with AgentOps for automatic monitoring, analytics, and real-time tracking of memory operations. (631 words)
- [LangGraph - Mem0](/content/docs/integrations/langgraph/index.html): Build customer support agents using LangGraph for conversation flow and Mem0 for personalized responses. (537 words)
- [Add Memory - Mem0](/content/docs/core-concepts/memory-operations/add/index.html): Add memory into the Mem0 platform by storing user-assistant interactions and facts for later retrieval. (1,009 words)
- [Codex - Mem0](/content/docs/integrations/codex/index.html): Add persistent memory to OpenAI Codex with the Mem0 plugin: MCP server, lifecycle hooks, and SDK skill. (752 words)
- [Overview - Mem0](/content/docs/open-source/overview/index.html): Self-host Mem0 with full control over your infrastructure and data (314 words)
- [Cursor - Mem0](/content/docs/integrations/cursor/index.html): Add persistent memory to Cursor with the Mem0 MCP server for context-aware coding. (463 words)
- [Mem0 vs Cognee: Best Cognee Alternative for Production AI Agent Memory](/content/compare/mem0-vs-cognee/index.html): Compare Mem0 vs Cognee across benchmarks, token efficiency, architecture, and production agent memory. See why Mem0 is a strong Cognee alternative for AI agents. (763 words)
- [Memory Types - Mem0](/content/docs/core-concepts/memory-types/index.html): See how Mem0 layers conversation, session, and user memories to keep agents contextual. (512 words)
- [Mem0 vs Mastra: Best Mastra Alternative for Production AI Agent Memory](/content/compare/mem0-vs-mastra/index.html): Compare Mem0 vs Mastra across benchmarks, token efficiency, architecture, and production agent memory. See why Mem0 is a strong Mastra alternative for AI agents. (823 words)
- [Mem0 MCP - Mem0](/content/docs/platform/mem0-mcp/index.html): Connect any AI client to Mem0 using Model Context Protocol in minutes (676 words)
- [CrewAI - Mem0](/content/docs/integrations/crewai/index.html): Combine CrewAI agent-based architecture with Mem0 for persistent memory across agent interactions. (477 words)
- [Mem0 vs Honcho: Best Honcho Alternative for Production AI Agent Memory](/content/compare/mem0-vs-honcho/index.html): Compare Mem0 vs Honcho (Plastic Labs) across benchmarks, token efficiency, pricing, self-hosting, and production agent memory. See why Mem0 is a strong Honcho alternative for AI agents. (794 words)
- [AutoGen - Mem0](/content/docs/integrations/autogen/index.html): Build conversational AI agents with AutoGen and Mem0 for context-aware, personalized interactions. (473 words)
- [AWS Bedrock - Mem0](/content/docs/integrations/aws-bedrock/index.html): Use Mem0 with AWS Bedrock and OpenSearch Service for cloud-native persistent semantic memory storage. (386 words)
- [Mem0 vs Supermemory: Best Supermemory Alternative for Production AI Agent Memory](/content/compare/mem0-vs-supermemory/index.html): Compare Mem0 vs Supermemory across benchmarks, pricing, self-hosting, integrations, and production agent memory. See why Mem0 is a strong Supermemory alternative for AI agents. (787 words)
- [Camel AI - Mem0](/content/docs/integrations/camel-ai/index.html): Plug Mem0 cloud memory into Camel's agents with the built‑in Mem0Storage. (309 words)
- [Antigravity - Mem0](/content/docs/integrations/antigravity/index.html): Add persistent memory to Google Antigravity with the Mem0 plugin: MCP server, lifecycle hooks, and slash commands. (370 words)
- [Mastra - Mem0](/content/docs/integrations/mastra/index.html): Use Mastra agents with Mem0 as the memory backend for cross-conversation storage and retrieval. (232 words)
- [Sign up as an agent - Mem0](/content/docs/platform/agent-signup/index.html): Zero-friction signup for AI agents: mint a working Mem0 API key in under five seconds. No email, no dashboard, no OTP. (532 words)
- [Mem0 raises $24M to build the memory layer for AI](/content/series-a/index.html): Mem0 raised $24M across Seed and Series A. Mem0's Seed round was led by Kindred Ventures, and Series A was led by Basis Set Ventures, with participation from Peak XV Partners, GitHub Fund, and Y Combinator. (1,024 words)
- [Raycast Extension - Mem0](/content/docs/integrations/raycast/index.html): Mem0 Raycast extension for intelligent memory management (152 words)
- [Dify - Mem0](/content/docs/integrations/dify/index.html): Integrate Mem0 as a plugin in Dify AI workflows for persistent conversation storage and retrieval. (214 words)
- [AI Memory Pricing - LLM Memory Plans Starting Free | Mem0](/content/pricing/index.html): AI memory and LLM memory pricing plans for AI agents. Free tier with 10K memories, Pro plans with unlimited memories for retrieval augmented generation. (146 words)
- [AI Memory Healthcare Agents Patient Memory | Mem0](/content/usecase/healthcare/index.html): AI memory for healthcare agents with HIPAA-compliant patient memory. LLM memory tracks medical history, treatment plans, and preferences across sessions. (277 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/claude-fable-5-memory/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/cross-channel-support-memory/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/vercel-ai-sdk-memory/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Direct Import - Mem0](/content/docs/platform/features/direct-import/index.html): Bypass the memory deduction phase and directly store pre-defined memories for efficient retrieval (282 words)
- [Valkey - Mem0](/content/docs/components/vectordbs/dbs/valkey/index.html): Use Valkey as an open-source vector store in Mem0 for high-performance key-value storage with vector search. (475 words)
- [Entity-Scoped Memory - Mem0](/content/docs/platform/features/entity-scoped-memory/index.html): Scope conversations by user, agent, app, and session so memories land exactly where they belong. (939 words)
- [Async Memory - Mem0](/content/docs/open-source/features/async-memory/index.html): Run Mem0 operations without blocking your event loop. (1,418 words)
- [Delete Memory - Mem0](/content/docs/core-concepts/memory-operations/delete/index.html): Remove memories from Mem0 either individually, in bulk, or via filters. (717 words)
- [Platform: Migrating to the New Memory Algorithm - Mem0](/content/docs/migration/platform-v2-to-v3/index.html): Guide for Mem0 Platform users to adopt the new memory algorithm with single-pass extraction, built-in graph memory, and multi-signal retrieval. (1,729 words)
- [Azure AI Search - Mem0](/content/docs/components/vectordbs/dbs/azure/index.html): Use Azure AI Search as a vector store in Mem0 for managed vector search with service name and API key setup. (797 words)
- [Node SDK Quickstart - Mem0](/content/docs/open-source/node-quickstart/index.html): Store and search Mem0 memories from a TypeScript or JavaScript app in minutes. (378 words)
- [Redis - Mem0](/content/docs/components/vectordbs/dbs/redis/index.html): Use Redis as a real-time vector database in Mem0 for fast vector search using Redis Stack and redisvl. (343 words)
- [Databricks - Mem0](/content/docs/components/vectordbs/dbs/databricks/index.html): Use Databricks Vector Search as a serverless vector store in Mem0 with auto-updating indexes from Delta tables. (395 words)
- [Langchain Tools - Mem0](/content/docs/integrations/langchain-tools/index.html): Integrate Mem0 with LangChain tools to enable AI agents to store, search, and manage memories through structured interfaces (804 words)
- [Page Not Found](/content/docs/migration/ts-v2-to-v3/index.html) (31 words)
- [Platform - Mem0](/content/docs/changelog/platform/index.html): Release notes for the Mem0 hosted platform: backend, dashboard, billing, and infrastructure changes. (737 words)
- [Get Webhook - Mem0](/content/docs/api-reference/webhook/get-webhook/index.html): Retrieve webhook configuration details for a specific project on the Mem0 platform. (503 words)
- [Create Webhook - Mem0](/content/docs/api-reference/webhook/create-webhook/index.html): Create a new webhook for a project to receive real-time notifications about memory events. (403 words)
- [Update Project - Mem0](/content/docs/api-reference/project/update-project/index.html): Update a project's settings, including name, custom instructions, and other configuration options. (526 words)
- [Update Webhook - Mem0](/content/docs/api-reference/webhook/update-webhook/index.html): Update an existing webhook configuration, such as its URL or event subscriptions, by webhook ID. (455 words)
- [Overview - Mem0](/content/docs/components/vectordbs/overview/index.html): Overview of all supported vector databases in Mem0, including Qdrant, Chroma, PGVector, Pinecone, and more. (177 words)
- [Create Project - Mem0](/content/docs/api-reference/project/create-project/index.html): Create a new project within an organization on the Mem0 platform to isolate memory resources. (370 words)
- [Python SDK Quickstart - Mem0](/content/docs/open-source/python-quickstart/index.html): Install the Mem0 Python SDK, configure your environment, and store your first memory in under five minutes. (256 words)
- [pgvector - Mem0](/content/docs/components/vectordbs/dbs/pgvector/index.html): Use pgvector as a vector store in Mem0 for PostgreSQL-based vector similarity search with open-source simplicity. (538 words)
- [Delete Project - Mem0](/content/docs/api-reference/project/delete-project/index.html): Permanently delete a project and its associated data from the Mem0 platform by project ID. (269 words)
- [Custom Instructions - Mem0](/content/docs/features/selective-memory/index.html): Control how Mem0 extracts and stores memories using natural language guidelines (424 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/claude-opus-4-8-memory-why-context-windows-arent-enough.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Update Project Member - Mem0](/content/docs/api-reference/project/update-project-member/index.html): Update an existing member's role within a project to change their permissions and access level. (373 words)
- [Smart Travel Assistant - Mem0](/content/docs/cookbooks/companions/travel-assistant/index.html): Plan itineraries that remember traveler preferences across trips. (417 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/blog/context-window-vs-persistent-memory/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (23 words)
- [Remove Project Member - Mem0](/content/docs/api-reference/project/remove-project-member/index.html): Remove a member from a project to revoke their access to its memories, configuration, and resources. (285 words)
- [Add Member - Mem0](/content/docs/api-reference/project/add-project-member/index.html): Add a new member to a project with a specified role such as READER or OWNER access level. (390 words)
- [Delete Webhook - Mem0](/content/docs/api-reference/webhook/delete-webhook/index.html): Delete an existing webhook by its ID to stop receiving notifications for memory events. (282 words)
- [Get Projects - Mem0](/content/docs/api-reference/project/get-projects/index.html): Retrieve a list of all projects within an organization on the Mem0 platform using the GET endpoint. (312 words)
- [Get Members - Mem0](/content/docs/api-reference/project/get-project-members/index.html): Retrieve a list of all members belonging to a specific project on the Mem0 platform. (263 words)
- [Delete Organization - Mem0](/content/docs/api-reference/organization/delete-org/index.html): Permanently delete an organization and its associated resources from the Mem0 platform. (265 words)
- [Get Project - Mem0](/content/docs/api-reference/project/get-project/index.html): Retrieve details of a specific project by its organization and project ID using the GET endpoint. (408 words)
- [AGENTRUSH — the most memorable memory wins · Mem0](/content/agentrush/index.html): A 7-day mind-share rumble for AI agents. Three searches and three adds per day. The most memorable memory wins. (376 words)
- [Overview - Mem0](/content/docs/platform/overview/index.html): Managed memory layer for AI agents, production-ready in minutes (246 words)
- [Interactive Memory Demo - Mem0](/content/docs/examples/mem0-demo/index.html): Spin up the showcase companion app to see Mem0 memories in action. (222 words)
- [Reranking - Mem0](/content/docs/open-source/features/reranking/index.html): Redirect to the canonical reranker-enhanced search guide. (20 words)
- [AI Agent Memory Blog | Mem0](/content/blog/index.html): Guides, research, and engineering deep-dives on memory for AI agents - persistent context, agent memory architecture, and building systems that remember. (1,116 words)
- [SDK & Tools - Mem0](/content/docs/changelog/sdk/index.html): Release notes for the Mem0 Python SDK, TypeScript SDK, Vercel AI SDK, CLI, and editor plugins. (15,156 words)
- [Hermes Agent - Mem0](/content/docs/integrations/hermes/index.html): Add long-term memory to Hermes agents with Mem0, on managed Mem0 Cloud or fully self-hosted (OSS), with automatic background sync and zero-latency prefetch. (1,053 words)
- [Overview - Mem0](/content/docs/api-reference/index.html): REST APIs for memory management, search, and entity operations (289 words)
- [Mem0 vs Zep: Best Zep Alternative for Production AI Agent Memory](/content/compare/mem0-vs-zep/index.html): Compare Mem0 vs Zep across benchmarks, pricing, self-hosting, integrations, and production agent memory. See why Mem0 is a strong Zep alternative for AI agents. (791 words)
- [Cookie Notice - Mem0 - The Memory Layer for your AI Agents](/content/cookie-notice/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (1,474 words)
- [Mem0 vs Hindsight: Best Hindsight Alternative for Production AI Agent Memory](/content/compare/mem0-vs-hindsight/index.html): Compare Mem0 vs Hindsight across benchmarks, token efficiency, pricing, self-hosting, and production agent memory. See why Mem0 is a strong Hindsight alternative for AI agents. (789 words)
- [Compare Mem0 — AI Agent Memory Platform Comparisons](/content/compare/index.html): Looking for a Cognee, Letta, Zep, or Mastra alternative Compare Mem0 against every major AI agent memory platform on accuracy, benchmarks (LOCOMO, LongMemEval, BEAM), token efficiency, and production readiness. (132 words)
- [Investors](/content/investors/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (264 words)
- [Claude Code - Mem0](/content/docs/integrations/claude-code/index.html): Add persistent memory to Claude Code and Claude Cowork with the Mem0 plugin: MCP server, lifecycle hooks, and SDK skill. (806 words)
- [Privacy Policy - Mem0 - The Memory Layer for your AI Agents](/content/privacy-policy/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (622 words)
- [Mem0 Integrations -  LangChain, CrewAI, Vercel AI SDK & 25+ More](/content/integrations/index.html): Add persistent memory to your AI agents with one drop-in. Mem0 integrates with LangGraph, LangChain, CrewAI, OpenAI Agents SDK, Vercel AI SDK, Claude Code, Cursor, LiveKit, ElevenLabs, AWS Bedrock and more. (491 words)
- [AI Memory Demo: LLM Memory & RAG Solutions | Mem0](/content/demo/index.html): AI memory demo for LLMs and AI agents. See how Mem0 provides instant memory, RAG, and vector database solutions for personalized AI applications., Mem0 has helped hundreds of AI applications store & retrieve memory at low latency and minimal cost. We'd love to show you how in 15 minutes! (239 words)
- [AI Memory Demo: LLM Memory & RAG Solutions | Mem0](/content/custom-pricing/index.html): AI memory demo for LLMs and AI agents. See how Mem0 provides instant memory, RAG, and vector database solutions for personalized AI applications., Mem0 has helped hundreds of AI applications store & retrieve memory at low latency and minimal cost. We'd love to show you how in 15 minutes! (230 words)
- [About Mem0 - Persistent Memory for AI Agents](/content/about-us/index.html): Learn about Mem0's mission to give every AI agent memory. Founded by ex-Tesla and EvalAI builders, backed by top investors, trusted by 100,000+ developers. (359 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (59 words)
- [Mem0 CLI - Agent Memory From Your Terminal](/content/cli/index.html): Add, search, and manage agent memory from the command line. Production-ready memory layer for AI agents. Available in Python and Node.js. (264 words)
- [AI Memory E-Commerce Solutions for LLM Personalization | Mem0](/content/usecase/e-commerce/index.html): Mem0 AI memory powers personalized e-commerce with LLM memory for shopping recommendations, cart recall, and customer preferences across sessions. (253 words)
- [Mem0 vs Letta: Best Letta Alternative for Production AI Agent Memory](/content/compare/mem0-vs-letta/index.html): Compare Mem0 vs Letta (formerly MemGPT) across benchmarks, pricing, self-hosting, memory architecture, and production agent memory. See why Mem0 is a strong Letta alternative for AI agents. (697 words)
- [Mem0 Research Paper: Token-Efficient Memory Algorithm](/content/research/index.html): Benchmarked across LoCoMo, LongMemEval, and BEAM, achieves competitive accuracy while using under 7,000 tokens per retrieval call. For comparison, full-context approaches on these benchmarks routinely consume 25,000+ tokens per query. (339 words)
- [AI Memory Startup Program: 3 Months Free Access | Mem0](/content/startup-program/index.html): Mem0 AI memory startup program offers 3 months free Pro plan access, priority support, and direct team collaboration for LLM memory solutions. (273 words)
- [AI Memory Sales CRM: Smart Lead Tracking & Follow-ups | Mem0](/content/usecase/sales/index.html): AI memory for sales CRM agents tracks every touchpoint, objection, and signal. Build persistent lead context, smarter follow-ups, and faster deal closes. (273 words)
- [AI Memory Customer Support: LLM Memory for Agents | Mem0](/content/usecase/customer-support/index.html): AI memory and LLM memory for customer support agents. Mem0 provides AI assistant memory to resolve issues faster with full context across channels. (265 words)
- [OpenMemory - AI Memory MCP Server for Coding Agents | Mem0](/content/openmemory/index.html): With OpenMemory, add persistent, project-aware memory to Cursor, Windsurf, and VS Code agents. Store preferences, patterns, and context that get retrieved automatically. (224 words)
- [AI Memory Education: Personalized Learning Tutors | Mem0](/content/usecase/education/index.html): AI memory for education enables personalized learning with adaptive tutors. Track student progress, create custom content paths, and provide context-aware feedback. (278 words)
- [Mem0 for OpenClaw](/content/claw-setup/index.html): Add persistent memory to OpenClaw in minutes. Install the Mem0 plugin and give your AI agent memory that carries across every session and agent. (171 words)
- [AI Memory MCP Server for Claude Desktop Integration | Mem0](/content/openmemory-mcp-3/index.html): AI memory MCP server enables persistent memory for Claude Desktop. Add LLM memory capabilities to your AI assistant with OpenMemory integration. (220 words)
- [Mem0 for OpenClaw](/content/openclaw/index.html): Add persistent memory to OpenClaw in minutes. Install the Mem0 plugin and give your AI agent memory that carries across every session and agent. (89 words)
- [Contact Mem0 | Memory for AI Agents](/content/contact-us/index.html): Questions about adding memory to your AI agents? Contact Mem0 for demos, support, and partnerships. Our team will get back to you. (24 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/old-home/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (297 words)
- [Careers at Mem0](/content/careers/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (159 words)
- [Anthropic Claude Pricing Explained: Claude Plans, API Rates & How to Cut Costs](/content/blog/anthropic-claude-pricing/index.html): Claude pricing: every plan from Free to Max ($200/mo) and full API token costs. Plus: why your bill compounds fast and how to cut it by up to 90%. (2,567 words, Jul 17, 2026)
- [How We Cut Vector Search Latency by 70x](/content/blog/how-we-cut-vector-search-latency-by-70x/index.html): Our HNSW indexes recorded zero scans in production. Here's why Postgres skipped them, and how moving vector search to Turbopuffer cut retrieval time by 70x. (1,902 words, Jul 17, 2026)
- [Adding Persistent Memory to  Claude with Mem0](/content/blog/adding-persistent-memory-to-claude-with-mem0/index.html): We tested the Mem0 Claude connector with a real two-chat memory test: state a preference once, then see if Claude recalls it with zero hints. Here's what happened. (663 words, Jul 16, 2026)
- [How Mem0 uses embeddings, and why we are evaluating NVIDIA Nemotron 3 Embed](/content/blog/how-mem0-uses-embeddings-and-why-we-are-evaluating-nvidia-nemotron-3-embed.html): A blog covering onto how Mem0 uses embeddings and our experiment results over using NVIDIA Nemotron 3 Embed (955 words, Jul 16, 2026)
- [Mem0's infer=True vs infer=False: The Fact Your AI Support Bot Forgot](/content/blog/mem0-s-infer-true-vs-infer-false-the-fact-your-ai-support-bot-forgot.html): Mem0 has two ways to remember what a customer says. One takes notes like a smart assistant. The other records like a tape recorder. This is what happened when the same conversation went through both, for real. (1,678 words, Jul 15, 2026)
- [Mem0 Claude Connector: Persistent Memory Across Every Chat](/content/blog/mem0-claude-connector-persistent-memory-across-every-chat.html): Mem0 is now an official Anthropic connector for Claude. No CLI or config file needed. Just search, connect, and Claude remembers every chat. (540 words, Jul 14, 2026)
- [5 Agentic Memory Papers at ICML 2026](/content/blog/5-breakthrough-papers-shaping-ai-agent-memory-at-icml-2026.html): Five breakthrough ICML 2026 papers show how structured retrieval, reconstruction, and new benchmarks are reshaping AI agent memory for production use. (2,383 words, Jul 10, 2026)
- [Mem0 vs. Building Your Own Vector Store for Agent Memory](/content/blog/mem0-vs-building-your-own-vector-store-for-agent-memory.html): Compare Mem0 with building a custom vector store for AI agent memory, covering identity, extraction, lifecycle, retrieval, and production tradeoffs. (2,468 words, Jul 9, 2026)
- [Harness Comparison: How Claude Code, Cursor, Devin, and Antigravity Each Handle Memory](/content/blog/harness-comparison-how-claude-code-cursor-devin-and-antigravity-each-handle-memory.html): Technical comparison of how Claude Code, Cursor, Devin, and Antigravity handle memory, and how Mem0 adds persistent, cross-session memory for AI agents. (2,760 words, Jul 8, 2026)
- [Why Your Voice Sales Agent Forgets Every Lead (And the Fix)](/content/blog/why-your-voice-sales-agent-forgets-every-lead-and-the-fix.html): Voice AI remembers nothing between calls. Mem0 gives outbound sales agents memory of every prior call . (736 words, Jul 8, 2026)
- [Give Your AI Agent Memory and Guardrails: Mem0 + Docker Sandboxes ](/content/blog/give-your-ai-agent-memory-and-guardrails-mem0-docker-sandboxes.html): Add persistent memory to AI agents with Mem0 and Docker Sandboxes. Run local, private agent memory with Docker Model Runner, microVM isolation, and no cloud keys. (3,237 words, Jul 7, 2026)
- [Mem0 for Healthcare Agents: Compliant Memory for Triage and Care](/content/blog/mem0-for-healthcare-agents-compliant-memory-for-triage-and-care.html): Learn how Mem0 gives healthcare AI agents reliable, compliant long-term memory for triage, care coordination, RAG, and clinical workflows at scale. (2,220 words, Jul 7, 2026)
- [Programmatic Memory Management for AI Agents with Mem0](/content/blog/programmatic-memory-management-for-ai-agents-with-mem0.html): Programmatic memory management in Mem0 for AI agents, including search, update, soft delete, and hard delete patterns with Python examples. (2,233 words, Jul 6, 2026)
- [How to Build a Code Review Agent Using Mem0](/content/blog/how-to-build-a-code-review-agent-using-mem0/index.html): Learn how to build a production-grade AI code review agent using Mem0 as a persistent memory layer for repositories, reviewers, and code history. (2,408 words, Jul 3, 2026)
- [Build a Local Coding Agent with Mem0 and Ollama](/content/blog/build-a-local-coding-agent-with-mem0-and-ollama/index.html): Build a local coding agent with Mem0, Qdrant, and Ollama. No Docker. No cloud API keys. Any hardware that runs a local model. (2,112 words, Jul 2, 2026)
- [How to Build a Continual Learning Agent with Mem0](/content/blog/how-to-build-a-continual-learning-agent-with-mem0/index.html): Learn how to build a continual learning AI agent that stores outcomes, reuses past lessons, and improves over time using Mem0 as a persistent memory layer. (2,587 words, Jul 2, 2026)
- [How Perplexity-Style Memory Works?](/content/blog/how-perplexity-style-memory-works-and-how-to-build-it-with-mem0.html): Learn how Perplexity-style memory works, how it models preferences and history, and how to implement the same pattern in ~50 lines using Mem0. (2,180 words, Jul 1, 2026)
- [Build an AI Companion App with Voice and Persistent Memory](/content/blog/build-an-ai-companion-app-with-voice-and-persistent-memory.html): Most AI companion apps forget users the moment a session ends. Here's how to build one with voice input, cross-session memory, and working Python code using Mem0. (1,910 words, Jun 30, 2026)
- [How to Build a Production AI Agent with LangGraph and Mem0](/content/blog/how-to-build-a-production-ai-agent-with-langgraph-and-mem0.html): Step by step guide to build production-ready LangGraph agents with Mem0, including full Python example of long-term memory integration. (2,374 words, Jun 30, 2026)
- [How to Reduce LLM Token Costs: The Persistent Memory Approach](/content/blog/reduce-llm-token-costs/index.html): Most LLM token costs come from re-sending conversation history. Here's how persistent memory cuts that by 60-90% with token counts and working code. (799 words, Jun 29, 2026)
- [How to Add Persistent Memory to GPT-5.6 Agents](/content/blog/how-to-add-persistent-memory-to-gpt-5-6-agents.html): GPT 5.6 Sol, Terra, and Luna for production agents, how ultra-mode and reasoning change memory needs, and how Mem0 provides durable long-term memory. (2,457 words, Jun 26, 2026)
- [Build a Personalized AI Tutor with Persistent Memory](/content/blog/build-a-personalized-ai-tutor-with-persistent-memory.html): Most AI tutors forget students the moment a session ends. Here's how to build one that remembers learning gaps, progress, and preferences across sessions with Mem0. (1,863 words, Jun 25, 2026)
- [How to Build a Customer Service Chatbot with Persistent Memory](/content/blog/customer-service-chatbots-with-persistent-memory-2/index.html): How to build customer service chatbots with persistent memory using Mem0, including architecture patterns, tradeoffs, and Python integration. (503 words, Jun 25, 2026)
- [Giving Pi Agent Project Memory with Mem0: A Practical Schema Migration Demo](/content/blog/giving-pi-agent-project-memory-with-mem0-a-practical-schema-migration-demo.html): Pi is a terminal coding agent. Mem0 is its memory layer. See how the @mem0/pi-agent-plugin gives Pi project-scoped memory that survives across sessions, proven on a real schema migration task. (2,010 words, Jun 25, 2026)
- [How to Add Persistent Memory to Gemma 4 Agents](/content/blog/gemma-4/index.html): Technical deep dive into Gemma 4 for production AI agents, with focus on memory limitations, local deployment, and Mem0 integration for long-term context. (1,750 words, Jun 24, 2026)
- [Introducing the Mem0 Plugin for Pi Code](/content/blog/introducing-the-mem0-plugin-for-pi-code/index.html): You can now give a persistent memory to Pi Code using the Mem0 plugin (813 words, Jun 24, 2026)
- [How to Add Memory to OpenAI Responses API Agents](/content/blog/how-to-add-memory-to-openai-responses-api-agents/index.html): Learn how to add persistent memory to OpenAI Responses API agents using Mem0, with production-ready patterns, architecture, and Python code examples. (2,217 words, Jun 23, 2026)
- [Memory Poisoning in AI Agents: How Bad Inputs Corrupt Agent Memory](/content/blog/memory-poisoning-how-bad-inputs-corrupt-your-ai-agent-s-memory.html): Learn how memory poisoning corrupts AI agent memory, what patterns cause it, and how Mem0 adds guardrails, scoring, and policies to keep agents safe. (2,403 words, Jun 22, 2026)
- [Adding Memory To Claude Connectors](/content/blog/adding-memory-to-claude-connectors/index.html): Learn how Claude connectors work, where they fall short for long-term context, and how Mem0 adds durable memory for production-grade AI agents. (1,991 words, Jun 19, 2026)
- [Building Persistent Memory for a Therapy AI Assistant](/content/blog/building-persistent-memory-for-a-therapy-ai-assistant.html): A therapist's AI captures 14 structured facts over 3 sessions. The referral letter keeps 4 sentences. See what the psychiatrist's assistant knows with and without shared memory. (1,139 words, Jun 19, 2026)
- [How memory works in Google AI chatbots and agents](/content/blog/how-memory-works-in-google-ai-chatbots-and-agents/index.html): Deep dive on how memory works in Google AI chatbots and agents, from session to long-term memory, and how Mem0 provides a portable memory layer. (2,507 words, Jun 18, 2026)
- [GLM 5.2 + Mem0: Persistent Memory for Long-Horizon Coding Agents](/content/blog/glm-5-2-mem0-persistent-memory-for-long-horizon-coding-agents.html): GLM 5.2 gives agents a 1M-token window and long-horizon reasoning, but the context still resets on every restart. Add durable cross-session memory with Mem0. (2,515 words, Jun 17, 2026)
- [Mem0 + Vercel AI SDK: Memory for Your Chat Agents](/content/blog/mem0-vercel-ai-sdk-memory-for-your-chat-agents/index.html): Vercel AI SDK builds great chat agents, but they forget users between sessions. Add a Mem0 memory layer in one backend route, with runnable Python you can paste in today. (1,777 words, Jun 16, 2026)
- [Memory Architecture for Health AI: Keeping Patient Context Across Providers and Sessions](/content/blog/memory-architecture-for-health-ai-keeping-patient-context-across-providers-and-sessions.html): Therapy AI assistants capture great notes, then bury them under months of context. Here's the memory architecture that keeps patient facts retrievable across sessions and providers. (1,312 words, Jun 16, 2026)
- [Kimi K2.7 Code Forgets Everything Between Sessions. Here Is the Fix.](/content/blog/kimi-k2-7-code-forgets-everything-between-sessions-here-is-the-fix.html): Kimi K2.7 Code is a strong coding model with no memory across sessions. Add a persistent memory layer with Mem0 in four lines, with runnable code. (1,661 words, Jun 15, 2026)
- [ DiffusionGemma for AI Agents: Adding Persistent Memory with Mem0](/content/blog/diffusiongemma-for-ai-agents-adding-persistent-memory-with-mem0.html): Learn how DiffusionGemma works, how to run it in production agents, and how Mem0 provides persistent memory for image workflows and user preferences. (2,309 words, Jun 10, 2026)
- [Adding Long-Term Memory to Claude Fable 5 Agents with Mem0](/content/blog/adding-long-term-memory-to-claude-fable-5-agents-with-mem0.html): Deep dive on memory in Claude Fable 5: how its context works, where it fails for long-term agents, and how Mem0 adds durable, queryable memory. (2,422 words, Jun 9, 2026)
- [Loop Engineering for AI Agents: Memory-First Design](/content/blog/loop-engineering-for-ai-agents-memory-first-design/index.html): Learn what loop engineering is, token-rich vs token-poor loops, and how Mem0 solves core memory challenges for production AI agents. (1,905 words, Jun 9, 2026)
- [Build an AI Agent for Customer Service That Remembers Every Customer](/content/blog/cross-channel-support-memory-with-mem0/index.html): How to Build an AI Agent for Customer Service That Remembers Across Phone, Email, and Chat (1,848 words, Jun 8, 2026)
- [GPU-Aware Agent Memory with Mem0](/content/blog/gpu-aware-agent-memory-with-mem0/index.html): Learn how Mem0 works with GPUs and TPUs, from embedding pipelines to vector search, and how to architect memory-aware GPU workloads for production agents. (2,297 words, Jun 8, 2026)
- [MAI-Thinking-1 + Mem0: Add Long-Term Memory to Microsoft's Reasoning Model](/content/blog/how-mai-thinking-1-works/index.html): Deep dive into MAI-Thinking-1 reasoning, architecture, and memory design, and how Mem0 adds persistent, production-grade recall for AI agents. (2,332 words, Jun 8, 2026)
- [Mem0 vs Hindsight vs Supermemory for Production AI Agent Memory](/content/blog/comparison-mem0-vs-hindisght-vs-supermemory/index.html): Compare Mem0 vs Hindsight vs Supermemory on benchmarks, architecture, and production agent memory. See how Mem0 solves the core long-term memory problem. (2,285 words, Jun 5, 2026)
- [How memory works in AI chatbots](/content/blog/how-memory-works-in-ai-chatbots/index.html): Technical deep dive on how memory works in AI chatbots, from context windows to vector stores, and how Mem0 provides durable, queryable agent memory. (2,315 words, Jun 5, 2026)
- [Open source AI agents with built‑in memory](/content/blog/open-source-ai-agents-with-built-in-memory/index.html): How open source AI agents use built-in memory with Mem0 to provide persistent, personalized behavior for production-grade autonomous systems. (2,359 words, Jun 5, 2026)
- [Understanding Memory Benchmark For Production AI Agents](/content/blog/understanding-memory-benchmark-for-production-ai-agents.html): Learn how to design and interpret memory benchmarks for production AI agents, where they fail in practice, and how Mem0 improves retrieval and recall. (2,423 words, Jun 5, 2026)
- [Why BEAM Is a Good Memory Benchmark for AI Agents](/content/blog/why-beam-is-a-good-memory-benchmark-for-ai-agents/index.html): Learn why the BEAM benchmark matters for evaluating agent memory, how it works, where it breaks, and how Mem0 achieves state-of-the-art results. (1,594 words, Jun 5, 2026)
- [Adding Persistent Memory To MiniMax M3 With Mem0](/content/blog/adding-persistent-memory-to-minimax-m3-with-mem0/index.html): MiniMax M3 handles next-step reasoning. Mem0 handles cross-session memory. Here's how to combine both into a coding agent that picks up where it left off. (2,533 words, Jun 4, 2026)
- [AI knowledge base agents with persistent memory](/content/blog/ai-knowledge-base-agents-with-persistent-memory/index.html): Learn how to build AI knowledge base agents with persistent memory, why context windows are not enough, and how Mem0 simplifies long-term memory. (2,454 words, Jun 4, 2026)
- [How to add memory to autonomous AI agents](/content/blog/how-to-add-memory-to-autonomous-ai-agents/index.html): Learn practical patterns to add memory to autonomous AI agents, and see how Mem0 provides a production-ready memory layer with real Python examples. (2,166 words, Jun 4, 2026)
- [Mem0 vs Honcho for AI Agent Memory in Production](/content/blog/mem0-vs-honcho/index.html): Compare Mem0 vs Honcho for production AI agent memory, including benchmarks, scopes, Python examples, and how Mem0 solves persistent memory. (1,809 words, Jun 4, 2026)
- [Mem0 vs Zep  Which AI Memory Platform Is Better for Production Agents?](/content/blog/mem0-vs-zep/index.html): Compare Mem0 vs Zep across benchmarks, pricing, self-hosting, integrations, and production agent memory for long-term AI agents in production. (2,032 words, Jun 4, 2026)
- [Claude Opus 4.8 Memory: Why Context Windows Aren't Enough](/content/blog/claude-opus-4-8-memory-why-context-windows-aren-t-enough.html): Claude Opus 4.8 supports 1M tokens. But context isn't memory. Here's a live demo showing what Opus 4.8 can't do alone and how Mem0 fills the cross-session gap. (2,070 words, Jun 3, 2026)
- [OpenAI Responses API and realtime agents with memory](/content/blog/openai-responses-api-and-realtime-agents-with-memory.html): Learn how to build OpenAI Responses API realtime agents with persistent memory using Mem0 for long-term, personalized, and context-aware behavior. (2,147 words, Jun 3, 2026)
- [How to create AI agents with long‑term memory](/content/blog/how-to-create-ai-agents-with-long-term-memory/index.html): Learn practical patterns for AI agents with long-term memory and see how Mem0 provides production-ready storage, retrieval, and personalization. (2,291 words, Jun 2, 2026)
- [AI agent frameworks and how to choose a memory strategy](/content/blog/ai-agent-frameworks-and-how-to-choose-a-memory-strategy.html): Guide for AI engineers on agent frameworks and production memory strategies, with concrete patterns and Mem0 integration examples in Python. (2,418 words, Jun 1, 2026)
- [AI coding agents that actually remember your codebase](/content/blog/ai-coding-agents-that-actually-remember-your-codebase.html): How to build AI coding agents that persistently remember large codebases using Mem0 as a dedicated memory layer for context, decisions, and edits. (2,441 words, Jun 1, 2026)
- [Adding Persistent Memory to Azure AI Agents with Mem0](/content/blog/ai-agent-platforms-on-azure-with-persistent-memory/index.html): Learn how to build production AI agent platforms on Azure with persistent memory using Mem0, covering architecture, patterns, and Python integration. (2,208 words, May 29, 2026)
- [Build a Financial AI Agent That Remembers Analyst Preferences](/content/blog/build-a-financial-ai-agent-that-remembers-analyst-preferences.html): Most financial AI agents retrieve a table and stop. Here's how to build one that remembers valuation preferences and analyst style across sessions. (2,170 words, May 29, 2026)
- [How to Build Context Queries for AI Agents with Mem0](/content/blog/how-to-build-context-queries-for-ai-agents-with-mem0.html): Learn how context queries power production AI agents, patterns for retrieval, limitations, and how Mem0 provides durable, queryable memory for agents. (2,148 words, May 29, 2026)
- [Agent Memory: Built-In Patterns vs. Dedicated Layer](/content/blog/agent-memory-built-in-patterns-vs-dedicated-layer.html): Learn how AI agent platforms implement built-in memory patterns, where they fall short in production, and how Mem0 fixes core memory gaps. (2,247 words, May 28, 2026)
- [Context Engineering for AI Agents: How to Route Queries to Memory](/content/blog/context-engineering-for-ai-agents-how-to-route-queries-to-memory.html): Learn how to detect context queries in AI agents, route them to memory, and integrate Mem0 for reliable retrieval, storage, and personalization. (2,606 words, May 28, 2026)
- [Customer-Aware Agent With Gemini 3.5 Flash and Mem0](/content/blog/customer-aware-agent-with-gemini-3-5-flash-and-mem0.html): Most support agents forget users the moment they close the tab. Here's how to build a Gemini 2.5 Flash agent with durable customer and account memory via Mem0. (1,079 words, May 28, 2026)
- [How Mem0 Gives Stateless Edge Agents Long-Term Memory](/content/blog/remote-memory-for-ai-agents-running-at-the-edge/index.html): How remote memory solves context limits for AI agents at the edge, with patterns, tradeoffs, and Mem0 integration code for production systems. (2,440 words, May 27, 2026)
- [What is Agentic AI & Why Memory is The Missing Piece?](/content/blog/what-is-agentic-ai-why-memory-is-the-missing-piece/index.html): Learn what agentic AI really is, why long-term memory is the missing piece for production agents, and how Mem0 solves the core memory problem. (2,299 words, May 27, 2026)
- [AI-Powered Coding Agents That Actually Remember Your Codebase](/content/blog/ai-powered-coding-agents-that-actually-remember-your-codebase.html): Coding agents fail on real projects because they have no durable memory. Add persistent, queryable memory for repository structure, design decisions, and user preferences with Mem0. (2,349 words, May 26, 2026)
- [Build an AI Agent That Remembers Your Users](/content/blog/build-an-ai-agent-that-remembers-your-users/index.html): Production AI agents forget everything between calls. Learn how to add persistent, per-user memory to your agent with Mem0 that survive every session. (2,461 words, May 26, 2026)
- [Agentic AI in Production Systems](/content/blog/agentic-ai-in-production-systems/index.html): Agentic AI systems act, plan, and remember across sessions. Learn how memory works in production agents and how Mem0 solves context sprawl, session amnesia, and tool overload. (2,872 words, May 25, 2026)
- [Building AI Chatbot With Persistent Memory](/content/blog/ai-chatbot-development-with-persistent-memory/index.html): Stateless chatbots break at scale. Add persistent memory to your AI chatbot with Mem0 including user profiles, interaction history, and task state across every session. (2,296 words, May 25, 2026)
- [Build a Customer Support Agent with Next.js and Mem0](/content/blog/build-a-customer-support-agent-with-next-js-and-mem0.html): Your AI support agent forgets users the moment they close the tab. Add cross-session memory to Next.js with Mem0 (2,308 words, May 25, 2026)
- [Give Your AI Agent Persistent Memory in Under 5 Seconds](/content/blog/give-your-ai-agent-persistent-memory-in-under-5-seconds.html): Run one command and your AI agent has a working memory API key, a stable user ID, and an MCP endpoint-  no email, no browser, no human required. (852 words, May 22, 2026)
- [How to Enable Memory in Your Agentic Stack with a Single Command](/content/blog/how-to-enable-memory-in-your-agentic-stack-with-a-single-command.html): mem0 init --agent --json provisions a Mem0 API key in under 5 seconds. No email, no browser. Includes LangGraph and CrewAI integration snippets. (706 words, May 22, 2026)
- [The Easiest Way to Add Persistent Memory to Any AI Agent](/content/blog/the-easiest-way-to-add-persistent-memory-to-any-ai-agent.html): Learn how to give any AI agent persistent, semantically searchable memory with a single CLI command. No human signup needed. Works with LangGraph, CrewAI, Claude Code, and Cursor. (879 words, May 22, 2026)
- [Persistent Memory Integration For Google Antigravity CLI](/content/blog/add-persistent-memory-to-google-antigravity-cli-with-mem0-mcp.html): Persistent memory helps Google Antigravity CLI retain context across sessions. Discover persistent memory ai & build persistent AI systems that boost agent recall (1,819 words, May 21, 2026)
- [Agent Mode AI For Secure Signup & Identity Authentication](/content/blog/introducing-agentmode-mem0-signup-without-a-human-in-the-loop.html): Agent mode AI improves trust in automated sign in and signup flows. Explore agentic AI authentication and AI agent identity with agentic authentication methods (1,018 words, May 21, 2026)
- [Agent Models And Memory First Architectures](/content/blog/agent-models-and-memory-first-architectures/index.html): Explore memory-first agent architectures: how agents that retrieve, reason, and checkpoint memory outperform stateless alternatives at scale. (1,619 words, May 20, 2026)
- [Agentic workflows with Persistent Memory](/content/blog/agentic-workflows-with-persistent-memory/index.html): Agentic workflows lose context between runs by default. Learn how persistent memory keeps agents informed across sessions using Mem0 and LangGraph. (1,759 words, May 20, 2026)
- [Context Compression vs Memory in AI Agents](/content/blog/context-compression-vs-memory-in-ai-agents/index.html): Context compression shrinks what is in the window. Memory stores what is worth keeping long-term. Learn how both techniques work and when to use each. (1,292 words, May 20, 2026)
- [Context Engineering in Multi-Turn AI Agents](/content/blog/context-engineering-in-multi-turn-ai-agents/index.html): Context engineering keeps AI agents coherent across long conversations. Learn sliding window, summarization, and memory-augmented context strategies.
 (1,807 words, May 20, 2026)
- [FastMCP tools with Shared Memory for AI Agents](/content/blog/fastmcp-tools-with-shared-memory-for-ai-agents/index.html): FastMCP makes building MCP tools straightforward. Learn how to add shared persistent memory across MCP tool calls using Mem0. (1,375 words, May 20, 2026)
- [How Memory Works In Agent-to-Agent Protocols](/content/blog/how-memory-works-in-agent-to-agent-protocols/index.html): When agents hand off tasks to other agents, memory does not transfer automatically. Learn how shared memory works across agent-to-agent protocols. (1,883 words, May 20, 2026)
- [How to add memory to LangGraph Agents](/content/blog/how-to-add-memory-to-langgraph-agents/index.html): Learn how to add persistent, per-user memory to LangGraph agents with Mem0. (1,118 words, May 20, 2026)
- [How To Reduce Context Cost With Smart Context Construction](/content/blog/how-to-reduce-context-cost-with-smart-context-construction.html): Context window costs compound fast in multi-turn agents. Learn smart context construction techniques to reduce token usage without losing relevant context. (1,795 words, May 20, 2026)
- [Memory Layer for Open Source Agent Frameworks](/content/blog/memory-layer-for-open-source-agent-frameworks/index.html): Learn how LangGraph, AutoGen, CrewAI, and LangChain handle memory natively and how to add persistent, cross-session user memory with Mem0. (1,366 words, May 20, 2026)
- [Message Indexing And Memory Capture For AI Agents](/content/blog/message-indexing-and-memory-capture-for-ai-agents/index.html): Raw message indexing accumulates noise. Learn how extraction-first memory capture gives AI agents precise, deduplicated context from conversation history. (1,791 words, May 20, 2026)
- [Persistent Memory for Claude Agents SDK](/content/blog/persistent-memory-for-claude-agents-sdk/index.html): The Claude Agents SDK tracks session state but not user context across sessions. Learn how to add persistent, per-user memory with Mem0. (1,154 words, May 20, 2026)
- [Vector Databases And Memory For AI Agents](/content/blog/vector-databases-and-memory-for-ai-agents/index.html): Vector databases handle retrieval but not memory. Learn what a real memory layer adds: fact extraction, deduplication, and conflict resolution. (1,622 words, May 20, 2026)
- [Codex + Mem0 MCP: Build a Coding Agent That Remembers Your Codebase](/content/blog/codex-mem0-mcp-build-a-coding-agent-that-remembers-your-codebase.html): Give Codex persistent codebase memory with Mem0 MCP. Store and retrieve architecture decisions, constraints, and debugging context across sessions, machines, and tools. (2,199 words, May 19, 2026)
- [How Hermes and Claude Handle Context Compression in Agents](/content/blog/how-hermes-and-claude-handle-context-compression-in-real-production-agents-and-what-you-should-extract.html): 65% of enterprise AI failures trace to context degradation, not token limits. See how Hermes and Claude Code compress context - and what you must extract to Mem0 before it fires. (2,739 words, May 14, 2026)
- [The Token-Efficient Memory Algorithm Now Has Temporal Reasoning](/content/blog/the-token-efficient-memory-algorithm-now-has-temporal-reasoning.html): Mem0’s updated token-efficient memory algorithm adds Temporal Reasoning and Memory Decay, reaching 92.5% on LoCoMo and 94.4% on LongMemEval while staying under a <7,000-token retrieval budget. (890 words, May 14, 2026)
- [Agent Memory Staleness: How Recency-Aware Ranking Fixes Retrieval Drift](/content/blog/memory-decay-for-long-running-agents-how-recency-aware-ranking-fixes-retrieval-staleness.html): Long-running agents surface stale memories because retrieval ignores recency. Mem0 Memory Decay fixes this: real A/B results, 0.15 score gap, copy-paste harness. (3,045 words, May 13, 2026)
- [Introducing Temporal Reasoning in Mem0](/content/blog/introducing-temporal-reasoning-in-mem0/index.html): Introducing Temporal Reasoning in Mem0: a time-aware memory feature that helps AI agents understand when facts were true, track evolving user context, and improve LongMemEval accuracy to 94.8% at top_50. (2,346 words, May 12, 2026)
- [AI Memory Benchmarks 2026: LoCoMo, LongMemEval & BEAM](/content/blog/ai-memory-benchmarks-in-2026/index.html): LoCoMo 92.5%, LongMemEval 94.4%, BEAM 1M 62%: a breakdown of every major AI memory benchmark in 2026 and where Mem0 stands (2,443 words, May 11, 2026)
- [Memory vs Context Window for LLM and AI Agents | Mem0](/content/blog/context-window-is-ram-not-storage-why-most-agent-failures-happen-how-to-fix-them-in-2026.html): Learn the real difference between memory vs context window for LLM agents. Why most AI agents fail and how to use long-term memory to build stateful AI (2,920 words, May 11, 2026)
- [Episodic memory for AI agents](/content/blog/episodic-memory-for-ai-agents/index.html): What is Episodic memory, why agents need episodic memoryband how to wire it through Mem0. (2,021 words, May 11, 2026)
- [Memory eviction and forgetting in AI agents](/content/blog/memory-eviction-and-forgetting-in-ai-agents/index.html): Whar is memory eviction, why an agent that remembers everything recalls badly and how to design forgetting on purpose. (2,195 words, May 11, 2026)
- [Memory Retrieval Strategies for AI Agents](/content/blog/memory-retrieval-strategies-for-ai-agents/index.html): The multiple retrieval strategies for AI agent memory, their tradeoffs, failure modes, and how to pick one for your usecase (2,094 words, May 11, 2026)
- [Semantic Memory for AI Agents](/content/blog/semantic-memory-for-ai-agents/index.html): What semantic memory is for AI agents, why personal facts matter beyond a model's baked-in world knowledge, and where Mem0 fits. (1,883 words, May 11, 2026)
- [Working memory for AI agents](/content/blog/working-memory-for-ai-agents/index.html): What working memory means for AI agents, why a context window is not the same thing, and how to design for it. (1,910 words, May 11, 2026)
- [Codex CLI Memory: How It Works + What Mem0 Adds](/content/blog/how-memory-works-in-codex-cli/index.html): Codex CLI ships two memory layers (AGENTS.md + Memories). Here’s how each works, where they fall short, and how Mem0 fills the gaps (1,761 words, May 8, 2026)
- [How Memory works in Hermes Agent (and how to improve it)](/content/blog/how-memory-works-in-hermes-agent-and-how-to-improve-it.html): How Hermes Agent stores 3,575 characters of memory in two frozen markdown files, and where the design breaks. (1,790 words, May 8, 2026)
- [How to add Memory to Langchain Agents](/content/blog/how-to-add-memory-to-langchain-agents/index.html): Step-by-step guide to adding persistent, cross-session memory to LangChain agents using Mem0. (935 words, May 8, 2026)
- [How to add memory to LlamaIndex agents](/content/blog/how-to-add-memory-to-llamaindex-agents/index.html): Step-by-step guide to adding persistent, cross-session memory to LlamaIndex agents using Mem0. (878 words, May 8, 2026)
- [Introducing Memory Decay in Mem0](/content/blog/introducing-memory-decay-in-mem0/index.html): Memory Decay in Mem0 softly re-ranks search results by recent access, helping long-running agents prioritize current context while keeping old memories available. (1,023 words, May 8, 2026)
- [OpenClaw vs Hermes Agent Memory Comparison](/content/blog/openclaw-vs-hermes-agent-memory-comparison/index.html): A breakdown onto how Memory is handled in the OpenClaw and Hermes Agent Harness and their limitations. (1,850 words, May 8, 2026)
- [How to Reduce LLM Token Costs for AI Agent Memory | Mem0](/content/blog/6-techniques-to-cut-ai-agent-memory-cost-beyond-basic-retrieval.html): Learn the real difference between memory vs context window for LLM agents. Why most AI agents fail and how to use long-term memory to build stateful AI (1,160 words, May 7, 2026)
- [The 2026 Token Optimization Playbook: Cut AI Agent Memory Costs 3–4X ](/content/blog/the-2026-token-optimization-playbook-cut-ai-agent-memory-costs-3-e2-80-934x-2.html): Step-by-step playbook to reduce AI agent token costs by 3–4× using modern memory architectures. (2,472 words, May 6, 2026)
- [The 2026 Token Optimization Playbook: Cut AI Agent Memory Costs 3–4X ](/content/blog/the-2026-token-optimization-playbook-cut-ai-agent-memory-costs-3-e2-80-934x.html): Step-by-step playbook to reduce AI agent token costs by 3–4× using modern memory architectures. (2,493 words, May 6, 2026)
- [How to Test AI Agent Memory: 5 Simulation Runs with Mem0 ](/content/blog/how-to-test-ai-agent-memory-with-mem0-a-practical-memory-simulation-guide.html): Memory bugs hide in accumulated state, not unit tests. Here's how we ran 5 simulation experiments with Mem0 to catch drift, contradiction, and stale context. (1,242 words, May 2, 2026)
- [Proactive Memory in AI Agents: A Developer's Guide](/content/blog/proactive-memory-in-ai-agents-a-developer-s-guide/index.html): Most AI agents only retrieve memory when asked. This guide covers proactive memory — three patterns for surfacing relevant context before the user speaks with Mem0. (3,530 words, May 1, 2026)
- [Evaluating Claude Opus 4.7's Memory on Complex Multi-Step Tasks](/content/blog/evaluating-claude-opus-4-7-s-memory-on-complex-multi-step-tasks.html): Anthropic shipped Opus 4.7 with specific claims about long-horizon reasoning and self-verification. I built a reproducible experiment to test one question most people aren't asking: does the model actually remember what it said in step 1 when it gets to step 5? (2,735 words, Apr 28, 2026)
- [Your AI Agent's Memory Is Just a File? That's the Problem](/content/blog/your-ai-agents-memory-is-just-a-file-thats-the-problem.html): Why filesystem-based memory works at first, breaks at scale, and what two years of building AI memory infrastructure with 23M installs taught me. (4,781 words, Apr 28, 2026)
- [Kimi K2.6 Memory Requirements, Hardware Specs, and What the Traces Reveal](/content/blog/reading-the-traces-what-two-charts-tell-us-about-kimi-k2-6-e2-80-99s-memory-2.html): Kimi K2.6 needs 350GB+ RAM for the Q2 quant, 8× H100s for full quality. Here's every hardware config and what 12 hours of execution traces reveal about how its memory system actually works. (3,699 words, Apr 23, 2026)
- [Kimi K2.6 Memory Requirements, Hardware Specs, and What the Traces Reveal](/content/blog/reading-the-traces-what-two-charts-tell-us-about-kimi-k2-6-e2-80-99s-memory.html): Kimi K2.6 needs 350GB+ RAM for the Q2 quant, 8× H100s for full quality. Here's every hardware config and what 12 hours of execution traces reveal about how its memory system actually works. (3,435 words, Apr 23, 2026)
- [OpenAI API Pricing Breakdown With Claude And Gemini LLMs](/content/blog/llm-api-cost-breakdown-claude-gemini-openai-compared.html): OpenAI API pricing is analyzed alongside Claude and Gemini in this guide. Find out how Claude API cost compares to help teams be cost efficient & pick the right LLM (1,875 words, Apr 20, 2026)
- [Multi Agent System Memory Guide With Multica Explained](/content/blog/how-memory-works-in-a-multi-agent-system-inside-multica.html): Multica is a multi-agent system built on shared memory layers for agents. Discover multi-agent ai frameworks through shared context in llm-based applications (1,220 words, Apr 19, 2026)
- [Add Memory to OpenClaw: The Complete Mem0 Integration Guide (2026)](/content/blog/add-persistent-memory-openclaw/index.html): Step-by-step guide to integrating Mem0 memory into the OpenClaw AI assistant. Code examples, configuration, and multi-session memory setup. (2,043 words, Apr 17, 2026)
- [Openclaw Memory: How Live Data Compaction Works in AI](/content/blog/openclaw-memory-management-live-data-compaction-and-best-practices.html): Openclaw memory gives AI agents a structured approach to live data compaction. Apply openclaw best practices to keep agent memory lean and performant (2,663 words, Apr 17, 2026)
- [OpenClaw Memory System: How It Works and How to Set It Up](/content/blog/openclaw-memory-system-how-it-works-and-how-to-set-it-up.html): A technical breakdown of how OpenClaw's memory system works - file architecture, indexing, compaction, plugin slots and how to set up persistent memory. (2,108 words, Apr 17, 2026)
- [Introducing The Token-Efficient Memory Algorithm](/content/blog/mem0-the-token-efficient-memory-algorithm/index.html): Mem0's new token-efficient memory algorithm hits 92.5 on LoCoMo, 94.4 on LongMemEval, and 64.1/48.6 on BEAM (1M/10M) while averaging under 7,000 tokens per retrieval call. Full-context approaches on the same benchmarks use 25,000+. High accuracy at 3-4x lower token cost. (1,675 words, Apr 16, 2026)
- [Adding Persistent Memory to Local AI Agents with Mem0, OpenClaw, and Ollama](/content/blog/adding-persistent-memory-to-local-ai-agents-with-mem0-openclaw-and-ollama.html): Build a fully local AI coding assistant with persistent memory using OpenClaw, Ollama, and Mem0 OSS with no API keys, no cloud, no data leaving your machine. Learn how to wire Mem0 with Qdrant for semantic memory that survives restarts, add a smart memory filter that stores only what matters, and generate code shaped by your preferences across every session. (2,516 words, Apr 9, 2026)
- [Mem0 CLI - Agent-First Memory from Your Terminal](/content/blog/mem0-cli-agent-first-memory-from-your-terminal/index.html): Give your AI agents persistent memory with Mem0 CLI. Add, search, and manage user and agent preferences directly from the terminal. (325 words, Apr 9, 2026)
- [AI Memory Management for LLMs and Agents](/content/blog/ai-memory-management-for-llms-and-agents/index.html): How memory management actually works in LLM-powered agents: architectures, pipelines, scoping, and the benchmarks that reveal what performs in production. (2,771 words, Apr 8, 2026)
- [Context Window vs Persistent Memory: Why 1M Tokens Isn't Enough](/content/blog/context-window-vs-persistent-memory-why-1m-tokens-isn-t-enough.html): A 1M context window sounds like a lot. Here's why persistent memory beats context-stuffing for production AI agents in the real world. (2,321 words, Apr 8, 2026)
- [Hermes AI Agent: How to Add Memory to Your Workflow](/content/blog/how-to-add-memory-to-your-hermes-agent/index.html): This complete guide shows how to add memory to your hermes ai agent using Mem0. Read about hermes agent memory to improve how AI recalls and stores context (679 words, Apr 6, 2026)
- [How Memory Works in Claude Code](/content/blog/how-memory-works-in-claude-code/index.html): Claude Code stores memories as plain markdown files with a 200-line index cap and when you hit line 201, it silently forgets. No error. No warning. Just gone. Here's exactly what's in the source code, how the failure mode works, and how to replace the default layer with semantic memory that doesn't have a ceiling. In Context : mem0's blog series on AI agent memory and context engineering. (1,103 words, Apr 5, 2026)
- [Memory Hierarchy in AI Systems: From Sensory to Semantic](/content/blog/memory-hierarchy-in-ai-systems-from-sensory-to-semantic.html): Context window is not memory. The memory hierarchy explains why agents forgets and what a properly layered system looks like from sensory input to persistent semantic knowledge.  (2,289 words, Apr 4, 2026)
- [The Modal Model of Memory: What AI Agents Can Learn From Cognitive Science](/content/blog/the-modal-model-of-memory-what-ai-agents-can-learn-from-cognitive-science.html): Sixty years of cognitive science has mapped how memory works. Here's what AI agent builders can take directly from that research. (2,264 words, Apr 4, 2026)
- [Hyperagents: How Memory Works in Self Improving AI](/content/blog/how-memory-works-in-hyperagents/index.html):  Hyperagents are AI systems that use memory to continuously improve their behaviors. Explore hyperagents ai memory to see how self improving ai agents evolve (1,292 words, Apr 3, 2026)
- [Beam Memory Benchmark: Key Findings on 1M Context](/content/blog/what-is-beam-memory-benchmark-the-paper-that-shows-1m-context-window-isnt-enough.html): The beam memory benchmark shows where 1M context windows fail LLM agents. Explore AI memory benchmark findings revealing where AI recall falls short (1,314 words, Apr 2, 2026)
- [How Memory Works in DeerFlow?](/content/blog/how-memory-works-in-deerflow/index.html): In Context - mem0’s blog series on context engineering. Most agents replay chats. DeerFlow builds memory instead—extracting facts and injecting only what matters into each prompt. (1,590 words, Apr 1, 2026)
- [AI Agent Memory 2026: Progress Benchmark Report Evaluations](/content/blog/state-of-ai-agent-memory-2026/index.html): Explore AI agent memory trends shaping intelligent systems in 2026. This guide covers agentic AI memory and agent memory using the latest AI agent benchmark evaluations (1,012 words, Apr 1, 2026)
- [What Is Agentic RAG?  How It Works and When to Use It](/content/blog/what-is-agentic-rag/index.html): Agentic RAG adds autonomous AI agents to traditional RAG pipelines, enabling multi-step planning, validation, and tool use. Learn how it works, when to use it, and what tradeoffs to expect in production.
 (2,807 words, Mar 10, 2026)
- [Google ADK Memory: How to Add Persistent Memory to Google ADK with Mem0](/content/blog/persistent-memory-google-adk-agents/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (2,386 words, Mar 9, 2026)
- [Grok API Pricing: Every Model, Token Cost, and How to Spend Less](/content/blog/xai-grok-api-pricing/index.html): Grok API pricing for every model and plan, plus the hidden token cost driver AI overviews miss: repeated context in production agents. (2,545 words, Mar 5, 2026)
- [How to Fix CrewAI Memory in Production with Mem0](/content/blog/crewai-memory-production-setup-with-mem0/index.html): CrewAI's built-in memory loses data on redeploy and leaks context between users. Learn how to swap in Mem0 and get persistent, user-scoped memory in 15 minutes. (2,752 words, Mar 4, 2026)
- [How to Design Multi-Agent Memory Systems for Production](/content/blog/multi-agent-memory-systems/index.html): Multi-agent AI systems fail not because agents can't communicate, but because they lack shared memory. Learn the three memory architecture patterns that work in production and how to design them before writing your first agent. (3,288 words, Mar 3, 2026)
- [How to Configure AI Agent Memory in Dify: A Complete Guide](/content/blog/dify-agent-memory-configuration-guide/index.html): Learn how to configure Dify agent memory step-by-step: from enabling TokenBufferMemory and setting window sizes to using Conversation Variables and the Mem0 plugin for persistent, cross-session memory. (1,821 words, Mar 2, 2026)
- [Short-Term Memory for AI Agents: What, Why, and How?](/content/blog/short-term-memory-for-ai-agents/index.html): Learn how short-term memory for AI agents enables session-level context retention in LLM systems. Explore implementation patterns, token management strategies, frameworks like LangGraph and Redis, and best practices to build scalable, reliable agents (2,257 words, Feb 26, 2026)
- [RAG vs. Memory: What AI Agent Developers Need to Know](/content/blog/rag-vs-ai-memory/index.html): Understand the difference between RAG vs AI memory for AI agents. Learn when one type of memory works best, and how Mem0 adds long-term memory for production-ready AI assistants. (2,476 words, Feb 25, 2026)
- [Reducing Hallucinations in LLMs with Grounded Memory](/content/blog/reducing-hallucinations-llms-with-grounded-memory/index.html): Learn how grounded memory and RAG architectures reduce LLM hallucinations by 95%+. Explore retrieval systems, verification loops, and Mem0's stateful approach. (2,818 words, Feb 24, 2026)
- [Self-Hosting Mem0: A Complete Docker Deployment Guide](/content/blog/self-host-mem0-docker/index.html): Self-host Mem0’s AI memory stack in three Docker containers (API, Postgres + pgvector, Neo4j) to keep conversation data on your own infrastructure, swap in local LLMs, and stay compliant. (2,720 words, Feb 23, 2026)
- [Long-Term Memory for AI Agents: The What, Why and How](/content/blog/long-term-memory-ai-agents/index.html): Explore AI agent long-term memory design for persistent memory AI agents. Learn how vector embeddings, graph memory, and consolidation enable cross-session memory and scalable retrieval. (1,872 words, Feb 21, 2026)
- [Memory for Voice Agents: A Practical Architecture Guide](/content/blog/ai-memory-for-voice-agents/index.html): Build persistent memory for voice agents with this practical architecture guide on retrieval, storage, and key trade-offs like per-round writes vs. sessions. Covers latency fixes, long-session handling, and Mem0 integration for production-ready voice AI tutors, therapy bots, and assistants. (2,408 words, Feb 20, 2026)
- [AI Memory Security: Best Practices and Implementation](/content/blog/ai-memory-security-best-practices/index.html): Discover how to defend AI agents against memory poisoning attacks like MINJA and AgentPoison. Learn best practices for secure persistent memory, isolation, and Mem0 implementation (2,962 words, Feb 11, 2026)
- [Short-Term vs Long-Term AI Memory: Engineer's Guide (2026)](/content/blog/short-term-vs-long-term-memory-in-ai/index.html): Compare short-term vs long-term memory in AI: architecture patterns, retrieval benchmarks, hybrid designs, and production pitfalls for ML engineers. (1,934 words, Feb 9, 2026)
- [Add Persistent Memory to Claude Code with Mem0 (5-Minute Setup)](/content/blog/claude-code-memory/index.html): Learn to add memory to Claude Code with Mem0 MCP in under 5 minutes. Reduce token usage by 90%, speed up workflows, and keep your AI context-aware across sessions. (759 words, Feb 7, 2026)
- [We Built Persistent Memory for OpenClaw (FKA Moltbot, ClawdBot) AI Agents](/content/blog/mem0-memory-for-openclaw/index.html): OpenClaw memory makes its AI agents extremely powerful. The Mem0 plugin gives your AI agent persistent memory with auto-recall and auto-capture. Setup in less than 30-seconds (1,091 words, Feb 6, 2026)
- [How to Build Context-Aware Chatbots with Memory using Mem0](/content/blog/context-aware-chatbots-with-ai-memory/index.html): Build context-aware AI chatbots with persistent memory using Mem0. Learn to implement production-ready conversation history, handle user preference updates, and solve the stateless LLM problem with practical code examples. (2,178 words, Feb 5, 2026)
- [The Architecture of Remembrance: Architectures, Vector Stores, and GraphRAG](/content/blog/what-is-ai-agent-memory/index.html): AI agent memory allows LLMs to retain and retrieve context across sessions. Learn how agent memory architectures work — from vector stores to GraphRAG — and how to implement them with Mem0. (2,034 words, Jan 26, 2026)
- [Building Memory-First AI Reminder Agents with Mem0 and Claude Agent SDK](/content/blog/building-a-reminder-agent-that-actually-remembers/index.html): Build reliable AI agents with Mem0's memory layer and Claude SDK. Separate databases from personalization memory for long-lived assistants that learn without drifting. (2,723 words, Jan 23, 2026)
- [Graph-Based Memory Solutions for AI Context: Top 5 Compared (January 2026)](/content/blog/graph-memory-solutions-ai-agents/index.html): Compare 5 graph-based memory solutions for AI agents in January 2026. Learn how graph memory tracks entity relationships vs vector search for better AI context. (2,360 words, Jan 20, 2026)
- [The AI Memory Layer: What It Is, How It Works and Why Agents Need It (2026)](/content/blog/ai-memory-layer-guide/index.html): The AI memory layer gives LLMs and autonomous agents persistent context across sessions. Learn how it works, when to use it, and how Mem0 compares to RAG and context windows. (2,520 words, Dec 31, 2025)
- [Agentic AI Framework Guide For Building AI Agents](/content/blog/agentic-frameworks-ai-agents/index.html): An agentic ai framework guides teams in building and running smart AI agents. Explore agentic framework options and ai agent orchestration for your next project (2,397 words, Dec 30, 2025)
- [Building Enterprise Knowledge Graphs with MCP (December 2025 Update)](/content/blog/mcp-knowledge-graph-memory-enterprise-ai/index.html): Learn how MCP transforms AI memory with knowledge graphs. Build enterprise-grade systems that understand relationships, not just facts. December 2025 guide. (2,004 words, Dec 30, 2025)
- [LangGraph Studio: Complete Guide To Debugging Visual AI Agents](/content/blog/visual-ai-agent-debugging-langgraph-studio/index.html): LangGraph studio walks you through debugging AI agents step by step visually. Use LangGraph memory tracing to fix errors and track agent context flows (1,780 words, Dec 29, 2025)
- [Context Engineering AI: How To Build Smarter LLM Agents In 2026](/content/blog/context-engineering-ai-agents-guide/index.html): Context engineering AI helps teams build smarter agents in 2026. Learn what is context engineering and apply context engineering for AI agents with LLM best practices (2,246 words, Dec 23, 2025)
- [Smolagents vs Other AI Agent Frameworks: What's New in December 2025](/content/blog/smolagents-vs-langchain-autogen-comparison/index.html): Comparing LangChain, AutoGen, and CrewAI in December 2025: Learn which AI agent framework fits your project, with performance insights. (1,461 words, Dec 11, 2025)
- [Build persistent memory for agentic AI applications with Mem0 Open Source, Amazon ElastiCache for Valkey, and Amazon Neptune Analytics](/content/blog/build-persistent-memory-for-agentic-ai-applications-with-mem0-open-source-amazon-elasticache-for-valkey-and-amazon-neptune-analytics.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (2,044 words, Nov 26, 2025)
- [Agentic RAG vs Traditional RAG: Complete Guide ](/content/blog/agentic-rag-vs-traditional-rag-guide/index.html): Learn how agentic RAG systems with intelligent memory outperform traditional RAG by 26% accuracy and 90% fewer tokens. Complete implementation guide for December 2025. (1,522 words, Nov 15, 2025)
- [OpenAI Agent SDK Features, Tools and Developer Insights](/content/blog/openai-agents-sdk-review/index.html): This openai agent sdk review breaks down every key feature for building AI agents. Read about openai agents sdk memory to improve how AI agents retain context (1,528 words, Nov 2, 2025)
- [CrewAI Multi-Agent AI Teams: Complete Guide with Memory](/content/blog/crewai-guide-multi-agent-ai-teams/index.html): Learn how to build multi-agent AI teams with CrewAI and add persistent memory with Mem0. Step-by-step guide with code examples. (1,553 words, Oct 31, 2025)
- [AgentStack: Build AI Automation at Scale (October 2025)](/content/blog/agentstack-tutorial-build-ai-agents-fast/index.html): Learn how AgentStack scaffolds AI agent projects with CrewAI, LangGraph, and OpenAI Swarms in minutes. Add persistent memory with Mem0 for production-ready agents in October 2025. (1,621 words, Oct 30, 2025)
- [LLM Summarization Techniques For Managing Chat History 2026](/content/blog/llm-chat-history-summarization-guide-2025/index.html): LLM summarization techniques enable compression of long chat history token loads. Apply LLM context management to keep AI context accurate and cost efficient (1,853 words, Oct 6, 2025)
- [Introducing the OpenMemory Chrome Extension](/content/blog/introducing-the-openmemory-chrome-extension/index.html): AI memory Chrome extension for LLM memory and retrieval augmented generation. OpenMemory enables persistent AI agent memory across web browsing sessions. (675 words, Jun 23, 2025)
- [How OpenNote Scaled Personalized Visual Learning with Mem0 While Reducing Token Costs by 40%](/content/blog/how-opennote-scaled-personalized-visual-learning-with-mem0-while-reducing-token-costs-by-40.html): AI memory and LLM memory solution helped OpenNote reduce token costs by 40% while scaling personalized learning. See how Mem0 AI assistant memory works. (670 words, May 21, 2025)
- [How RevisionDojo Enhanced Personalized Learning with Mem0](/content/blog/how-revisiondojo-enhanced-personalized-learning-with-mem0.html): AI memory platform Mem0 helped RevisionDojo reduce token costs 40% while enhancing personalized learning through persistent LLM memory and context retention. (546 words, May 20, 2025)
- [AWS and Mem0 Partner to Bring Persistent Memory to Next-Gen AI Agents with Strands](/content/blog/aws-and-mem0-partner-to-bring-persistent-memory-to-next-gen-ai-agents-with-strands.html): AI memory partnership between AWS and Mem0 brings persistent memory to Strands agents. LLM memory integration for personalized AI agent experiences. (657 words, May 19, 2025)
- [How Sunflower Scaled AI Support to 80K Users with Mem0 Memory](/content/blog/how-sunflower-scaled-personalized-recovery-support-to-80-000-users-with-mem0.html): See how Sunflower used Mem0 to give personalized AI memory to 80,000 recovery support users. Architecture, results, and implementation guide. (519 words, May 16, 2025)
- [How to make your clients more context-aware with OpenMemory MCP](/content/blog/how-to-make-your-clients-more-context-aware-with-openmemory-mcp.html): AI memory layer OpenMemory MCP enables persistent context for LLM clients like Cursor, Claude Desktop. Local-first memory AI with vector storage and control. (1,139 words, May 13, 2025)
- [Introducing OpenMemory MCP](/content/blog/introducing-openmemory-mcp/index.html): OpenMemory MCP adds persistent, user-owned memory to Claude, Cursor, and any MCP-compatible client. Self-hostable. Free to get started. Install in under 5 minutes. (720 words, May 13, 2025)
- [Benchmarked OpenAI Memory vs LangMem vs MemGPT vs Mem0 for Long-Term Memory - Here’s How They Stacked Up](/content/blog/benchmarked-openai-memory-vs-langmem-vs-memgpt-vs-mem0-for-long-term-memory-here-s-how-they-stacked-up.html): AI memory benchmark comparing Mem0, OpenAI Memory, LangMem, and MemGPT for LLM long-term memory. Mem0’s leads with a 92.5 LoCoMo score. (1,197 words, Apr 29, 2025)
- [Why Stateless Agents Fail at Personalization](/content/blog/why-stateless-agents-fail-at-personalization/index.html): AI memory and LLM memory are crucial for personalization. Learn why stateless AI agents fail without persistent memory and how memory AI transforms agent performance. (1,376 words, Apr 25, 2025)
- [Memory in Agents: What, Why and How](/content/blog/memory-in-agents-what-why-and-how/index.html): LLM memory gives language models persistent context across sessions. Learn how it works, how it differs from RAG and context windows, and how to add LLM memory to your agents with Mem0. (1,296 words, Apr 15, 2025)
- [How Memory Shapes Us: A Deep Dive into the Types of Memory](/content/blog/how-memory-shapes-us-a-deep-dive-into-the-types-of-memory.html): AI memory and LLM memory systems mirror human memory types. Explore sensory, short-term, and long-term memory patterns that shape AI agent intelligence. (1,129 words, Feb 26, 2025)
- [Improving User Experiences with Memory Export](/content/blog/improving-user-experiences-with-memory-export/index.html): AI memory export enables LLM data analysis, machine learning model training, and seamless data migration. Learn implementation with Mem0's memory export feature. (812 words, Jan 16, 2025)
- [Understanding Custom Categories in Mem0](/content/blog/understanding-custom-categories-in-mem0/index.html): Learn how to implement custom categories in Mem0 AI memory platform for LLMs. Organize AI agent memory efficiently with specialized categorization. (518 words, Oct 25, 2024)
- [Customizing Memory in Mem0](/content/blog/customizing-memory-in-mem0/index.html): AI memory customization in Mem0 lets you control what your LLM remembers. Fine-tune memory storage with inclusion/exclusion for better RAG performance. (608 words, Oct 21, 2024)
- [Searching Memories with Mem0 search() Operation](/content/blog/searching-memories-with-mem0-search-operation/index.html): AI memory retrieval with Mem0 search() operation. Learn basic queries, advanced filtering, and output formats for LLM memory and AI agent memory. (880 words, Oct 16, 2024)
- [Understanding Mem0's add() Operation](/content/blog/understanding-mem0-s-add-operation/index.html): Learn Mem0's add() operation for AI memory management. Store long-term and session-based memories for LLMs, AI agents, and memory-enhanced applications. (616 words, Oct 12, 2024)
- [Add Mem0’s Powerful Memory in just Four Lines of Code](/content/blog/add-mem0-s-powerful-memory-in-just-four-lines-of-code.html): AI memory and LLM memory made simple with Mem0. Add powerful AI agent memory to your applications in just four lines of code with easy setup. (576 words, Oct 8, 2024)
- [Making AI Companions Truly Personal](/content/blog/making-ai-companions-truly-personal/index.html): AI memory and LLM memory solutions for building personal AI companions. Learn how Mem0 enables AI agent memory to create truly personalized experiences. (386 words, Oct 1, 2024)
- [How to Add Long-Term Memory to AI Companions: A Step-by-Step Guide](/content/blog/how-to-add-long-term-memory-to-ai-companions-a-step-by-step-guide.html): Learn how to add AI memory and long-term memory to AI companions using Mem0. Complete guide with code examples for building memory-enabled AI agents. (1,608 words, Sep 30, 2024)
- [Introducing Mem0](/content/blog/introducing-mem0/index.html): Mem0 AI memory layer enables personalized LLM applications with long-term memory for user preferences, traits, and histories. Open-source memory AI solution. (725 words, Sep 9, 2024)

## Listings & Categories

- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/engineering-team/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (150 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/deshraj-yadav/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (122 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/livia-ellen/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (109 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/himanshu-sangshetti/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (110 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/aashi-dutt/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (117 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/taranjeet-singh/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (225 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/ozan-eken/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (39 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/swarnaprakash-udayakumar/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (39 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/spruce-emmanuel/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (16 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/david-castro/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (39 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/agam-pandey/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (31 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/fimber-elemuwa/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (51 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/bex-tuychiev/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (42 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/marvel-ken/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (31 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/waricha-muensit/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (15 words)
- [Mem0 - AI Memory Layer for your Agents & Apps | Persistent Context](/content/author/paurush-mittal/index.html): Mem0 enables AI agents & apps to continuously learn from past user interactions, enhancing their intelligence and personalization. (16 words)

## Resources

- [Full Page Index](/index.html): Browse all cached pages with rich metadata
- [About This Cache](/content/about.html): Methodology, technical details, and usage guidelines
- [XML Sitemap](/sitemap.xml): Machine-readable sitemap for crawler discovery
- [Robots.txt](/robots.txt): Crawler directives