Long-term memory for AI agents — connect a client, call the API, and your agent remembers across sessions. Grounded, graph-based recall with automatic tiering and consolidation.
A deterministic long-term memory engine for AI agents — built to replace probabilistic vector guesswork and LLM write-wrappers.
Every memory is a typed, scored node connected to related memories by typed relationships (Supersedes, Causal, Semantic, DependsOn, Temporal). Unlike LLM memory wrappers that call a stochastic model on every write, Memoreal's encode and recall paths are 100% deterministic: the same sequence of events produces the exact same state, the exact same Supersedes belief revisions, and the exact same recall trace in 12–17 ms with zero LLM tokens.
Memories live in retention tiers (Buffer → Episodic → Semantic → Core) and are automatically promoted, demoted, or forgotten based on importance and usage. Layered on top: 15-language multilingual reasoning, offline consolidation, reinforcement from feedback, safety filters (PII redaction + threat quarantine), and confidence scoring. Every operation is isolated by namespace.
Zero LLM calls on encode or recall. Supersedes belief revision, multi-session counting, and temporal queries execute deterministically in <15 ms.
Recall traverses causal, semantic, and temporal relationships to surface facts that flat vector similarity misses.
Every recall emits a reproducible trace (/v1/trace/recent), and every query enforces strict organization and namespace isolation.
Three ways to use it: connect an MCP client (Claude Code, OpenCode, Cursor), call the HTTP API directly, or use an SDK. Start with the Quickstart.
From zero to your first recall in three steps.
Create an account (or log in). You'll get an isolated namespace and your first key — it starts with mem_dev_ and is shown once. Generate more anytime from your account.
Add the Memoreal MCP server to Claude Code with one command:
claude mcp add -s user --transport http memoreal https://memoreal.kolivri.com/v1/mcp \ --header "Authorization: Bearer mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
Or run via the zero-install npm / npx stdio bridge (@kolivri/memoreal-mcp):
claude mcp add memoreal -e MEMOREAL_API_KEY="mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" -- npx -y @kolivri/memoreal-mcp
MEMOREAL_API_KEY="mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" npx -y @kolivri/memoreal-mcp
…or paste this into your MCP client config (Cursor, Claude Desktop, etc.):
{
"mcpServers": {
"memoreal": {
"type": "http",
"url": "https://memoreal.kolivri.com/v1/mcp",
"headers": { "Authorization": "Bearer mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
}
}
}Your agent can now store and retrieve memories in your namespace. Or hit the HTTP API directly:
# store a memory
curl -X POST https://memoreal.kolivri.com/v1/memories \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"content":"We deploy on Fridays after 2pm","type":"Episodic","namespace":"my-project"}'
# recall what you know
curl -X POST https://memoreal.kolivri.com/v1/memories/recall \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"query":"when do we deploy?","namespace":"my-project"}'Organization isolation is handled automatically behind the scenes from your API key — pass any project or workspace name (e.g. my-project or default) in the namespace field.
The concepts you work with when storing and recalling memories.
Every memory has a retention tier. Migration between tiers is automatic, driven by salience and access patterns.
| Tier | Retention | Lifecycle | Notes |
|---|---|---|---|
| Buffer | Short-term | Promotes on repeated access or high salience | Automatically expired when unused. |
| Episodic | Medium-term | Promotes with sustained usage across sessions | Captures session events and task history. |
| Semantic | Long-term | Promotes when confirmed as durable knowledge | Distilled project facts and conventions. |
| Core | Permanent | Pinned or created as core rules | Never decays or expires. |
The type you assign at encode time. Over the HTTP API and TypeScript SDK these are PascalCase (Episodic); over MCP, the Python SDK, and the CLI they're lowercase (episodic).
| Type | Meaning |
|---|---|
Buffer | Short-lived scratch memory awaiting promotion. |
Episodic | An event or experience carrying temporal context. |
Semantic | Distilled factual knowledge. |
Core | Immutable foundational knowledge. |
Procedural | A learned action sequence or workflow. |
Prospective | A future-oriented intention or reminder. |
Memories are connected by typed relationships so recall can follow causal chains, dependency trees, and belief revisions.
| Edge type | Meaning |
|---|---|
Causal | One memory caused or led to another. |
DerivedFrom | Source was derived from the target — a provenance trail. |
DependsOn | Source requires the target to hold. |
Assumes | Source depends on the truth of a target assumption. |
Supersedes | Source replaces the target; outdated memories are automatically suppressed. |
Evidence | Source provides evidence supporting the target. |
Semantic | Shared meaning or topic, linked automatically at encode time. |
CoRetrieval | Frequently retrieved together and reinforced on co-access. |
Schema | Linked through a shared category schema. |
Contains | Structural containment (project → dir → file → definition). |
Predicts | Source predicts the target will be needed. |
Temporal | Sequential proximity in time, linked automatically. |
Contradicts | Marks conflicting statements so stale or contradictory state is surfaced. |
Recall matches your query against your isolated namespace and traverses connected relationships (Causal, DependsOn, Semantic, Supersedes) to surface relevant context — even when an important decision does not share exact keywords with the prompt. Every traversal strictly enforces your organization namespace boundary.
Candidates are ranked deterministically using relevance, salience, recency, retention tier, and historical utility. When a newer memory Supersedes an older one, the outdated fact is automatically suppressed so your agent always receives current state.
Salience is a memory's importance (0–1). An explicit value you pass always wins; otherwise Memoreal assigns it automatically based on novelty and high-consequence signals. Salience guides ranking and retention tier promotion.
Consolidation merges near-duplicate episodic captures into clean Semantic knowledge linked by Supersedes, reinforces co-accessed memories, groups related session events, and flags contradictions.
Calling /v1/feedback or the feedback MCP tool marks a memory as useful or unhelpful, immediately adjusting its future ranking priority without deleting history.
Before storage, Memoreal can redact sensitive identifiers (emails, phone numbers, API keys, payment cards) and quarantine suspected prompt-injection payloads so poisoned inputs do not corrupt agent context.
Every recall evaluates result confidence and emits an auditable trace (GET /v1/trace/recent) so you can inspect why specific memories were returned.
One key per request, scoped to your namespace.
Authenticate every request with your key as a Bearer token:
Authorization: Bearer mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Keys look like mem_dev_ followed by 43 URL-safe characters. The raw key is shown once at creation and never stored — only a SHA-256 hash is kept, so if you lose a key you mint a new one. The token is opaque: it carries no embedded namespace; your scope is looked up server-side.
Every API key is automatically scoped to your organization behind the scenes — you never pass an org: identifier. The namespace field in API and MCP calls is purely for your own project, repository, or agent wing name (e.g. my-project, backend, or default). One organization's data can never surface in another's query.
Mint additional keys and revoke any key instantly from your account. Revocation takes effect on the very next request (nothing is cached). You can only see and revoke keys under your own account.
Requests are rate-limited per key (a token bucket). Exceed it and you get 429 Too Many Requests with a Retry-After header and a JSON body {code:"RATE_LIMIT_EXCEEDED", status:429, message}. Each organization also has a rolling usage quota; once it's exhausted, requests return 402 Payment Required until the window advances. The exact throughput and quota scale with your plan — check your account.
The Model Context Protocol is the fastest path — your agent gets memory tools automatically.
Add Memoreal to Claude Code:
claude mcp add -s user --transport http memoreal https://memoreal.kolivri.com/v1/mcp \ --header "Authorization: Bearer mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
Or configure any MCP client (Cursor, Claude Desktop, VS Code) over Streamable HTTP:
{
"mcpServers": {
"memoreal": {
"type": "http",
"url": "https://memoreal.kolivri.com/v1/mcp",
"headers": { "Authorization": "Bearer mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
}
}
}Or connect via npm / npx stdio (@kolivri/memoreal-mcp):
claude mcp add memoreal -e MEMOREAL_API_KEY="mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" -- npx -y @kolivri/memoreal-mcp
MEMOREAL_API_KEY="mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" npx -y @kolivri/memoreal-mcp
{
"mcpServers": {
"memoreal": {
"command": "npx",
"args": ["-y", "@kolivri/memoreal-mcp"],
"env": {
"MEMOREAL_API_KEY": "mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
"MEMOREAL_NAMESPACE": "my-project"
}
}
}
}The connection speaks JSON-RPC 2.0 over streamable HTTP (protocol 2024-11-05) at https://memoreal.kolivri.com/v1/mcp (with backward-compatible support for legacy https://memoria.kolivri.com/v1/mcp). Namespace is chosen per call via the namespace argument (or the x-memoreal-namespace / x-memoria-namespace header default).
Memoreal provides 14 MCP tools natively on Hosted Cloud + Local (encode_memory, batch_encode, recall_memories, build_context, forget_memory, delete_by_context, feedback, consolidate, health, stats, search_code, explain_code, list_agent_wings, handoff_to_agent). Deep static code-intelligence tools require the Local CLI Engine.
| Tool | Availability | Params | Does |
|---|---|---|---|
encode_memory | Hosted Cloud + Local | namespace, content, type?, salience?, context? | Store a memory with tier classification (buffer, episodic, semantic, core). |
batch_encode | Hosted Cloud + Local | memories:[{ content, type?, namespace, ... }] | Atomically store multiple memories in a single batch call. |
recall_memories | Hosted Cloud + Local | query, namespace?, token_budget?, min_salience? | Retrieve relevant memories ranked deterministically within a token budget. |
build_context | Hosted Cloud + Local | query, namespace?, token_budget? | Assemble a token-budgeted <memory_context> block for a query. |
forget_memory | Hosted Cloud + Local | id | Delete a memory and its incident graph edges by UUID. |
delete_by_context | Hosted Cloud + Local | key, value, namespace? | Bulk delete memories matching a context metadata [key, value] pair. |
feedback | Hosted Cloud + Local | id, useful | Mark a recalled memory useful or noisy to adjust its ranking priority. |
consolidate | Hosted Cloud + Local | namespace | Run offline consolidation: merge duplicates and detect patterns & edges. |
health | Hosted Cloud + Local | — | Engine health across namespaces, active counts, and quota status. |
stats | Hosted Cloud + Local | namespace | Per-namespace memory count, tier breakdown, and 30-day API usage. |
list_agent_wings | Hosted Cloud + Local | namespace? | List specialist agent wings (architect, reviewer, qa, security, ops). |
handoff_to_agent | Hosted Cloud + Local | wing, summary, task?, files?, memory_ids? | Record a structured handoff into a specialist agent wing. |
Index a repository into a code/<project> namespace and these become available:
| Tool | Availability | Does |
|---|---|---|
search_code | Hosted Cloud + Local | Search indexed code definitions and architectural notes in Memoreal. |
explain_code | Hosted Cloud + Local | What a symbol is, who calls it, its tests and context. |
find_references | Local CLI Engine | Every reference to a symbol (graded exact, heuristic, ambiguous). |
find_file | Local CLI Engine | Locate a file/dir by path substring, shallowest first. |
impact | Local CLI Engine | Transitive blast radius of changing a symbol (reverse-call walk). |
call_tree | Local CLI Engine | Nested caller (in) or callee (out) tree for a symbol. |
dead_code · test_gaps | Local CLI Engine | Uncalled definitions · definitions with no test. |
rename · diff_risk | Local CLI Engine | Reviewed rename worklist · callers at risk for changed symbols. |
implementors | Local CLI Engine | Types implementing a trait/interface (Rust / TS). |
explain_diff · explain_error | Local CLI Engine | Analyse a unified diff · an error/stack trace. |
navigate · get_hierarchy | Local CLI Engine | Walk the containment map · a node’s full vertical context. |
The same tools are reachable over plain HTTP JSON-RPC at POST /v1/mcp:
curl -X POST https://memoreal.kolivri.com/v1/mcp \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
"params":{"name":"recall_memories",
"arguments":{"query":"auth flow","namespace":"code/myapp"}}}'Successful results come back as {content:[{type:"text", text:<json>}]}. Call tools/list to see everything the server advertises.
Everything the agents do, over plain REST. Base URL https://memoreal.kolivri.com, all routes under /v1, Bearer auth.
Hosted Cloud routes run on Hosted Cloud and sync to your persistent tenant partition. Experimental and codebase-indexing AST routes run on the Local Engine Only.
/v1/memoriesHosted Cloud{ content, type, namespace, salience?, context?, links? }201 { id, created_at, salience, tier, quarantined, is_duplicate, duplicate_of? }curl -X POST https://memoreal.kolivri.com/v1/memories \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"content":"user prefers dark mode","type":"Episodic","namespace":"my-project","salience":0.8,"context":{"user_id":"john-123"}}'/v1/memories/recallHosted Cloud{ query, namespace, token_budget?=4096, min_salience?=0, context?, mode? }200 { results:[{ memory, score }], total_candidates, latency_ms, metacognition? }curl -X POST https://memoreal.kolivri.com/v1/memories/recall \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"query":"authentication tokens","namespace":"my-project","token_budget":4096}'/v1/memories/contextHosted Cloud{ query, namespace, token_budget?=4096, format?=Structured (Structured|Narrative|Raw), context?, mode? }200 { context, memories_used }/v1/memories/recall/enhancedHosted Cloud{ query, namespace, token_budget?, diversity?=0.7, min_salience?, mode? }200 { results, total_candidates, latency_ms, cache_hit, trace_id?, metacognition? }/v1/memories/:idHosted Cloud(none)200 { deleted }/v1/memories/:id/neighborsHosted Cloud(none)200 { edges:[{ target_id, edge_type, weight }] }/v1/memories/batchHosted Cloud{ memories:[{ content, type?, salience?, context?, namespace }] }201 { ids, encoded, failed, compressed_size, raw_size }/v1/memories/recall/batchHosted Cloud{ queries:[{ query, namespace, token_budget? }] }200 { results: MemoryResult[][] }/v1/memories/by-contextHosted Cloud{ namespace, context_key, context_value }200 { deleted }/v1/consolidateHosted Cloud{ namespace }200 { patterns_found, edges_created, memories_created, contradictions }/v1/feedbackHosted Cloud{ memory_id? | recall_id?, useful?, score? }200 { updated }/v1/intentionsLocal Engine Only{ trigger_type, trigger_data, action, salience, expires_at?, namespace }201 { id }/v1/intentions?namespace=NSLocal Engine Only(query)200 { intentions:[{ id, trigger_type, action, salience, expires_at?, created_at, namespace }] }/v1/intentions/:idLocal Engine Only(none)200 { deleted }/v1/healthHosted Cloud(none)200 { memory_count, edge_count, tier_distribution, namespace_count }/v1/stats?namespace=NSHosted Cloud(query)200 (MemoryStats)/v1/meta/knowledge-map?topic=T&namespace=NSLocal Engine Only(query)200 (KnowledgeMapEntry)/v1/meta/contradictions?namespace=NSLocal Engine Only(query)200 { contradictions:[…] }/v1/graph/dot?namespace=NS&max_nodes=50Local Engine Only(query)200 text/plain (DOT)/v1/trace/:recall_idHosted Cloud(none)200 (RecallTrace)/v1/events/streamHosted Cloud(none)text/event-stream/v1/events?since=RFC3339Hosted Cloud(query)200 [{ event_type, data, timestamp, id }]An interactive OpenAPI 3.1 specification is served at /v1/openapi.json (with documentation at /docs#rest). Auth and rate-limit errors return {code, status, message}; most other errors return standard HTTP status codes.
Index a repository into a code/<project> namespace and Memoreal becomes a queryable map of it — definitions, references, call graphs, blast radius.
| Method · Path | Availability | Purpose |
|---|---|---|
POST /v1/code/search | Hosted Cloud + Local | Semantic search over indexed definitions (optional type filter). |
POST /v1/code/explain | Hosted Cloud + Local | What a symbol is, who uses it (live scan), and its tests. |
POST /v1/code/references | Local Engine Only | Every reference to a symbol — call / definition / mention, graded. |
POST /v1/code/find | Local Engine Only | Find files/dirs whose path matches a name, shallowest first. |
POST /v1/code/impact | Local Engine Only | Blast radius: transitive reverse-call walk of what could break. |
POST /v1/code/call-tree | Local Engine Only | Nested caller (in) or callee (out) tree. |
POST /v1/code/dead-code | Local Engine Only | Definitions with no in-namespace caller (removal candidates). |
POST /v1/code/test-gaps | Local Engine Only | Non-test definitions with no direct test caller. |
POST /v1/code/rename | Local Engine Only | Reviewed line-level edit worklist for a rename (not an auto-patcher). |
POST /v1/code/diff-risk | Local Engine Only | For a set of changed symbols, their direct callers at risk. |
POST /v1/code/implementors | Local Engine Only | Types whose impl Trait for Type names a symbol (Rust today). |
POST /v1/code/diff · /error | Local Engine Only | Natural-language analysis of a unified diff · an error/stack trace. |
POST /v1/code/build-edges | Local Engine Only | Materialise Contains + DependsOn edges after indexing (idempotent). |
curl -X POST https://memoreal.kolivri.com/v1/code/impact \
-H "Authorization: Bearer $MEMOREAL_KEY" -H "Content-Type: application/json" \
-d '{"namespace":"code/myapp","symbol":"calc_total","max_depth":5,"limit":200}'
# -> { symbol, affected:[{ qualified_name, file, line, depth, min_confidence }], total, truncated }All code tools are also exposed as MCP tools (see Connect via MCP). Search and explain run natively on Hosted Cloud + Local, while structural AST analysis runs on the Local CLI Engine. Findings are graded (exact / heuristic / ambiguous) with confidence scores — treat rename and dead-code output as a reviewed worklist, not an automatic edit.
No external package installation required — call the API directly with standard fetch or paste this clean zero-dependency client into your codebase:
// Zero-dependency TypeScript / Node 20+ fetch client
export class MemorealClient {
private readonly baseUrl: string;
private readonly apiKey: string;
constructor(
baseUrl = "https://memoreal.kolivri.com",
apiKey = process.env.MEMOREAL_KEY || process.env.MEMORIA_KEY || "mem_dev_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
) {
this.baseUrl = baseUrl.replace(/\/+$/, '');
this.apiKey = apiKey;
}
private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
const res = await fetch(`${this.baseUrl}${path}`, {
...options,
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${this.apiKey}`,
...options.headers,
},
});
if (!res.ok) {
const err = await res.json().catch(() => ({ message: res.statusText }));
throw new Error(`Memoreal HTTP ${res.status}: ${JSON.stringify(err)}`);
}
return res.json() as Promise<T>;
}
/** Store a memory (Episodic, Semantic, Buffer, Core) */
async encode(content: string, namespace = 'my-project', type = 'Episodic', salience = 0.8) {
return this.request<{ id: string; tier: string }>('/v1/memories', {
method: 'POST',
body: JSON.stringify({ content, namespace, type, salience }),
});
}
/** Assemble a token-budgeted memory context block */
async buildContext(query: string, namespace = 'my-project', token_budget = 4096) {
return this.request<{ context: string; memories_used: number }>('/v1/memories/context', {
method: 'POST',
body: JSON.stringify({ query, namespace, token_budget }),
});
}
/** Recall memories scored by BM25, tier weight, and salience */
async recall(query: string, namespace = 'my-project', token_budget = 4096) {
return this.request<{ results: Array<{ score: number; memory: any }> }>('/v1/memories/recall', {
method: 'POST',
body: JSON.stringify({ query, namespace, token_budget }),
});
}
}
// Backward-compatible alias for existing integrations
export { MemorealClient as MemoriaClient };
// Example usage:
const memoreal = new MemorealClient("https://memoreal.kolivri.com", process.env.MEMOREAL_KEY || process.env.MEMORIA_KEY);
await memoreal.encode("Deployments require passing end-to-end integration tests", "my-project");
const { context } = await memoreal.buildContext("deployment requirements", "my-project");
console.log(context);| Method | Endpoint | Availability |
|---|---|---|
encode(content, ns?, type?, salience?) | POST /v1/memories | Hosted Cloud |
buildContext(query, ns?, budget?) | POST /v1/memories/context | Hosted Cloud |
recall(query, ns?, budget?) | POST /v1/memories/recall | Hosted Cloud |
forget(id) | DELETE /v1/memories/:id | Hosted Cloud |
encodeBatch(memories) | POST /v1/memories/batch | Hosted Cloud |
consolidate(ns) · feedback(id, useful) | POST /v1/consolidate · /v1/feedback | Hosted Cloud |
deleteByContext(key, val, ns?) | DELETE /v1/memories/by-context | Hosted Cloud |
health() · stats(ns) | GET /v1/health · /v1/stats | Hosted Cloud |
A native (PyO3) module that links the engine in-process — embedded, no server or HTTP. Build with maturin develop. Enum-like strings are lowercase (episodic). Surface: encode · recall · build_context · forget · health.
from memoreal import Memoreal
m = Memoreal() # in-process; wraps the engine directly
mid = m.encode("Deployed v2 to prod", "episodic", "myapp")
out = m.recall("deployment", "myapp", token_budget=2048)
for r in out["results"]:
print(r["score"], r["content"])
print(m.build_context("deployment", "myapp", 4096)["context"])The Python SDK is for embedding the engine locally. For the hosted cloud service, connect via MCP (https://memoreal.kolivri.com/v1/mcp) or use the HTTP API with standard fetch or requests. Local Rust workspace crates (memoria-core, memoria-server) are also available in the repository for embedded engine development.
The memoreal binary runs against a local SQLite database (default ~/.memoreal/memoreal.db). Global flags: --db PATH, --format text|json, --verbose.
| Command | Does |
|---|---|
memoreal health | Graph stats: memory/edge counts, tier distribution. |
memoreal encode --namespace NS --content T --type episodic | Encode a memory; prints its id. |
memoreal recall --namespace NS --query T [--budget 4096] | Recall ranked results for a query. |
memoreal search --namespace NS --query T | BM25 lexical search (top 20). |
memoreal forget --id UUID | Delete a memory by UUID. |
memoreal stats --namespace NS | Per-namespace stats + health assessment. |
memoreal consolidate --namespace NS | Run offline consolidation. |
memoreal migrate --namespace NS | Run tier promotion/demotion/GC. |
memoreal contradictions --namespace NS | Detect contradictory memory pairs. |
memoreal meta --namespace NS --topic T | Metamemory knowledge-map for a topic. |
memoreal export --namespace NS | Dump all memories in a namespace as JSON. |
memoreal import json|csv --file F --namespace NS | Import memories from a file. |
memoreal graph dot|ascii … | Export the graph (Graphviz DOT / ASCII neighborhood). |
memoreal backup|restore --file F | Checksummed JSON backup / restore. |
memoreal trace --last | Show the most recent recall trace. |
memoreal pii-check --content T | Scan text for PII. |
--db must come before the subcommand: memoreal --db /path.db health. Memory types accept lowercase values.
Yes. Your key resolves to your own organization and namespace, and every read, write, and graph traversal enforces strict tenant boundaries — one organization’s data can never surface in another’s query.
You can’t recover it — only a hash is stored. Mint a new key from your account and revoke the old one. Revocation is effective on the next request.
No. Promotion, demotion, and garbage-collection between Buffer → Episodic → Semantic → Core happen automatically from salience and access patterns. Pin a memory or set it to Core to keep it forever.
Up to 1000 memories per /v1/memories/batch call; the decompressed payload must be ≤64 MiB. For larger loads, send multiple batches.
Requests are rate-limited per key (429 with a Retry-After header when you exceed it), and each org has a rolling usage quota (402 when it’s exhausted, until the window advances). The exact numbers scale with your plan — see your account.
PascalCase (Episodic) over the HTTP API and TypeScript SDK; lowercase (episodic) over MCP, the Python SDK, and the CLI.
Index a repo into a code/<project> namespace, then call the /v1/code/* endpoints or the corresponding MCP tools. Findings are graded by confidence — treat rename/dead-code as a reviewed worklist.
Still stuck? Your account has your API keys and Memory Explorer, and the Quickstart gets you connected in a minute.