REST API · v1

API Reference

Capture, recall, and verify Unified Memory Objects over a small REST API. Below: a map of every call, four use cases you can paste into a terminal, and a worked request and response for each endpoint. Base URL https://api.memoryintelligence.io.

Sign in → Download OpenAPI
Typed Python and JavaScript SDKs are coming. Today, call the REST API directly (any HTTP client), or use the MCP server to give an assistant memory in one command.

At a glance

The whole public surface is ten calls. Click any row to jump to its worked example.

Do thisCallWhat you get
Capture a memoryPOST/v1/processa UMO with a receipt
Capture many at oncePOST/v1/batchone UMO per item
Capture from a filePOST/v1/uploada UMO from PDF text
Browse memoriesGET/v1/memoriesa paginated list
Ask or searchPOST/v1/memories/queryranked results with citations
Get one memoryGET/v1/memories/{id}a single UMO
Verify provenanceGET/v1/memories/{id}/proofsource, hash, receipt
Introspect a memoryGET/v1/memories/{id}/explainentities and structure
Delete a memoryDEL/v1/memories/{id}a deletion receipt
Check the serviceGET/healthstatus, no auth

Authentication

Every request needs your API key as a bearer token. Get one from the developer portal (free during beta). Keep it server-side; never ship it in client code.

Header
Authorization: Bearer mi_sk_your_key_here

Response envelope

Every response is wrapped in a consistent envelope. Read your payload from data; keep request_id for support. The worked examples below show the data payload only.

{
  "status": "success",
  "data": { /* endpoint payload, shown below per call */ },
  "request_id": "req_8f3f...",
  "timestamp": "2026-07-05T19:05:05Z"
}

Errors

Errors use the same envelope with "status": "error" and a human-readable message. The common ones:

CodeMeansFix
401Missing or invalid API keyCheck the Authorization header and your key.
404No memory with that idConfirm the umo_id from a capture or list call.
422Request body failed validationCheck required fields and types (see each call).
429Rate limitedBack off and retry; contact us to raise limits.

Use cases to try

Four short flows you can paste into a terminal. Set your key first: export MI_KEY="mi_sk_...".

Give an agent memory

Capture a fact once, then ask about it later and get an answer that cites its source.

1
Capture the fact with POST /v1/process. Save the umo_id it returns.
curl -X POST $MI_URL/v1/process -H "Authorization: Bearer $MI_KEY" \
  -H "Content-Type: application/json" -d '{"content":"We ship releases on Tuesdays."}'
2
Ask a question with POST /v1/memories/query. The answer comes back ranked, with the source umo_id.
curl -X POST $MI_URL/v1/memories/query -H "Authorization: Bearer $MI_KEY" \
  -H "Content-Type: application/json" -d '{"query":"when do we ship?"}'

Prove where an answer came from

Turn a recall into an auditable claim by verifying the source memory's provenance.

1
Query, and take the top result's umo_id.
2
Verify it with GET /v1/memories/{id}/proof to get the source, content hash, and provenance state.
curl $MI_URL/v1/memories/$UMO_ID/proof -H "Authorization: Bearer $MI_KEY"

Bulk-load a knowledge base

Seed many memories in one call, then browse them.

1
Send an array to POST /v1/batch; each item becomes its own UMO.
curl -X POST $MI_URL/v1/batch -H "Authorization: Bearer $MI_KEY" \
  -H "Content-Type: application/json" -d '{"items":[{"content":"..."},{"content":"..."}]}'
2
Browse them with GET /v1/memories.

Honor a delete request

Let a user remove a memory, and keep a receipt that the removal happened.

1
Find the memory with GET /v1/memories.
2
Delete it with DELETE /v1/memories/{id}. The response is a deletion receipt.
curl -X DELETE $MI_URL/v1/memories/$UMO_ID -H "Authorization: Bearer $MI_KEY"

Capture

Turn content into structured memory

POST/v1/processalias: POST /v1/memories

Turn raw content into a Unified Memory Object. Runs the pipeline (capture, normalize, extract, enrich, parse, embed, validate) and returns the new UMO with a quality score and a provenance receipt.

Request body
contentstring requiredRaw text to capture. A sentence, transcript, or document. Max 50,000 characters.
sourcestring optionalSource identifier (for example "slack"). Stored for filtering.
timestampISO 8601 optionalOriginal content time. Defaults to now. Affects recency in search.
Request
curl -X POST https://api.memoryintelligence.io/v1/process \
  -H "Authorization: Bearer $MI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content":"Sarah proposed provenance hashing for the deck.","source":"meeting-notes"}'
Response 200 · data payload
{
  "umo_id": "019d9cd5-1be8-8d07-0f31-45018cfe4b68",
  "quality_score": 0.72,
  "created_at": "2026-07-05T19:05:05Z"
}
NoticeContent is structured into a UMO, never stored as a raw blob. Save umo_id to reference the memory later; quality_score (0 to 1) is the pipeline's confidence in the extraction.
POST/v1/batch

Capture many items in one call. Send an array of content items; each becomes its own UMO.

Request
curl -X POST https://api.memoryintelligence.io/v1/batch \
  -H "Authorization: Bearer $MI_KEY" -H "Content-Type: application/json" \
  -d '{"items":[{"content":"First note."},{"content":"Second note."}]}'
Response 200
{ "created": 2, "umo_ids": [ "019d...", "019e..." ] }
NoticeUse batch for seeding or syncing. Each item runs the full pipeline, so responses carry one umo_id per item in order.
POST/v1/upload

Capture from a media file, sent as multipart form data.

Request
curl -X POST https://api.memoryintelligence.io/v1/upload \
  -H "Authorization: Bearer $MI_KEY" -F "file=@notes.pdf"
Response 200
{ "umo_id": "019d...", "source": "notes.pdf" }
NoticePDF text is supported today. Audio and image transcription are coming; until then those files capture their extractable text only.

Recall

Browse, search, and read memories back

GET/v1/memories

A paginated list of the authenticated user's UMOs. Use for browsing, sync, or building a custom UI.

Query parameters
limitinteger optionalMax results. Default 20, max 100.
offsetinteger optionalItems to skip for pagination. Default 0.
sourcestring optionalFilter by source.
Request
curl -s "https://api.memoryintelligence.io/v1/memories?limit=20" \
  -H "Authorization: Bearer $MI_KEY"
Response 200
{ "results": [ { "umo_id": "019d...", "created_at": "..." } ], "total": 128 }
NoticePage with limit and offset; total tells you how many exist so you know when to stop.
POST/v1/memories/queryalias: POST /v1/search

Ask a natural-language question or run a semantic search. Returns ranked results, each with a citation back to the source UMO.

Request body
querystring requiredYour question or search text.
limitinteger optionalMax results. Default 5.
Request
curl -X POST https://api.memoryintelligence.io/v1/memories/query \
  -H "Authorization: Bearer $MI_KEY" -H "Content-Type: application/json" \
  -d '{"query":"What do I know about funding?","limit":5}'
Response 200
{ "results": [
  { "umo_id": "019d...", "score": 0.88, "snippet": "Sarah mentioned a seed round." }
] }
NoticeEvery result carries a score and the source umo_id. Pass that umo_id to proof to turn the answer into evidence.
GET/v1/memories/{id}

Fetch a single UMO by its umo_id.

Request
curl -s https://api.memoryintelligence.io/v1/memories/$UMO_ID \
  -H "Authorization: Bearer $MI_KEY"
Response 200
{ "umo_id": "019d...", "content": "...", "created_at": "..." }
NoticeA 404 here means the id is wrong or belongs to another account; keys only see their own memories.

Verify

Prove and introspect what a memory is

GET/v1/memories/{id}/proof

The receipt for a memory: its source, content hash, and provenance chain, cryptographically verifiable.

Request
curl -s https://api.memoryintelligence.io/v1/memories/$UMO_ID/proof \
  -H "Authorization: Bearer $MI_KEY"
Response 200
{ "umo_id": "019d...", "content_hash": "sha256:...", "provenance": "verified" }
NoticeThis is the difference between "the AI said so" and evidence: the hash lets anyone confirm the memory has not changed since capture.
GET/v1/memories/{id}/explain

Introspect a UMO: the entities, relationships, and structure the pipeline extracted.

Request
curl -s https://api.memoryintelligence.io/v1/memories/$UMO_ID/explain \
  -H "Authorization: Bearer $MI_KEY"
Response 200
{ "entities": [ "Sarah", "seed round" ], "relations": [ { "subject": "Sarah", "predicate": "proposed" } ] }
NoticeUse explain to see why a memory matched a query, or to debug extraction quality before you trust a source.

Manage

Delete data, and check the service

DEL/v1/memories/{id}

Delete a memory. Returns a deletion receipt so the removal itself is auditable.

Request
curl -X DELETE https://api.memoryintelligence.io/v1/memories/$UMO_ID \
  -H "Authorization: Bearer $MI_KEY"
Response 200
{ "umo_id": "019d...", "deleted": true, "receipt": "del_..." }
NoticeDeletion is auditable by design: the receipt proves the removal happened, which is what a user or regulator actually needs.
GET/health

Liveness check. No auth required.

Request
curl -s https://api.memoryintelligence.io/health
Response 200
{ "status": "ok" }
NoticeSafe to poll for uptime; it is the only call that does not require a key.
Need every field and error code? The full, always-current contract is the OpenAPI spec. Hit Copy for LLM to hand it to Claude, ChatGPT, or Cursor and have your agent write the integration.