Point your agent at one endpoint. It stores experience and gets back the right context, hybrid-retrieved, ranked, and packed to a token budget, improving as the agent runs. Not a vector store. Not an SDK. A database whose query primitive is recall.
Agents remember experience on one side and get packed context back on the other. In between, a database that retrieves, reranks, packs, and curates itself.
One call does it all. Send an intent and a token budget; get back a ranked, deduped, cited context window, fused across vector, keyword, recency, and graph retrieval. You never touch a vector. Embeddings are generated server-side by a local model, so there is no API key and no per-call cost.
# intent in, packed and cited context out $ curl -X POST $TM/v1/recall -d '{ "agent_id": "a1", "intent": "what is the API rate limit?", "token_budget": 2000 }' { "context": "[1] API rate limit is 1000 rpm per tenant.", "items": [{ "id": 42, "mtype": "semantic", "why": ["vector","keyword","rerank"] }], "tokens_used": 16, "tokens_saved_vs_dump": 1840 }
Generic Postgres plus pgvector is bad at exactly what agents need. The value lives in four primitives a stitched-together setup cannot easily match.
Send an intent, get the most useful context window, fused across retrievers, reranked, and packed to your budget with citations.
Background workers keep memory healthy. Each recall boosts what it surfaced; time decays the rest. Useful memories rise, stale ones sink.
Every memory records when it was true and when you learned it. Recall the past, prove how the agent knows things, isolate tenants at the database.
Ships an MCP server so any MCP-capable agent uses memory as native tools with zero glue, plus a plain REST API for everything else.
You send text, not vectors. The server embeds locally, retrieves, reranks, and packs the context.
export TM=https://memory.thinkingdbx.com export TM_API_KEY=tm_live_... # create one in the console, API keys # store a memory $ curl -X POST $TM/v1/remember \ -H "X-API-Key: $TM_API_KEY" -H "Content-Type: application/json" \ -d '{"agent_id":"support-bot","content":{"text":"Customer ACME prefers email over phone."},"mtype":"semantic"}' # recall, intent in, packed and cited context out $ curl -X POST $TM/v1/recall \ -H "X-API-Key: $TM_API_KEY" -H "Content-Type: application/json" \ -d '{"agent_id":"support-bot","intent":"How should I contact ACME?","token_budget":512}'
// register the MCP server with any MCP client { "mcpServers": { "thinkingmemory": { "command": "npx", "args": ["-y", "@thinkingmemory/mcp"], "env": { "TM_API_KEY": "tm_live_...", "TM_BASE_URL": "https://memory.thinkingdbx.com" } } } }
Prefer not to run it yourself? Point your agent at memory.thinkingdbx.com. Lifecycle, bitemporal audit, and per-tenant isolation, fully managed.
Intent in, cited and token-budgeted context out. No vector wrangling, no reranking glue, no prompt stuffing.
Decay, consolidation, and contradiction resolution run continuously. Useful memories rise, stale ones fade.
Row-level isolation, audit trail, and bitemporal history. The things you would otherwise build yourself.
We are onboarding a small group of design partners: teams who use ThinkingMemory on production agents, meet with the founders monthly, and get lifetime free access to ThinkingMemory Cloud. Limited seats.
Clone the repo, run init_db, and your agent has a memory database. Open source, Apache-2.0, on Postgres with local embeddings.
Prefer managed? ThinkingMemory Cloud is live. Sign up, get an API key, and your agent has memory in minutes.
$ git clone github.com/mplusm/thinkingmemory $ cd thinkingmemory && ./init_db.sh ✓ postgres + pgvector ready ✓ local embedder loaded $ tm serve → recall endpoint live on :8080 # remember experience, recall the right context
* Measured on the bundled recall benchmark (eval/run_eval.py): packed context vs dumping the full corpus, with 100% recall@5 of the gold memory. Your numbers will vary with corpus size and token budget.