> ## Documentation Index > Fetch the complete documentation index at: https://docs.remem.online/llms.txt > Use this file to discover all available pages before exploring further. # Remem: Persistent Memory for AI Agents and Chatbots > Remem is a memory API for AI agents using hybrid scoring — blending semantic relevance, recency, and importance — to surface the most useful memories. AI agents are powerful, but they suffer from a fundamental flaw: every new conversation starts from zero. Remem gives your agent a persistent memory layer so it can remember what users tell it, retrieve the right information at the right time, and deliver genuinely personalised responses — without you building any of the underlying infrastructure. ## What Is Remem? Remem is a memory API built specifically for AI agents. You call one method to store what your agent learns about a user. You call another to retrieve it later. Remem handles the embedding, deduplication, storage, and hybrid-ranked retrieval so you can focus on your product instead of your memory pipeline. At its core, Remem exposes three operations: * **`remember()`** — store a new memory for a user * **`context()`** — load the most relevant memories at the start of a session * **`recall()`** — search memories semantically based on a query ## The Problem Remem Solves Every time a user starts a new conversation with your AI agent, it begins completely fresh. It does not remember: * The user's name, location, or background * What they asked about or complained about last week * Their communication style and preferences * Anything they have ever shared with it before The usual workarounds make things worse, not better. Stuffing conversation history into the system prompt hits token limits fast, and re-asking users for information they already provided damages trust and degrades the experience. **Remem fixes that** by giving your agent a durable, searchable memory store that persists across every session. ## How It Works When your agent learns something meaningful about a user — a preference, a fact, a piece of context — call `remember()`. Remem embeds the text using a language model, checks for near-duplicate memories, and persists it to your account. You can attach an importance score from `0.0` to `1.0` to control how prominently the memory surfaces in future retrievals. At the start of every conversation, call `context()` before the user says a word. Remem returns the most important and most recent memories for that user, giving your agent a head start. It already knows who the user is and what matters to them. When the user asks something specific mid-conversation, call `recall()`. Remem ranks results using its hybrid scoring formula — weighting semantic relevance, recency, and importance together — and returns the memories most likely to be useful right now. ## Why Remem Is Different Most memory solutions return the most *similar* memory. Remem returns the most *useful* one. The difference is hybrid scoring — a transparent formula that combines three signals into a single ranked result. ``` final score = 70% semantic relevance + 20% recency ← newer memories rank higher + 10% importance ← you control what matters most ``` Every search result includes a `score_detail` breakdown showing exactly how each signal contributed to the final rank. There is no black box — you can see precisely why your agent surfaced a particular memory. The largest weight measures how closely the stored memory matches your query **in meaning**, not just in overlapping words. Ask `"where does this user live?"` and Remem finds `"User is based in Lagos, Nigeria"` even though none of the words match. That is vector similarity working on embedded representations of meaning, not keyword matching. Newer memories score higher than older ones. A preference stored yesterday outranks an identical preference stored six months ago. This prevents stale data from dominating retrieval as your memory store grows. Facts naturally fade over time; fresh context naturally rises. When you call `remember()`, you pass an `importance` value between `0.0` and `1.0`. High-importance memories receive a consistent boost on every search. Use this for stable, high-signal facts — the user's name, their plan type, a critical constraint — that you always want your agent to surface. ## How Remem Compares | | Remem | mem0 / LangMem | Building yourself | | ------------------- | -------------------------------- | ---------------------- | ------------------------- | | Retrieval method | Hybrid scoring | Pure vector similarity | Depends on implementation | | Score transparency | ✅ `score_detail` on every result | ❌ Black box | Depends | | Duplicate detection | ✅ Built in | Partial | You build it | | Framework agnostic | ✅ Any LLM or agent framework | Partial | ✅ | | Setup time | 5 minutes | 15–30 minutes | 2–3 days | | Ongoing maintenance | None — fully managed | Minimal | Ongoing | ## Get Started Store your first memory and build a working agent in under 5 minutes Full documentation for the store endpoint One command: `pip install remem-py` Add persistent memory to a LangGraph agent