Show HN: Cogni: MCP memory for LLMs, with no LLM in the retrieval path

wpnews.pro

#

More than memory.

Memory that reasons.

Cogni is an MCP server that gives any LLM a connected memory that grows as you work. Its entity-graph spreading activation follows the chain of facts a plain vector store can't reach, so your agent reasons over what it remembers instead of just looking things up.

scattered across separate documents

same store, same eight rows

Chain-recall@8: the share of a four-document chain a single recall call surfaces — Cogni finds 3.4 of the 4, a vector store finds 2.6. Not answer accuracy. Deterministic, no model in the loop, on the shipped recall path at the settings every account gets: 5 chains × 3 seeds against 300 distractor documents. Both sides return the same eight rows, so none of the margin is bought with extra context. Every number, and where we tie or come second.

✓ Works with any model: Claude, GPT, Gemini, local ✓ No LLM and no GPU in the retrieval path ✓ No vector DB to run ✓ No API key to paste

A vector store retrieves. Cogni connects. #

The difference is one clean, measured capability: entity-graph spreading activation for cross-vocabulary retrieval — questions whose answer shares no words with the question, where a single similarity lookup scores zero no matter how wide you set k.

Ask something whose answer lives in a document sharing no vocabulary with the question — a part number that leads to a batch that leads to a name. In a single retrieval call Cogni follows the entity chain. A similarity search matches the first link and has nothing to take it to the second, so on one call it scores zero.

Measured end to end over MCP with GPT-4o answering, one recall call, on Cogni's default mode at the settings every account gets — mean of 14 runs, 45 questions each. The zero is the structural part: turning Cogni's own graph off reproduces it exactly, on the same store with the same embeddings and the same prompt, so the difference is the traversal and nothing else.

Let the model keep calling instead of stopping at one, and a vector store recovers to near-parity — it eventually stumbles onto each link. That is the honest shape of the result, and it is still the argument: the answer is reachable either way; what differs is how many round trips you pay for it.

Cogni returns the chain on the first call. The alternative gets there by iterating, and every iteration is another request, another context window, and another bill from whichever model you are using.

The gap widens with the length of the chain: each extra hop is one more round trip a similarity search has to discover, and one Cogni already walked.

A full vector search runs underneath the graph. Cogni's default recall runs a dense-vector search and the spreading graph, then returns both — so adding Cogni does not take away the retrieval you already had. It is a floor you can check in one call, not a promise: on needle-in-a-haystack recall the two are level at 1.00 to 1.00, at every haystack length we measured.

Works with any model. No LLM in the loop. #

No language model and no GPU anywhere in the retrieval path.

Nothing rewrites, summarises, or judges your memories on the way in, and nothing is generated on the way out. Recall is a deterministic graph traversal: the same question over the same store returns the same rows, every time, with no second model's opinion in between. That is why the advantage travels — it lives in the retrieval, not in the model. And it is why a small model gains the most: clean connected context was the piece it was missing.

To be straight about the ceiling: GPT-4o with the entire corpus in context scores 0.99, so this is not parity — it is a small local model doing work it could not do at all before, on a fraction of the context. Feed that same 8B the exact chain by hand and it scores 0.97, which says the remaining gap is retrieval rather than reasoning.

Multi-hop deductive benchmark, 12 chains × 3 seeds against 250 distractor documents, llama3.1:8b answering, measured through the shipped retrieval path at the settings every account gets — the results file records no deviation from them. The vector baseline was given 15 rows to Cogni's 8. Because Cogni's tools are called by your model, real-world consistency depends on the model and how it's prompted. Why results may vary.

Recall stays flat as memory grows. Bury a fact in a history that grows to 32,000 words and Cogni returns it first, every time — at a fixed eight rows per query, whatever the history costs to hold.

Effectively a rolling, always-on context window at a constant per-query cost, on a model that could never hold it all at once.

that tie is on the compare page, along with the check that makes it mean something.

What else it does that a vector store can’t #

A full vector search runs underneath the graph, so adding Cogni does not take away the retrieval you already had. We test that rather than claim it: a release this month replaced roughly half the rows a recall returns with graph results, and on needle-in-a-haystack the answer stayed at rank one in every single question.

Every memory is timestamped as it is stored, and recall can be pointed at a moment or a window — "what did I know as of last Tuesday?", "only what I picked up in March". Ask for a window and Cogni searches inside it.

Similarity search has no time model of its own — it ranks on closeness of meaning, so ordering and point-in-time questions depend on whatever timestamp index someone bolted on beside it. Cogni stamps every memory as it is stored and applies the window before it ranks, so a dated question is answered from what was in the window, not from the closest wording anywhere in the store.

Cogni runs no LLM of its own and no GPU. The advantage is in the retrieval, so it holds whichever model you point at it — and it costs the same whether that model is frontier or 8 billion parameters on your desk.

See it follow a chain #

Ten memories, none of them written for this question. The answer is two facts away and shares no words with what was asked. Here is what each retrieval actually returns — same store, same question, same eight-row budget. The vector column is shorter because a relevance floor drops matches too weak to be worth returning; widening the budget adds more of those, not the answer.

hop 0The Meridian rollout is blocked until the Atlas migration finishes.
hop 0Standups for the rollout moved to Tuesdays at 9.
hop 0Priya Raman is the delivery lead for the Meridian rollout.
hop 0The Helios pilot wrapped up two weeks early.
hop 1Devon Okafor runs the platform infrastructure team.
hop 1Marcus Webb asked to be looped in on anything customer-facing.
hop 1The design review for the new onboarding flow is on the 14th.
hop 1Quarterly planning is the first week of next month.

hop is how many connections Cogni followed to reach that memory. Everything at hop 1 was found by traversing the graph, not by matching the question.

1The Meridian rollout is blocked until the Atlas migration finishes.
2Priya Raman is the delivery lead for the Meridian rollout.
3Marcus Webb asked to be looped in on anything customer-facing.
4The Atlas migration is owned by the platform infrastructure team.

It stops here. Row 4 is one connection away from the answer — the platform team is named, and the person who runs it is not. Nothing in the question resembles “Devon Okafor”, so similarity search has no step left to take.

A real run, not an illustration: a live Cogni store at default settings, the same production embeddings, and the same ordering an MCP client receives. Reproducible from tools/make_demo_transcript.py. The vector column is Cogni’s own dense channel with the graph switched off, so both sides share the embedder and differ only in the traversal.

What it unlocks #

Mention an allergy once, and six weeks later Cogni still surfaces it before the model books the restaurant. Deadlines, preferences, and people stay connected across every session, not lost between chats.

Trace a connected case across a thousand documents that share no keywords, then write the brief a flat search can't assemble — the chain is reached by following entity links, not by matching the question.

Illustrative use cases. The measured results behind them are on the compare page.

How it works #

Cogni runs no LLM. Your client is the brain. It exposes a handful of tools over MCP and does the connected retrieval a vector store can't. The retrieval substrate is fully deterministic.

Store a fact, note, or observation. Entities are linked into a graph.

Spreading-activation retrieval across everything you've told it, with a full vector search running underneath — so adding Cogni doesn't take away the retrieval you already had. Optional point-in-time and windowed recall.

Replace the model's human-speed guess with the agent's own measured median.

Rank candidate plans by how long they'll actually take, so the agent picks the genuinely faster path.

Log a real duration so future estimates get sharper.

One entity graph, spanning everything it remembers. That graph is the difference between remembering and reasoning.

Connect in 60 seconds #

No cluster, no GPU, no vector database. Cogni is one remote endpoint, https://mcp.getcogni.io/mcp

, and connecting takes about a minute. There are two ways in, depending on your client.

Sign in, no key

Connector apps: add Cogni as a custom connector with the URL, then sign in. No key to paste — OAuth handles it.

Signing in: sign in from inside the Claude or ChatGPT app, and when the Cogni sign-in screen opens choose

“Email me a code”— a one-time code signs you in, no password to remember. If you ever forget a password, use the email-code option rather than “reset password.”

Claude (web, Desktop, mobile)⌄ #

Settings → Connectors → Add custom connector.
Paste https://mcp.getcogni.io/mcp

, leave the OAuth fields blank, click Add.

Click Connect and sign in when the browser opens.

Free plan allows one custom connector; paid plans allow several.

ChatGPT⌄ #

Turn on Developer mode (Settings → Connectors → Advanced).
Add a connector, paste https://mcp.getcogni.io/mcp

, sign in.

Plus, Pro, Business, Enterprise or Edu, on web/desktop (not the mobile app or Free).

Paste your key

Dev & agent clients sign in with a Cogni API key you mint yourself. Connect a GUI app (track 1), then ask it "create a Cogni API key" — it shows an sk-cogni-…

key once. Drop your tool's config below and paste that key into the Authorization: Bearer

header.

Claude Code⌄ #

One command in your shell:

claude mcp add --transport http --scope user cogni \
  https://mcp.getcogni.io/mcp \
  --header "Authorization: Bearer sk-cogni-YOUR_KEY"

Cursor⌄ #

Add to ~/.cursor/mcp.json

, then Settings → Tools & MCP → enable cogni.

{
  "mcpServers": {
    "cogni": {
      "url": "https://mcp.getcogni.io/mcp",
      "headers": { "Authorization": "Bearer sk-cogni-YOUR_KEY" }
    }
  }
}

Cline⌄ #

MCP Servers → Configure MCP Servers, add under mcpServers

:

{
  "mcpServers": {
    "cogni": {
      "type": "streamableHttp",
      "url": "https://mcp.getcogni.io/mcp",
      "headers": { "Authorization": "Bearer sk-cogni-YOUR_KEY" }
    }
  }
}

VS Code · needs Copilot⌄ #

Create .vscode/mcp.json

, then start the server and use it in Copilot Chat's Agent mode.

{
  "servers": {
    "cogni": {
      "type": "http",
      "url": "https://mcp.getcogni.io/mcp",
      "headers": { "Authorization": "Bearer sk-cogni-YOUR_KEY" }
    }
  }
}

Windsurf⌄ #

Add to ~/.codeium/windsurf/mcp_config.json

(note the key is serverUrl

), then refresh in Cascade.

{
  "mcpServers": {
    "cogni": {
      "serverUrl": "https://mcp.getcogni.io/mcp",
      "headers": { "Authorization": "Bearer sk-cogni-YOUR_KEY" }
    }
  }
}

OpenClaw⌄ #

One command (v2026.5.12+ for header support):

openclaw mcp add cogni \
  --url https://mcp.getcogni.io/mcp \
  --transport streamable-http \
  --header "Authorization: Bearer sk-cogni-YOUR_KEY"

Gemini CLI⌄ #

Add to ~/.gemini/settings.json

(the key is httpUrl

):

{
  "mcpServers": {
    "cogni": {
      "httpUrl": "https://mcp.getcogni.io/mcp",
      "headers": { "Authorization": "Bearer sk-cogni-YOUR_KEY" }
    }
  }
}

Requires a paid Gemini API key or a Code Assist Standard/Enterprise license (per Google's June 2026 change).

Then load the Cogni skill. Connecting gives your assistant the tools; the skill teaches it when to use them, so it recalls before answering and remembers what matters without you asking each time. It is one small file. Download the skill · how to add it to your client.

One memory, every client. OAuth or key, GUI or terminal — every way you sign in lands on the same isolated store. Sign in on Claude Desktop, mint a key for Cursor and your terminal, and they all read and write the one memory. Your agent remembers the same things everywhere you work.

Pricing #

Start free — no card required. Upgrade to Pro whenever you want more room, and cancel any time from your account page.

✓ Full spreading recall + effort and time tools
✓ One memory, shared across all your AI apps
✓ Generous personal limits (memory + monthly usage)
✓ Email support

Get started free

✓ Everything in Free
✓ 50× the limits — 50,000 memories, kept indefinitely
✓ Inspect, edit, and prune your memory graph
✓ Export and import your whole memory store
✓ Archive and restore memories, including anything set aside when a full store made room

Upgrade to Pro

✓ Everything in Pro
✓ Shared team memory, private + shared spaces, set up with you during onboarding
✓Per-member read/write roles — each space is a physically separatestore, so a space you can’t read is never queried, not filtered out afterwards - ✓ Named support contact
- SSO and directory provisioning
- Per-space audit logging
- On-prem or VPC deployment with local embeddings, so no memory text leaves your network

Scoped and built as part of an engagement rather than shipped today. Tell us what you need and we’ll price it.

Get in touch

FAQ #

Isn't this just RAG?⌄ #

No. Cogni includes a full vector search and adds an entity graph it traverses. RAG retrieves the closest match; Cogni follows the connections between facts. Where a question and its answer share no vocabulary, that is the difference between scoring zero and answering at all. And because the vector search runs underneath, adding Cogni doesn't take away the retrieval you already had — on needle-in-a-haystack recall the two are level at 1.00.

Which models does it work with?⌄ #

Any of them. Cogni runs no LLM — it's a memory and retrieval server your model calls over MCP. A recall request carries a query, not a model identity, and Cogni does the embedding itself, so the same question returns the same rows whichever model asked. Our headline retrieval numbers are measured with no answering model at all; where one is needed we use GPT-4o and Claude Opus 4.8, and both give the same shape of result.

Do I need a GPU or an API key?⌄ #

No. Cogni runs no language model and no GPU — recall is a deterministic graph traversal, and it does the embeddings for you. You connect your MCP client with a Cogni API key you mint in seconds, or just OAuth in the Claude app. No vector database to run, no OpenAI key to paste. (On the hosted service the embedding step itself calls OpenAI's API; nothing generates, rewrites, or summarises your memories — see the privacy policy.)

Where does my data live?⌄ #

In an isolated, per-user store on the hosted tier, and never used to train anything. Data is encrypted in transit using TLS, and encrypted at rest at the storage layer by our infrastructure providers, each of which maintains a SOC 2 Type II attestation. For teams that need data to never leave their environment, a self-hosted tier with local embeddings is on the roadmap.

What actually makes it different?⌄ #

A deterministic entity-graph spreading-activation engine, modeled on how memory works in the brain. Most memory products answer a query with a single similarity lookup; Cogni links facts into a graph and traverses it, reaching a connected chain a single lookup can't. What is unusual is not the graph — several good products build one — but that ours is built and walked with no language model at either end. Nothing reads, rewrites or judges your memories, so recall is the same traversal every time. The method is patent-pending.

Why might my results vary?⌄ #

The numbers here are reproducible benchmark results with our setup. In practice, Cogni's tools are called by your model over MCP, so how consistently it checks its memory depends on the model and how it's prompted. Ideal usage is a recall at the start of every turn. Cogni already prompts the model to do that, and where your client supports a loadable skill you can drop ours in to make it more consistent. A tighter always-on integration for Claude Code is in development.

Where are the standard memory benchmarks, like LoCoMo?⌄ #

We run them, and they are on the compare page with their method. The short version: measured on the path a real account is served, with both sides returning the same eight rows, Cogni and plain vector RAG are level on needle-in-a-haystack, on a continual-learning scenario and on LoCoMo.

These benchmarks measure recall from one long conversation or one document — the case a plain vector search already handles well, and which Cogni has built in. They don't test the cross-document, cross-vocabulary or time-scoped retrieval that is Cogni's real advantage, so we lead with the benchmarks that do.

One we deliberately don't publish: benchmarks that slice a novel or a paper into fixed-size chunks and store each chunk as a memory. That is not what an account holds, and we measured that the entity graph such chunks produce is meaningless — its strongest links are words like table. A number from that setup describes our chunker, not the product, and we take the same view of it whether it flatters us or not.

How do I get started?⌄ #

Create a free account and connect in about a minute — get started, then add Cogni to Claude, ChatGPT, or your terminal. No card needed for Free.

Give your agent memory that reasons. #

Create a free account and connect your first AI app in about a minute.

Free plan, no card needed. Questions? We're here.

source & further reading

getcogni.io — original article