inference + recall, one API

Your agent
remembers at
query time.

Drop-in recall layer for AI agents. Store what happened, retrieve only what the next step needs — no re-stuffing the whole history into context.

Start building Read the quickstart
quickstart.py 
from inra import Memory

mem = Memory(api_key="inra_...")

# remember an interaction
mem.add(
    agent="support-bot",
    user="u_123",
    text="prefers email over phone",
)

# recall only what this step needs
ctx = mem.recall(
    agent="support-bot",
    user="u_123",
    query="how should I reach them?",
)
print(ctx)  # → ["prefers email over phone"]
<40ms
p50 recall latency*
3
lines to integrate
Python · TS · Go
SDKs
Apache 2.0
open core

Quickstart

Install, add a memory, recall it. That's the whole surface.

$ pip install inra
The problem

Agents forget the moment the context window fills.

A model only knows what's in its prompt right now. Conversations run long, sessions restart, and useful detail scrolls out of the window. Stuffing the whole history back in is expensive and dilutes what matters — and generic RAG over a document store rarely returns the one fact the current step needs.

inra is the layer in between: a place to write what happened and pull back only what's relevant, keyed to the agent and user it belongs to.

How it works

add → store → recall.

One write path, one read path. Recall happens at query time, so the model sees only what the current step needs.

mem.add()

Write what happened

Hand inra a string plus the agent + user it belongs to. It embeds and stores the memory — you don't manage vectors or an index.

store

Kept under scope

Memories live inside a scope, so one user's context never leaks into another's, and each agent keeps its own knowledge.

mem.recall()

Read at query time

Pass the current query. inra returns only the matching memories, ranked by relevance — drop them straight into the prompt.

Capabilities

What the recall layer gives you.

scope

Namespace isolation

Memories are scoped by agent and user, so recall never mixes one end-user's context with another's.

recall

Semantic recall

Retrieval ranks by meaning against the current query — you get the relevant fact, not a keyword match or the whole log.

add

Incremental writes

Add one memory at a time as the conversation happens. No batch reindex, no pipeline to babysit.

any loop

Framework-agnostic

Two calls behind whatever agent loop you run — a tool-calling agent, a graph, or a plain request handler.

Who it's for

Developers building AI agents that need to remember across turns and sessions — support bots, copilots, assistants — without hand-rolling a vector store and a recall pipeline.

Get started →