Remem is the only memory API that shows you the math behind every retrieval. Not a black box. Not magic. Infrastructure you can actually trust in production.
Works with LangGraph · AutoGen · CrewAI · Any framework
pip install remem · Free to start
from remem import RememClientclient = RememClient(api_key="remem_live_xxx")memories = client.recall("what does this user prefer?", user_id="u1")Your agent retrieves a memory. You don't know if it retrieved the right one. You don't know why it ranked first. You don't know if a stale preference from 6 months ago just beat a fresh one from yesterday.
With every other memory solution — mem0, Zep, LangMem, your own vector store — retrieval is a black box. Something comes back. You hope it's right.
Production agents can't run on hope.
You stuffed history into the system prompt
You hit the token limit. At 10,000 users that's $3,000/month in wasted tokens. And you still can't see which context actually influenced the response.
You built your own vector store
Old preferences outrank fresh ones. Stale facts win retrieval. You can't tell why without digging through cosine scores manually.
You're using mem0 or LangMem
The memory layer makes decisions for you. Auto-extraction stores things you didn't intend. When retrieval goes wrong, there's no score breakdown. Just a wrong answer.
Your agent keeps giving outdated responses
Two conflicting memories. No way to know which one won retrieval. No way to debug it without rebuilding the whole query.
These aren't edge cases. They're what happens to every AI agent developer at scale. Remem was built specifically to solve them.
Every Remem search result returns score_detail — a breakdown of cosine similarity, recency score, and importance score. Debug retrieval in seconds, not hours.
No other memory API gives you this. You know what came back. You know why it ranked there. You can explain it to a compliance team, a customer, or yourself at 2am.
Transparency, control, sovereignty, and intelligence — the four things senior engineers need before they trust a memory layer in production.
Other memory APIs return results. Remem returns results and the reasoning. score_detail gives you cosine similarity, recency score, and importance score on every single retrieval. When your agent gives a wrong answer, you find the bad memory in seconds — not hours. No other memory API does this.
Auto-extraction sounds convenient until it stores something it shouldn't. Remem is explicit by design — you call remember(), you choose the content, you control the memory. No surprises in production. No unexplained behavior. Exactly what senior engineers want when building systems they have to trust.
Free and Pro plans: we handle everything. Enterprise BYOD: connect your own Supabase instance. Remem runs the engine, your database holds the data. SOC 2, GDPR, and HIPAA use cases handled. No data egress. No compliance risk.
Hybrid scoring combines semantic relevance (70%), recency decay (20%), and importance weighting (10%). A preference from yesterday beats an identical one from 6 months ago. Every time. The most similar memory is not always the most useful one. Remem knows the difference.
Each user's memories are completely separate. User A's memories never appear in User B's results.
When a fact changes, update() overwrites the old memory. No two conflicting memories sitting side by side.
If you don't update manually, newer memories naturally outrank older ones. Stale facts fade. Fresh facts win.
You store what matters. You retrieve what's relevant. You see exactly why it came back. That's the entire API.
When your agent learns something, store it. Remem embeds it, deduplicates it, and makes it retrievable forever.
POST /memories{ "content": "User prefers concise responses", "user_id": "user_123", "agent_id": "support_bot"}Session starts. Before the user says a word, load what your agent already knows. Inject into the system prompt. Agent is already personalized.
GET /memories/context ?user_id=user_123 &agent_id=support_botUser asks something. Search semantically. Hybrid scoring returns the most relevant, most recent, most important memory. Not just the most similar vector.
GET /memories/search ?query=what+does+this +user+preferThat's it. Three methods. Your agent has persistent, intelligent memory across every session.
pip install remem
from remem import RememClient
client = RememClient( api_key="remem_live_xxx", base_url="https://api.remem.online",)
# Store what your agent learnsclient.remember( "User prefers concise bullet points", user_id="user_123", agent_id="support_bot", memory_type="semantic", importance=0.8,)
# Load context at session startcontext = client.context( user_id="user_123", agent_id="support_bot",)
# Search when user asks somethingmemories = client.recall( query="what are this user's preferences?", user_id="user_123", agent_id="support_bot",)No bloat. No configuration. Every endpoint does exactly one thing and does it perfectly.
Most memory APIs require you to configure pipelines, choose embedding models, and tune retrieval parameters. Remem ships with production defaults — OpenAI embeddings, hybrid scoring, duplicate detection — all on by default.
We've already solved it. Here's what you'd spend building the same thing from scratch:
Total ~3 days · ~$2,400 + ongoing maintenance
5 minutes + $19/month
And that's before you hit the edge cases. Duplicate memories. Stale facts outranking fresh ones. Counts drifting out of sync after deletions. We've already solved all of it.
| Feature | Prompt stuffing | mem0 / LangMem | Remem |
|---|---|---|---|
| Score transparency | None | ❌ Black box | ✅ score_detail on every result |
| Storage control | Manual | Auto-extraction | ✅ Explicit — you decide |
| Retrieval engine | None | Semantic only | ✅ Hybrid (semantic + recency + importance) |
| Duplicate detection | None | Varies | ✅ 0.95 cosine threshold |
| Data sovereignty | N/A | Self-host required | ✅ BYOD Supabase — no infra needed |
| Framework lock-in | N/A | LangChain / varies | ✅ None — any framework |
| Time to integrate | Hours | 30–60 mins | ✅ 5 minutes |
Every plan includes everything — hybrid scoring, score_detail transparency, duplicate detection, TTL expiry, and BYOD on Enterprise. No features behind paywalls. Just higher limits.
Remem's free tier is designed for real integration, not toy demos. 500 memories is enough to build a working agent, ship it, and see if memory changes your product. When it does — and it will — upgrading takes one click and your memories carry over automatically.
Perfect for building and testing your agent. No credit card. No time limit. No catch.
For agents in production serving real users. 50,000 memories handles hundreds of users with thousands of interactions each.
For companies with data sovereignty requirements. BYOD means your data never touches our servers. GDPR. HIPAA. SOC2-ready architecture.
Not sure which plan? Start free. You'll know when you need Pro — your users will tell you by coming back.
These aren't made-up pain points. They're what developers post on Reddit at 2am when their agent breaks in production.
"Memory is becoming the real bottleneck for AI agents. If code used to be the bottleneck, memory might be the new one."
"Nobody talks about what AI memory looks like after six months in production. Old preferences keep winning retrieval, sarcastic comments get stored as literal truth."
Remem was built because we saw these posts and knew the infrastructure to fix them already existed. We just built the API layer on top of it.
mem0 auto-extracts memories and decides what to store. Remem doesn't — you decide. mem0's retrieval is a black box. Remem returns score_detail on every result so you see exactly why a memory ranked where it did. Different philosophy: mem0 is intelligent memory. Remem is controlled, auditable memory. If you need to explain your agent's behavior to a compliance team, Remem is the answer.
Every recall() response includes a breakdown of how each memory was scored — cosine similarity (semantic match), recency score (how fresh the memory is), and importance score (developer-assigned weight). You see the math behind every retrieval. When your agent retrieves the wrong memory, you find it immediately instead of guessing. No other memory API exposes this.
mem0 and LangMem make decisions about what to store — they extract memories from conversations automatically. Remem doesn't. You decide what gets stored. Remem's job is to store it reliably and retrieve the right thing at the right time. We're infrastructure, not intelligence. That boundary matters. Also: Remem shows you score_detail on every search result. No other memory API does that.
No. Remem handles pgvector, embeddings, indexing, and retrieval. You call an API. We do the rest.
Pure cosine similarity returns the most similar vector — not the most useful memory. A preference from 6 months ago can outscore an identical one from yesterday using pure similarity. Recency decay fixes that. Importance weighting lets you pin critical facts. Together they return what your agent actually needs.
Yes. Every search result includes score_detail — cosine, recency, importance, and final score. Most memory APIs are black boxes. Remem isn't.
Two ways. First, call update() when a fact changes — it overwrites the old memory in place, re-embeds the new content, same memory ID. No conflicts. Second, if you don't update manually, recency decay handles it — the newer memory scores higher and wins retrieval automatically.
The defaults work well for most agents: 70% semantic relevance, 20% recency, 10% importance. For knowledge base agents, cosine matters more. For support agents, recency matters more. Per-tenant weight configuration is on the roadmap.
Use a vector database to store memories as embeddings and retrieve them semantically. The best implementations combine similarity search with recency and importance scoring so the most relevant memories surface first — not just the most recent ones. Remem handles all of this out of the box.
Every piece of information the user shares gets stored as a vector embedding in a database. When a new conversation starts, the agent searches that database for context relevant to the current query and injects it before responding. The LLM never actually remembers — it just gets the right context at the right time.
You need a vector database — not Redis. Redis handles fast key-value lookups but can't do semantic search. For agent memory, you need something like pgvector or Pinecone that retrieves memories by meaning, not exact match. Or you skip the infrastructure entirely and use Remem's API.
Call an API. Setting up your own pgvector instance, writing the embedding pipeline, and tuning retrieval logic takes days. With Remem, it's `pip install remem-py`, initialize a client, and two tool calls — `remember()` and `recall()`. Most developers are up and running in under an hour.
Building it yourself: hosting a vector database, embedding API calls, and engineering time adds up fast. Using Remem: starts free, with paid plans based on memory volume. Check remem.online/pricing for current tiers.
No. Context window is temporary — it only exists for the duration of one API call and disappears when it ends. Agent memory is persistent storage outside the model that gets retrieved and injected into future context windows. One is RAM, the other is a hard drive.
That depends on how you build it. Remem uses a hybrid scoring system: semantic relevance (70%), recency decay (20%), and an importance weight you assign at write time (10%). High-importance memories stay relevant longer. Low-scored ones fade without needing manual cleanup.
Yes — as long as they query the same `user_id` namespace. In a multi-agent LangGraph system, a research agent, a writing agent, and a coding agent can all read from and write to the same memory store. They share context without duplicating storage or syncing state manually.
Free and Pro plans: stored on our Supabase instance, isolated by your tenant ID. No other tenant can access your data. Enterprise BYOD: your Supabase instance, we run the engine. Your data never leaves your servers.
OpenAI text-embedding-3-small — 1536 dimensions, 99.9% uptime SLA, production-grade reliability. Not a free tier model with no uptime guarantee.
Yes. Any framework that can make an HTTP request works with Remem. We have a Python SDK (pip install remem-py) and a full REST API. Framework agnostic by design.
You get a clear 402 error: "Memory limit reached — upgrade to store more." No silent failures. No data loss. Upgrade and the new limit applies immediately.
One API key. Hybrid scoring. Full score transparency. Your data stays where you put it.
Free forever on the starter plan. No credit card. Your first memory stored in under 5 minutes.
Engineering notes on agent memory, retrieval scoring and shipping memory in production.