Recall

Your models remember users and know your documents.

Recall learns durable facts from every conversation and grounds answers in your own documents, then keeps both in one knowledge graph. Ask a question and it recalls the relevant facts and passages, following the connections between them. Extraction and retrieval run on EU-sovereign models, scoped to each end-user and workspace, and erasable on request.

Start free Read the docs

learn · connect · recall

Knowledge graph per end-user

When does Acme launch in Berlin? Recalled

From conversations From documents

Your model forgets every user and has never read your docs.

A model holds nothing between requests and answers only from its training, not from your handbook or last week's decision. So you resend the same context every call and still miss what matters. Build it yourself and you are running a store, an extraction step, and a retrieval step, keeping all of it correct as facts change, often through a US API that ships your data abroad. Two half-solutions, memory and retrieval, that never share what they know.

Learn, connect, recall.

Send a user with your request, add your documents once, and Recall does the rest. Nothing to flag, no context to resend, no retrieval call to wire up.

Learn and ingest After each exchange, an EU-sovereign model extracts durable facts in the background: preferences, roles, decisions. Documents you add are parsed, split, and read into the same graph. It runs after the response, so it adds no latency.
Connect and reconcile Facts and documents become entities and relationships in one temporal graph. New facts are merged against what is known: changed ones update, contradicted ones are retired. The graph stays correct instead of just growing.
Recall with sources On a request that carries a user, Recall blends the relevant facts and passages, following the links between them, and adds them as context before the model runs. Every answer can name the facts and documents it used.

POST /v1/chat/completions api.akumi.cloud

{

"model": "mistral/mistral-small-2603",

"user": "usr_abc123",

"rag": "company-handbook",

"messages": [ ... ]

}

Relevant memory and passages recalled and added, before the model answers

A knowledge layer you can stand behind.

Isolated by construction

Each end-user has their own memory, and each workspace its own documents. Recall reads exactly the scope a request names, never another user's, another workspace's, or another tenant's.

EU-sovereign, end to end

The models that read the conversation and embed your documents run on EU-sovereign endpoints, and the graph lives in an EU-resident store. Your users' memory and your knowledge base never leave the EU.

Governed and erasable

Recalled facts are pseudonymized by the firewall before egress, every answer can cite its sources, the audit trail is metadata-only, and one call wipes everything stored for an end-user.

More than a bigger context window, more than a bolt-on index.

Stuffing the whole history into every prompt is slow, expensive, and still forgets what matters. A do-it-yourself retrieval stack is a vector database plus an embedding API plus glue. Recall is one governed knowledge layer, where memory and documents share a graph.

One graph, not two silos Conversation facts and document facts live together, so a question can follow the link from a user to their organization to the document that answers it.
Automatic, not manual Send a user id and add a collection by name. Facts are learned and recalled and passages retrieved on their own, no separate service to call first.
Reconciled, not appended When a user changes their mind or a document is updated, the graph updates rather than piling up contradictions.
Grounded and cited Answers can name the facts and documents they used, the audit trail stays metadata-only, and any user's memory is erasable on request.

Give your models a knowledge layer.

Create a key, send a user with your requests, add your documents, and stop resending the same context on every call.

Start free Read the docs