Mem0

Building AI agents that actually learn from you, instead of just reacting 🧠 Just added a brand new tutorial about Mem0 to my "Agents Towards Production" repo. It addresses the "amnesia" problem in AI, which is the limitation where agents lose valuable context the moment a session ends. While many developers use standard chat history or basic RAG, Mem0 offers a specific approach by creating a self-improving memory layer. It extracts insights, resolves conflicting information, and evolves as you interact with it. The tutorial walks through building a Personal AI Research Assistant with a two-phase architecture: - Vector Memory Foundation: Focusing on storing semantic facts. It covers how the system handles knowledge extraction and conflict resolution, such as updating your preferences when they change. - Graph Enhancement: Mapping explicit relationships. This allows the agent to understand lineage, like how one research paper influenced another, rather than just finding similar text. A significant benefit of this approach is efficiency. Instead of stuffing the entire chat history into a context window, the system retrieves only the specific memories relevant to the current query. This helps maintain accuracy and manages token usage effectively. This foundation helps transform a generic chatbot into a personalized assistant that remembers your interests, research notes, and specific domain connections over time. Part of the collection of practical guides for building production-ready AI systems. Check out the full repo with 30+ tutorials and give it a ⭐ if you find it useful: https://lnkd.in/dkjGZGiw Direct link to the tutorial: https://lnkd.in/eWST26Js How are you handling long-term context? Are you relying on raw history, or are you implementing structured memory layers? ♻️ Repost to let your network learn about this too!

If your New Year resolution is real impact >>> fancy titles... We’re #hiring an Applied AI Engineer in SF at Mem0. The role is about taking real customer use cases and turning them into working AI systems, end-to-end. You’ll prototype fast, experiment with memory retrieval strategies, and work closely with Research and Backend to hand off ideas that actually ship. We are a small team, which means you’ll own large parts of the system. My DMs are open(or apply via the link)

Most AI agents today are still stateless. That’s why they don’t evolve over time. They answer a query, end the session, and forget everything that happened before. This type of interaction feels okay for one-time queries, but it doesn’t hold up when users come back and expect the agent to remember them. A stateless agent treats every interaction as a clean slate. If a user shares preferences today and comes back tomorrow, the agent has no idea. Context has to be rebuilt manually, again and again. A stateful agent works differently. It learns from interactions, stores what matters, and recalls it when needed. Instead of resetting state between sessions, prior context is carried forward and reused. Here’s a simple example👇 User says: “I prefer aisle seats. But for long flights, make it a window.” A stateless agent acknowledges this and forgets it but a stateful agent stores that preference. So when the user later says, “Book my flight to Berlin, it’s a long one,” the stateful agent books a window seat without asking again. That behavior doesn’t come from better prompts or larger models. It comes from having a real memory layer in the system that can persist context across sessions and surface it when it’s actually relevant. Mem0 focuses on this missing layer, making it easier for agents to store, retrieve, and update long-term context instead of rebuilding state every time a user comes back.

🚀New cookbook: Gemini 3 + Mem0 MCP We put together a step-by-step guide showing how to add Mem0’s persistent, structured memory to a Gemini 3 workflow using the Model Context Protocol. If you're building agents that need long-term recall, consistent context, and reliable memory across sessions, this one’s for you. 🔗Link: https://lnkd.in/gEqwhd6Z

We partnered with AWS to show how developers can build persistent memory built for real-world agent workloads. The tutorial combines three components to create a robust GitHub Research Agent: - Mem0 Open Source for long-term memory orchestration. - Amazon ElastiCache for Valkey for high-speed semantic recall - Amazon Neptune Analytics for graph-based reasoning With these pieces working in sync, the agent doesn’t just answer questions, it retains what it learns, avoids repeated tool calls, and builds a connected understanding of the codebase over time. Link to the full guide in comments

AI agents work best when their memory aligns with your application’s exact needs. When you’re building agents with memory, a few things matter: - Only relevant details should turn into long-term memory. - Sensitive information shouldn’t be captured. - And, the rules for what gets stored should stay consistent across your entire project. That’s exactly what Custom Instructions in Mem0 are designed for. You define your guidelines in plain language like what to extract, what to ignore, and how information should be handled and Mem0 applies those rules across your entire project without any extra setup. This gives you far more control over what gets stored, allowing the memory layer to adapt to your specific use case. Your agent ends up working with cleaner, more reliable context that aligns with the outcomes you expect.

Not every AI agent query needs the same type of memory. Some questions are about a single fact, others depend on how different facts connect and Mem0 gives you both a vector store and graph memory to handle this. A vector store works best when the answer lives in a single memory. It’s built for semantic search like skills, notes, descriptions, FAQs, and anything that can be matched by meaning. It’s fast, lightweight, and exactly what you want for most semantic lookups. Graph memory comes in when the question is relational. Agents often need to understand how people, tasks, or concepts are linked like who works with who, who reports to who, what depends on what, or how multiple pieces fit together. Graph memory extracts entities and relationships so the agent can follow that chain directly. Here’s the trade-off in simple terms: • vector store → cheaper + low latency • graph memory → deeper reasoning when structure matters And switching between the two in Mem0 is straightforward. When adding a memory, you can enable graph extraction with one flag: enable_graph=True You can use it per-call, or turn it on project-wide if most of your data has relationships. If you are just looking for semantic lookups, stick with the vector store but for anything involving connections, turn on graph memory. Mem0 lets you use both in the same project, depending on what each query actually needs.

Congratulations to Throwback, winners of the Mem0 Track at the Cursor Hackathon! They integrated Mem0 to power the memory feature, enabling it to recall past conversations between generations and make each new interaction richer and more personal. Throwback is a storytelling app that connects the young and elderly through relaxed, guided dialogues, preserving Singapore’s cultural and historical heritage in a digital format🇸🇬 Kudos to Claudia Wijaya, Emily Choi , Luke Chen and Zhenming Lin for bringing such a thoughtful idea to life. And special thanks to 🃏 Sherry Jiang & 🥃 Agrim Singh for hosting an incredible hackathon!🙌

We’re hiring a Data Analyst at Mem0🔥 And, it’s one of the most high-impact roles we’ve ever opened. We’ve built the memory layer for AI agents, now used across thousands of AI apps. But to scale, we need to understand what truly drives impact and that’s where you come in. As our first data hire, you’ll: - Build our analytics stack from 0→1 - Define metrics that matter across product and business - Turn raw data from Postgres, PostHog, and LLM outputs into insights that guide every decision You’ll work closely with Product, Engineering, and Leadership, owning everything from data pipelines to experimentation frameworks. 📍 Bangalore, India If you’ve been waiting for a role where you can build, not just analyze, this is it. 🔗 Link in comments

Our co-founder & CTO Deshraj Yadav, presented the Mem0 research paper this week at ECAI 2025 in Bologna🇮🇹 ECAI (European Conference on Artificial Intelligence) is Europe’s flagship AI research conference that brings together leading researchers and labs shaping the future of intelligent systems. The paper explores how Mem0 enables persistent, production-ready memory for AI, built to retain context across interactions, scale as memories grow, and adapt across use cases. The talk sparked thoughtful discussions around: - Multimodal memory support - How Mem0 compares with RAG-based approaches - Managing large and evolving memory graphs - What to store vs. forget, since memory is always task-specific Proud to have presented our work on the memory layer for AI and to see it spark meaningful discussions at one of the leading global AI research venues.

Excited to announce Mem0's $24M (Seed + Series A)🔥 Led by Basis Set, with participation from Peak XV Partners, Kindred Ventures, GitHub Fund, and Y Combinator. AI today can reason, code, and plan, yet forgets everything as soon as the session ends. That’s the bottleneck holding back truly intelligent systems. Mem0 fixes that. With just three lines of code, developers can give their agents long-term memory, enabling them to adapt, personalize, and improve over time. In just a year, Mem0 has become the memory layer for the AI ecosystem: - 41K+ GitHub stars - 14M+ downloads - 186M API calls in just Q3 Used in production by thousands of developers and companies We’re creating a new foundation for the agentic economy where intelligence doesn’t just think, but remembers, learns, and evolves across time and context. Grateful to our team, community, and investors for believing in this mission. Intelligence needs memory & we're building it for everyone.

What does it actually take to give an LLM memory? Avishek Biswas explored that question by recreating the architecture described in the Mem0 paper using DSPy, showing how extraction, indexing, retrieval, and updates come together inside an agentic memory system. The video distills these complex ideas into a clear, hands-on walkthrough and also demonstrating how the Mem0 API brings those concepts to life in real applications. It’s a great introduction to how memory systems work and why they become complex to build and maintain as they scale.

Made my first open source contribution. Added support for custom Hugging Face models Mem0. Looking forward for more such contributions.

Mem0 v1.0.0 is live 🚀 Bringing faster memory retrieval, new integrations, and major performance upgrades across SDKs. Here's what's new: - Assistant memory retrieval upgrade -Default async mode for better performance - Azure MySQL & Azure AI Search support - Tool Calls for LangChainLLM - Custom Hugging Face model support - New rerankers: Cohere, ZeroEntropy, Hugging Face - Improved Databricks, Milvus & Weaviate stability - Refreshed docs, examples & playground - OpenAI 2.x compatibility Big shoutout to all our new contributors joining the release🚀

The hardest part about giving AI agents memory? Making them understand time. Most agents know what happened but not when it happened or when it stopped being true. That’s why Mem0 makes time-awareness native with with two powerful features👇 1. Timestamp - Record when something actually occurred not when it was added. - keeps chronological order intact - supports backfilled or imported data - enables time-based reasoning & analytics 2. Expiration - Give your memories a shelf life. Once expired, they’re automatically ignored in retrievals. - prevents stale or irrelevant data - ensures cleaner, more context-aware responses With these, Mem0 helps your agents reason across time, not just across data.

Prompt Engineering vs Context Engineering Prompt engineering is the art of crafting precise instructions, shaping what you say and how you say it so the model produces the right output. It’s about optimizing the input text itself through roles, examples, and structure. A few years ago, the craft of prompt engineering dominated how we built with language models. And it worked, until we started building agents. Because prompts alone can’t manage state. Each turn adds new data like messages, tool outputs, retrieved docs and only a fraction fits into the model’s limited context window. So the question shifted from “What should I tell the model?” to “What configuration of information helps it reason best right now?” That’s where context engineering comes in. Context engineering is the discipline of designing the environment around the prompt, deciding what the model should remember, retrieve, or focus on at any moment. It optimizes the information flow, not just the words. It’s about managing the model’s attention budget which is indeed a finite resource. -Too little context and the model loses awareness. -Too much, and precision decays, a phenomenon known as context rot. Good context engineering curates the smallest, highest-signal set of tokens that drive useful behavior. It involves: - Keeping system prompts clear and structured. - Using tools to fetch data just-in-time. - Managing memory like what to persist, summarize, or forget. - Orchestrating retrieval and state to keep information relevant. This evolution makes LLMs more than responders. It makes them capable agents that think and adapt over time. That’s where Mem0 fits in - the memory layer inside this context pipeline, deciding what’s worth keeping, compacting, or recalling so your agents always operate with the right context. Because the future of AI isn’t about better prompts - it’s about smarter context. #AI #ContextEngineering #PromptEngineering

Implement long-term memory for AI agents 🧠 Learn how to architect persistent memory using Azure AI Foundry, Azure AI Search, and Mem0. This tutorial by Eitan Sela explains how Mem0 fits into the Azure ecosystem - managing what to remember, summarize, and forget. While AI Search handles retrieval and Foundry orchestrates the agent. 🔗Blog link in the comments. #mem0 #microsoft #aimemory

100 billion tokens through OpenAI 🔥 Each one shaping the memory layer that helps AI grow smarter over time.

Lovable Cloud & AI builds it. Mem0 makes it remember. Luuk Alleman just built a Dating Profile Optimizer using Lovable Cloud & AI + Mem0 - an AI coach that learns your preferences, refines your bio, and even helps you pick better photos over time. Lovable Cloud & AI handled the orchestration, 1 orchestrator + 4 specialist agents working together seamlessly. Mem0 added long-term memory, letting the agents remember your preferences, past feedback, and even your chat history to personalize future suggestions. 🔗 Link to the YouTube video in comments👇

We’re joining ZeroEntropy (YC W25) and Mastra to unpack what real Context Engineering looks like from rerankers to long-term memory. Join the discussion 👇

Context Engineering is powerful but limited without Memory. Everyone’s been talking about Context Engineering lately, optimizing how models perceive and reason through structured context. But no matter how well-designed your pipeline is, it all vanishes when the session ends. That’s why Memory is emerging as the missing layer in modern LLM architecture. What Context Engineering does: Each request compiles prompts, system instructions, and tool outputs into a single, token-bounded context window. It’s great for recall and reasoning but once the session resets, all that knowledge disappears. Where Memory fits in: Memory adds persistence. Instead of re-feeding information every time, it lets the system: - Store distilled facts and user preferences - Update outdated or conflicting data - Retrieve what’s relevant automatically later So instead of context on demand, you get continuity over time. Together, they make an agent feel less like autocomplete and more like a collaborator. And, this is exactly what we’re building at Mem0, a universal memory layer that lets AI agents retain and reuse knowledge across sessions. #AI #LLM #ContextEngineering #AIMemory

RAG (Retrieval Augmented Generation) vs. Memory These two terms are often confused, but they play very different roles. RAG grounds an LLM with external knowledge. A query is embedded, matched against a vector store, and the top k-chunks are injected into context. Memory is broader. It is a system that stores, processes, and later retrieves distilled knowledge that supports decisions. It is not long context or raw logs. It captures salient facts, preferences, learned inferences and keeps them available across sessions. Here are four ways they differ👇 1. Statefulness - • RAG resets every time unless you stuff history back into the prompt. • Memory persists, retaining distilled context across sessions so the agent can build on past interactions rather than starting fresh. 2. Adaptability - • RAG serves chunks as indexed. • Memory evolves what it knows. It consolidates overlapping entries, overwrites outdated items, prunes low value details, and maintains a single source of truth so recall stays consistent as reality changes. 3. Personalisation - • RAG treats queries uniformly. • Memory represents user specific facts and preferences, identity, and style, which lets agents answer in a way that feels tuned to the person, not just to the question of the moment. 4. Temporal awareness - • RAG does not natively reason over time, so old and new can coexist. • Memory tracks recency and applies update or delete operations to resolve contradictions and keep the freshest truth at hand. RAG is one tool inside memory, specifically the retrieval step. True memory is the intelligence layer that decides what to remember, what to forget, and when to recall. That’s what we’re building with Mem0, the universal memory layer for AI agents.

We’re excited to share that our Co-founder & CTO, Deshraj Yadav will be speaking at inaugural session of AgentX at the Google Sunnyvale campus. AgentX is a new builder-first series for those pushing the frontier of agentic AI. He’ll be joining leaders from Genspark and Google DeepMind to discuss how memory unlocks the next generation of AI agents. RSVP here → https://luma.com/fsvw23ll

Mem0 is now part of Microsoft’s AI Agents for Beginners course 🎉 If you want to dive deeper into agent memory and how it powers self-improving agents, this lesson is a great place to start. This lesson covers: → What AI Agent memory is and why it’s essential → Short-term & long-term memory in agents and how to manage them → A hands-on demo on how to build an intelligent travel booking agent that remembers your preferences using Mem0 + Semantic Kernel + Azure AI Search → How memory powers self-improving agents that learn over time 🔗 Link in the description

How Mem0 works under the hood 1. Message enters - A new user message triggers the pipeline. 2. Fetch context - Mem0 pulls two things from storage: i) A running summary of past exchanges ii) The last m raw messages This keeps history compact but still meaningful. 3. Extraction - The LLM reads: i) Current message ii) Last m messages iii) Summary From this, it extracts a set of salient memories → clean statements about facts, preferences, or events. ⭐️ Parallel Independent process - Alongside all this, an asynchronous summary generator runs in the background. It keeps the conversation summary fresh without slowing the main pipeline, so extraction always has the latest context. 4. Update Phase - Now, for every extracted memory, Mem0 asks: does this already exist, or does it conflict with something we know? To answer, it fetches the top-s most similar memories from the database. Why this step is crucial: a) It gives the LLM “nearby” context → what’s already known about this user/topic. b) Prevents duplication. c) Handles change over time. The candidate fact + retrieved neighbors are then passed to the LLM via a function-calling interface (“tool call”). The LLM then chooses one of four operations: ✅ Add → insert new info 🔄 Update → revise existing fact ❌ Delete → remove outdated/conflicting info ➖ Noop → ignore if not useful This ensures memory stays consistent, accurate, and evolving. 5. Store - Updated memories are saved (with metadata). At the next turn, the cycle repeats, pulling the summary + relevant memories again, keeping the agent consistent without bloating the prompt. This architecture gives agents memory that stays consistent across sessions, adapts as facts change, remains efficient with tokens and latency, and scales reliably at production load. 🔗Link to the Mem0 arXiv paper is in the comments.

AI Agent Memory isn’t just bigger context windows... It’s how agents actually learn, adapt, and evolve. Context windows only let a model see more of the conversation at once. Memory is different, it's what the agent keeps, updates, and recall the right parts to guide decisions. And just like human memory, AI Agent Memory isn’t one-dimensional. It comes in different types↓ 1. Short-term (Working Memory) - Think of it as the agent’s notepad. It keeps track of the last few exchanges or the task you’re working on right now. Without it, the agent would lose its train of thought mid-conversation. 2. Long-term Memory - This is where persistence comes in. Instead of starting fresh every time, the agent can carry knowledge across sessions. Over time, interactions build on each other rather than resetting. Inside long-term memory, there are three important kinds: i) Factual Memory - This is where the agent keeps reliable facts like your name, preferences, role, and tools. It also updates them as things change. This keeps the agent’s knowledge of “what’s true right now” up to date. ii) Episodic Memory - This is the record of experiences like what happened, when it happened, and what the outcome was. That timeline gives agents a sense of continuity so that they can refer back to past decisions instead of treating every session as brand new. iii) Semantic Memory - This is the layer where understanding lives. It organizes knowledge into concepts and relationships, so the agent can connect dots and generalize like seeing that a “slow database” and “high query latency” are related problems. Without these types of memory, agents will always feel shallow, reacting in the moment but never really learning. With Mem0, all of these memory types are supported out of the box so you can focus on building the agent, not reinventing memory.

AI feels broken without memory. Mem0 is the memory layer that helps agents remember, learn, and evolve across interactions. If you’ve ever wondered how Mem0 fits into your stack, here’s the breakdown ↓ 1. Managed Platform – Hosted Mem0 with instant setup and lightning-fast memory retrieval that scales with your workload. 2. Open Source Toolkit – A full toolkit (Python & JS SDKs) so devs can self-host, extend, and control the memory layer end-to-end. 3. OpenMemory MCP - A plug-and-play memory API built on Model Context Protocol for seamless agent integration. 4. On-Premise Solution - Deploy Mem0 in your own infrastructure to maintain compliance, privacy, and full control. 5. Chrome Extension - Capture context directly from the browser (tabs, docs, web conversations) and feed into your Mem0 memory store. Mem0 gives you memory, on your terms.

We crossed 40k GitHub stars⭐️