Documentation menu
Straight answers, grounded in how Anansi actually works. If something here is unclear or looks wrong, tell us and we'll fix it.
Getting started
What is Anansi?
A memory API for AI apps. Your app sends Anansi a user's messages and documents; Anansi stores and embeds them, synthesizes a per-user profile, and serves it back ready to drop into a system prompt. Two calls do the job: POST /v1/ingest to remember, GET /v1/context to retrieve.
What problem does it solve?
LLM apps are stateless — users repeat themselves every session. The usual workarounds are stuffing raw history into the prompt (context bloat, quality decay) or building your own vector store plus a dedup/ranking pipeline. Anansi is a drop-in memory layer that removes that work.
How long does it take to integrate?
Usually a few minutes. Install the SDK (or call the REST API directly), add an ingest call where your app produces content, and a context call before your LLM call. That's the whole integration.
Do I need the SDK?
No. The contract is REST with a bearer token and JSON responses. SDKs (TypeScript, Python, Vercel AI SDK, LangChain, an MCP server, and framework-agnostic tools) are convenience wrappers.
How it works
What does GET /v1/context return?
static facts (stable truths about the user, up to 30), dynamic context (current state, up to 15), and — when you pass a q — relevant chunks. On Pro and above the response also includes temporal facts and the entities graph. The static and dynamic arrays drop straight into a system prompt with no post-processing.
What's the difference between static and dynamic?
static is stable ("Senior engineer at a fintech startup", "Prefers TypeScript"); dynamic is what's happening now ("Debugging a webhook dedup issue this week"). The synthesis worker re-derives both as new evidence arrives.
Is ingestion synchronous?
No. POST /v1/ingest returns 202 immediately; chunking, embedding, and synthesis run on background workers. That keeps ingest off your request path — ideal for latency-sensitive apps like voice agents.
What retrieval does it use?
Hybrid search: pgvector cosine similarity plus Postgres BM25, merged with reciprocal rank fusion (or an alpha weighting you control). Vector-only search misses exact lookups; BM25 catches them.
Can I bring my own embeddings?
Yes. Pass a pre-computed 768-dim embedding on ingest and Anansi stores your vector directly, skipping the internal embedding provider.
Knowledge-time & the graph
What does "bi-temporal" mean here?
Every relationship the synthesis worker extracts carries two independent time axes: valid-time (when the fact was true in the world) and knowledge-time (when Anansi learned it). Most memory stores track only the first, or just overwrite.
What's the difference between asOf and asOfKnowledge?
asOf reconstructs the graph as it was valid at an instant. asOfKnowledge reconstructs it as you knew it at an instant. Together they answer "what was true on May 1 — as we understood it on May 1?" versus "what was true on May 1 — as we know it today?"
Why does knowledge-time matter?
Two reasons. Audit: "what did we know on March 3rd when we made that call?" is answerable instead of silently rewritten. And debugging agents: you can reconstruct exactly what an agent knew at the moment it made a decision. It's a Pro+ feature (GET /v1/entities).
Does anyone else offer knowledge-time queries?
Zep (Graphiti) models bi-temporality too — we do not claim this is unique against them. As of mid-2026, neither Mem0's nor Supermemory's public APIs expose a knowledge-time query. See the landscape page for the honest full comparison.
Pricing & plans
How much does it cost?
Free ($0), Pro ($19/mo), Scale ($99/mo), and Enterprise (contact us). Usage-metered, cancel anytime from the portal.
What's in the free tier?
1,000 ingest calls and 500 context calls per month, 10 memory users, 7-day retention, vector retrieval. No credit card required.
What unlocks on Pro?
25,000 ingest / 10,000 context calls, unlimited memory users, unlimited retention, hybrid and keyword search, metadata filters, the entity graph and bi-temporal queries, workspace-scoped context, all connectors, and outbound webhooks. A 14-day trial is included.
What happens when I exceed a limit?
Calls beyond your monthly quota return 402 with an upgrade message. Per-minute rate limits return 429 with Retry-After: 60.
Models & self-hosting
Which LLM does Anansi use?
A provider chain: Cerebras (gpt-oss-120b) first, then GitHub Models (gpt-4o-mini), then local Ollama (llama3.1:8b). Query and synthesis have separate model slots, so you can route synthesis to a stronger model. Embeddings use Nomic nomic-embed-text-v1.5, falling back to Ollama.
Can it run fully local / offline?
Yes. With no cloud API keys set, the LLM and embedding providers automatically fall back to local Ollama, so the whole stack runs with zero external API calls. One honest caveat: we have not yet validated synthesis quality — especially bi-temporal entity extraction — on the small local llama3.1:8b model. Treat fully-local mode as great for development, offline work, and privacy prototyping; for production-grade synthesis accuracy, set a remote LLM key.
Is it really self-hostable?
Yes, and MIT-licensed with no open-core asterisks. docker compose up -d brings up PostgreSQL (pgvector) and Redis; the API ships its own Dockerfile. You can read the retrieval and synthesis code before you trust it with your users' memory.
Do I have to send my users' data to your servers?
Not if you self-host — memory never leaves your infrastructure. On the hosted service, your data is stored in our Postgres and processed by the configured LLM/embedding providers.
Security & privacy
How are API keys stored?
Hashed with HMAC-SHA256 (using a dedicated secret, separate from the token-encryption key). Raw keys are never stored, and a regex fast-reject filters obviously-invalid keys before any database hit.
How is tenant isolation enforced?
workspace_id / developer_id. Postgres row-level security is enabled on memory_chunks as a NULL-guard safety net, not as the isolation boundary. We'd rather tell you exactly how it works than imply RLS is doing more than it is.Are secrets redacted from ingested content?
Yes. Detected secrets are redacted on ingest, and end-user text is run through prompt-injection neutralization before it ever reaches an LLM. OAuth tokens (Slack, Notion, Google) are AES-256-GCM encrypted at rest.
Are outbound webhooks safe?
Yes. Webhook and URL-ingestion targets are validated against an SSRF allowlist (HTTPS only, no private/RFC-1918 addresses), with re-validation across redirects.
Data & deletion
How do I delete a user's memory?
DELETE /v1/memory?userId=… wipes all chunks, the synthesized profile, and the entity graph (the user row is kept so you can re-ingest). Add sourceId to delete just one ingested document. Caches are evicted on delete.
How do I do a GDPR hard-delete?
DELETE /v1/user?userId=… removes the user row and all cascaded child data (chunks, profile, entity nodes and edges) and evicts caches. It's idempotent — deleting an unknown user still returns {deleted: true}.
How long is data retained?
7 days on Free, unlimited on paid plans. You can also set a per-chunk TTL on ingest for ephemeral memory.
Performance & reliability
Do you publish latency or throughput benchmarks?
context reads hit a Redis cache (60s TTL), ingest is async (returns 202), and embedding/synthesis run off the request path. When we have a real benchmark, we'll publish the methodology with it.Is there a status page?
Yes — /status reports live PostgreSQL and Redis connectivity plus the running API version. Every API response also carries an API-Version header.
How does it scale, and what are the limits?
The API and background workers scale out independently. Today it runs on a single Postgres and Redis in a single region — honestly, that's the current ceiling, and it's plenty for launch-scale traffic. Larger deployments would move Postgres to a managed provider with read replicas.
How it compares
How is Anansi different from Mem0, Supermemory, and Zep?
They're all capable tools, and several now return synthesized profiles and offer graph or temporal memory — we won't pretend otherwise. Where Anansi is genuinely differentiated: knowledge-time queries (asOfKnowledge, not in Mem0's or Supermemory's public APIs), MIT self-hosting with a full local-model path, and a first-party Slack app. The landscape page is the honest, tool-by-tool breakdown.
Should I use Anansi or just build on pgvector myself?
Build it yourself if you want full control and don't need synthesis, hybrid search, a temporal graph, and billing out of the box. Use Anansi to skip weeks of pipeline work — it's two calls instead of a vector store plus a dedup/ranking/synthesis layer you maintain.
Didn't find your answer? Email us or open an issue on GitHub.