Skip to content

Give your LLM
long-term memory
of your data.

Send your data once. One POST returns ranked, cited chunks already formatted for your prompt — packed to the token budget you name, and marked unanswerable when your corpus does not cover the question. No vector database to run.

Get an API keySee the API
endpoints
2
retrieval strategies
6
client libraries to install
0

Worked examples

Same model.
Same question.

Left: a model with no context. Right: the same model after one call to /recall. It cites the demonstration corpus every key can search — take one and run these four questions against the same chunks yourself. The corpus has no answer to the last one. Watch what each side does with that.

Bare model

0 tokens of context

I don't have access to Acme's contract. Enterprise agreements typically renew annually, and overage terms vary by deal — you'd need to check the MSA directly or ask your account team.

no grounding · answer is a guess

Same model, with Itan

2 chunks · cited

Acme renews 1 March 2026. Overage billing is capped at 15% above committed spend, and the cap survives the auto-renewal clause in §7.2.

acme_msa_2024.pdf · chunk 410.91
salesforce/opportunity/44710.84
cited · every claim traceable to a chunk

What happens to what you send.

Five stages, all of them ours to run. Your data is split, embedded, and indexed as vectors where distance means similarity. A query is embedded the same way, and the nearest chunks come back ranked, filtered, and cited.

synthetic field · 8 clusters · euclidean1,200 points · k = 8
query vector·stored memorytop-k = 8
An illustration, not a customer’s data: 1,200 synthetic points in eight clusters. The nearest neighbours are computed live, by actual distance.

  1. Ingest

    PDFs, Postgres rows, Slack threads, Notion pages, S3 objects. Push to the API or point us at a source and we pull on a schedule.

    push · scheduled pull

  2. Chunk

    Split on document structure, not blind 512-token windows. Headings, tables, and code blocks stay intact.

    recursive · 12% overlap

  3. Embed

    Current embedding models, or bring your own. Every vector records the model that made it, so an upgrade never silently reshuffles your recall.

    1,536 dim

  4. Index

    HNSW with scalar quantization, one namespace per tenant. A write is queryable on the next request, with no indexing delay to wait out.

    HNSW · per-tenant namespace

  5. Retrieve

    One POST returns ranked, cited chunks with your filters and strategy applied.

    6 strategies · one endpoint

One call to store. One to recall.

Plain JSON over HTTPS, so the client is whatever your language already ships with — nothing to install, nothing to keep up to date. What comes back includes a prompt-ready string, so you never reshape JSON yourself.

Take a key and run it, or read the reference.

# 1. store — send the data once
curl -X POST $ITAN_HOST/api/memories \
  -H "Authorization: Bearer $ITAN_KEY" \
  -d '{"source":"acme_msa_2024.pdf","text":"Overage is capped at 115%..."}'
 
# 2. recall — before every prompt
curl -X POST $ITAN_HOST/api/recall \
  -H "Authorization: Bearer $ITAN_KEY" \
  -d '{
       "query": "when does acme renew?",
       "max_tokens": 4000,
       "strategy": "hybrid"
     }'
 
# -> ranked chunks, a prompt-ready string, and
#    "sufficient": false when the answer isn't in there
200 OKexample response
{
  "chunks": [
    {
      "text": "Overage billing shall not exceed
               115% of Committed Spend...",
      "source": "acme_msa_2024.pdf",
      "chunk": 41,
      "score": 0.91,
      "written_at": "2024-03-01"
    }
  ],
  "prompt": "Answer using only the context below...",
  "sufficient": true,
  "strategy": "hybrid",
  "tokens_estimated": 397,
  "returned": 6,
  "sandbox": true
}

Retrieval is a parameter, not a rewrite.

Six strategies behind the one /recall endpoint. Change the strategy field, measure, keep what wins. Your ingest, index, and prompts stay as they are. Against each one is the work it does per query, which is what its cost tracks.

Semantic

Vector nearest-neighbour over cosine distance. Fastest path, and the default when your corpus is prose.

strategy: "semantic", min_score: 0.72
max_tokens: 4000
Ask for a budget, not a count
You know how much room the context has. You do not know how many chunks fill it. Recall packs ranked chunks until the assembled prompt would exceed the budget, then stops, and reports what it spent.
as_of: "2026-02-01"
Ask what you knew in February
Runs the query against the corpus as it stood on a past date. Anything written later is absent rather than down-ranked, and the ranking statistics are rebuilt over what remains.

Where your data lives, and who can read it.

A memory layer holds the material your organisation would least like to see leave. So the boundary is the product. Start with the three you can verify against the API right now.

  • Isolation is in the request pathEvery read and write is scoped to the calling key before it reaches the index. One key cannot see another key's chunks — issue a second key and try it.
  • Deletion returns a receiptDELETE removes a chunk, or everything a key holds, and answers with the count that no longer exists. The next recall cannot return what it removed.
  • Keys carry no personal dataA key is a timestamp, a random value, and an HMAC signature. Issuing one records nothing about who asked.
t_1t_2t_3no shared segments · no cross-tenant path

The security model

roadmap

The controls the platform is architected around, published early so you can tell now — not after a procurement cycle — whether it would clear your review.

Tenant isolation
Each tenant gets its own index namespace and its own data encryption key. No shared index segments, so one tenant's query has no path to another tenant's vectors.
key-per-tenant · no shared segments
Data residency
Pin a project to a region when you create it. EU data stays embedded, indexed, and served in-region, including during failover.
region pinned at creation
Encryption
AES-256 at rest, TLS 1.3 in transit, and the option to supply your own key so revoking it makes the data unreadable — to you and to us.
AES-256 · TLS 1.3 · BYOK
Deletion
A delete propagates through the index, the embedding cache, and backups within 24 hours, and returns a receipt with the count of vectors removed.
≤ 24 h · GDPR Art. 17
Audit
Every read and write logged with actor, tenant, strategy, and a hash of the query, exportable to your own object storage or a webhook.
append-only · exportable
Network
Compute and index nodes on private subnets only, reachable through the API layer, with private connectivity to your own network on request.
private subnets · peering

Start with a key.

A key is issued instantly and lasts seven days. Store a chunk, recall it with any of the six strategies, delete it and get the count back. No sign-up, no card, no call.

Read the API reference