Skip to main content
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

1

Store

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.
2

Retrieve Context

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.
3

Search

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.
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

​
Get Started

Quick Start

Store your first memory and build a working agent in under 5 minutes

Store API Reference

Full documentation for the store endpoint

Install the SDK

One command: pip install remem-py

LangGraph Guide

Add persistent memory to a LangGraph agent