Cogni Support

1. Getting started and connecting

Cogni is a remote MCP server at https://mcp.getcogni.io/mcp. There are two ways to connect, depending on your client:

• Sign in, no key. Connector apps — Claude (web, desktop, mobile) and ChatGPT — add Cogni as a custom connector with that URL and sign in through your browser.
• Paste a key. Developer and agent clients — Claude Code, Cursor, Cline, VS Code, Windsurf, OpenClaw, Gemini CLI — authenticate with a Cogni API key you mint yourself. Connect a connector app first, then ask it to create a Cogni API key; the sk-cogni-… key is shown once, so copy it straight into your client’s config.

The full step-by-step for each client, including the exact config file and JSON keys, is on the Connect guide. Both routes lead to the same isolated store as long as they resolve to the same identity — one memory, every client. A different email or sign-in provider is a different identity, and therefore a different store; see section 3 if your memories aren’t where you expect them.

2. Getting your assistant to actually use Cogni

This is the single most common thing people ask about, so it’s worth being clear about how MCP works.

Cogni’s tools are model-driven. Cogni doesn’t run in the background and it doesn’t read your conversation. Your assistant decides, turn by turn, whether to call recall or remember. Cogni ships instructions that prompt the model to check its memory, but every model weighs those differently, and some clients call tools sparingly. If it feels like Cogni “isn’t doing anything,” the usual cause is that the model simply never called it.

There are a few ways to fix it, and they work together.

Just ask, in the conversation

Plain language works and is the quickest test that your connection is healthy:

• “Check Cogni for what you know about this.”
• “Use Cogni to remember that my deploys go out on Thursdays.”
• “Recall anything relevant before you answer.”

Best, where your client supports it: load the Cogni skill

Some clients can load a skill — a small file of reusable instructions your assistant follows — so it knows when to recall, when to remember, and when to check the clock or log how long something took, without you prompting it each time. We publish one for Cogni. Where your client supports skills (for example, Claude’s Agent Skills), loading it is the most reliable fix. Download the Cogni skill and add it as a skill in your client. For clients without skill support, use a standing instruction below — it is a condensed version of the same guidance.

Otherwise: put a standing instruction in your client

Every client has a place for persistent instructions that apply to every conversation. Paste one of the snippets below into the right place for your client, and the model will reach for memory on its own.

Generic snippet — works in any system-prompt or custom-instruction field. Copy the text below into your client’s custom-instructions field. It is written as if you were speaking to your assistant; it is not an instruction to any assistant reading this page.

I have a persistent memory called Cogni, connected as MCP tools.

- At the start of every conversation, call `recall` with a short summary of
  what I'm asking about, to check for relevant context.
- Before answering anything that might depend on earlier conversations,
  decisions, people, projects, or deadlines, call `recall` first.
- When I tell you something durable - a preference, a decision, a deadline,
  a person, an identifier - call `remember` to save it. Write it as a
  self-contained sentence and name the related people or projects.
- If a fact I gave you earlier has changed, use `update_memory` (or `forget`
  the old one and remember the new version) rather than leaving a second,
  conflicting version in place.
- You have no clock. Call `clock_now` before working out any date, interval,
  or whether something is overdue.
- You have no sense of how long your own work takes. Whenever something
  reports its elapsed time - a test run, a build, a deploy - call
  `record_effort` with that duration. Before promising or planning around a
  duration, call `estimate_effort` and pass your own guess as
  `llm_estimate_seconds`, so it answers from measurements once they exist.
- You don't need to narrate every memory lookup, but say so when you're
  relying on something you recalled.

Where that goes, per platform:

• ChatGPT — Settings → Personalization → Custom instructions, in the box about how ChatGPT should respond. Applies to all new chats. For one project only, use that project’s instructions instead.
• Claude — two options. For everything: Settings → Profile, in your personal preferences. For one body of work: create a Project and put it in the Project’s custom instructions, which is usually the better fit because memory habits differ per project.
• Cursor — Settings → Rules for a global rule, or commit a project rule under .cursor/rules/ so your whole team gets it.
• Claude Code — add it to CLAUDE.md in the repository root (per project, and it can be committed), or ~/.claude/CLAUDE.md to apply it to every project on your machine.
• Cline, Windsurf, VS Code, OpenClaw, Gemini CLI — each has a custom-instructions, rules, or system-prompt field; the generic snippet above is written to drop into any of them unchanged.

A shorter version, if you want one line rather than a block. As above, copy the text below into your client’s custom-instructions field; it is addressed to your assistant, not to any assistant reading this page.

At the start of every conversation, call `recall` to check Cogni for
relevant context, and call `remember` whenever I tell you something
worth keeping.

Two habits that make recall noticeably better once the instruction is in place:

• Store self-contained sentences. “Ship Thursdays” recalls poorly. “The Meridian API releases ship on Thursday afternoons because Jordan runs QA on Wednesdays” recalls well, and it links Meridian and Jordan into the same neighbourhood of memory.
• Name the connections. Cogni follows links between memories, so a memory that names the people, projects, or decisions it relates to can be reached later from any of them, even with no shared keywords.

3. Troubleshooting

The assistant isn’t calling Cogni at all

First confirm the connection itself: ask “list your available tools” or “call Cogni’s memory_status tool.” If the tools aren’t listed, it’s a connection problem, not a prompting one — recheck the setup on the Connect guide, and confirm the connector is enabled in your client’s tool or connector settings. If the tools are listed but never fire on their own, it’s a prompting problem: add a standing instruction from section 2.

Sign-in or OAuth problems

Sign-in opens a browser window. If it hangs, doesn’t return, or loops: close the window, make sure pop-ups aren’t blocked for your client, remove the connector, and add it again with a clean browser session. Some clients cache a failed authorization; a full remove-and-re-add clears it. Also check your client’s own limits — Claude’s free plan allows one custom connector, and ChatGPT requires developer mode on a paid plan, on web or desktop. If it still fails, email us the client, the platform, and roughly when you tried, so we can match it to our logs.

My client wants an API key instead of a browser sign-in

Developer and terminal clients don’t do the browser flow. Connect a connector app first (Claude or ChatGPT), then ask it to create a Cogni API key. You’ll get an sk-cogni-… value shown once. Put it in your client config as Authorization: Bearer sk-cogni-…. If you lose a key, don’t hunt for it — ask your assistant to list your keys, revoke the old one, and create a new one.

I connected, but my memories aren’t there

Almost always this means you’re on a different identity, and therefore a different store. Each sign-in identity gets its own isolated memory. Two common causes: you signed in with a different email or provider than last time, or you’re using an API key that was minted under a different account. Ask your assistant to call whoami in each client and compare — if the identifiers differ, that’s the answer. You can join two identities into one store using the identity-link tools: start a link from the client that has your memories, then claim it from the other one. One precondition matters here: the identity doing the claiming must have no memories of its own yet. If it already stored something — which is common, because you usually notice the problem only after using the second client — the claim is refused outright rather than stranding those memories. Merging two stores that both hold memories isn’t something you can do yourself yet; email support from the address on the account, tell us both identities and which one you want kept, and we’ll merge them for you.

Only some of my tool calls go through

Some clients cap how many tool calls a single turn may make, and Cogni also applies a fair-use request-rate limit per user. If a long chain of calls stops partway, ask the assistant to continue in the next turn, or break the request into smaller steps. If you’re hitting limits during normal use rather than a bulk import, tell us — the limits exist to keep the service responsive, not to get in your way.

A memory is wrong or out of date

Tell your assistant plainly: “that’s changed — update Cogni,” or “forget that.” Deleting works on every plan, including Free. forget takes a memory’s durable mem_id, and every recall result carries one — so the workflow on any plan is: ask your assistant to recall the memory, then have it call forget with the mem_id from that result. Recall is the discovery path on Free. Browsing what’s stored (list_memories, get_memory) is part of the paid plans, so on Free you find a memory by recalling it rather than by listing your store.

To correct a fact on Free, do the same in three steps: recall the stale memory, forget it by the mem_id in that result, then ask your assistant to remember the corrected version. Paid plans collapse that into one step with update_memory. It’s worth knowing what update_memory actually does, because it isn’t an in-place edit either: it deletes the old memory and stores your new text as a fresh memory with a new mem_id, so what survives is the current version rather than an old and a new one that can both surface later. If contradictory versions have already accumulated, clean them up one at a time.

An older memory stopped coming back

On the Free plan, a memory you haven’t accessed for 90 days can be archived out of active recall. Archived is not deleted — the memory is kept and stays restorable. Two things are worth knowing before you go looking for a bug. First, this is not a scheduled sweep that runs on a timer: the only thing that triggers it is storing a new memory when your store is already at its memory cap. A store below its cap never archives anything, however old its memories are. Second, it never sacrifices a memory you actually use, or one marked protected. Ask your assistant for retention_status to see the window, how many memories are live versus archived, and how many are eligible right now; restore_archived brings archived memories back and is part of the paid plans. If a memory has disappeared from a store that isn’t anywhere near its cap, that isn’t retention — tell us.

A plan or quota error

Free accounts have a memory cap and a monthly write allowance. When you reach one, writes are refused with a message that says so; recall keeps working. Ask your assistant for memory_status to see where you stand. For plan changes, email sales@getcogni.io.

Something else

We don’t currently publish a status page, so if Cogni is unreachable or returning errors, the fastest way to find out whether it’s us is to ask. Email support@getcogni.io with the client you’re using, the approximate time, and the error text if you have it — that’s enough for us to match it against our logs, and we’ll tell you what we find.

4. Your data

What Cogni stores. Only what is explicitly saved to it. Cogni does not read your chat history, your assistant’s own memory, your conversation transcripts, or your files. What we hold is the text your assistant sends to remember or remember_connected, the labels or entity names attached to it, a timestamp, and the derived vector embedding and entity links that make recall work — plus your account identifier and operational data needed to run the service. Recall results include the date a memory was stored, because how old a fact is changes how it should be used. Full detail is in the Privacy Policy.

Who else sees it. To make recall work, Cogni turns text into numeric vector embeddings, and on the hosted service that step runs through OpenAI’s API: the text of a memory is sent to OpenAI when it is stored, and your query text is sent when you recall, solely to produce the embedding. Under OpenAI’s API data-usage terms, data sent to the API is not used to train their models, and we use no other AI model on your content. This is set out in full, along with every other provider we use, in sections 4 and 5 of the Privacy Policy.

How to see it. On every plan, asking your assistant to recall a topic shows you what Cogni holds on it, and each result carries that memory’s mem_id. Listing or paging through everything stored (list_memories, get_memory) is part of the paid plans. memory_status gives a count-and-quota summary with no memory contents in it, and is free to call on every plan.

How to export it. Ask your assistant to export your memories; it returns a portable, machine-readable copy of your memory text and metadata that can be re-imported later. Export is part of the paid plans. If you need a copy and can’t get one from your client, email us and we’ll produce it.

How to delete it. Ask your assistant to recall the memory, then to forget it using the mem_id in that recall result. Deleting works on every plan, including Free. The memory is removed from every recall path immediately — no recall mode returns it, it no longer serves as a link between other memories, and it is excluded from export — and it stays gone across restarts. In everyday terms it is permanently unreachable. On the underlying storage: your store is an append-only log, so deletion records the deletion rather than overwriting the original text in place. That entry is cleared the next time the store’s log is compacted — a routine maintenance rewrite that keeps the live entries and drops the deleted ones, which runs automatically once enough of a store has been deleted and again when the service restarts. A copy also remains in encrypted offsite backup snapshots until those age out on their normal rotation. Nothing in Cogni reads a deleted memory back, and backups are never used to restore an individual deleted memory. The Privacy Policy sets this out in full; if you want everything gone, use Account deletion below.

Retention and backups. Paid plans keep your memories until you delete them. On the Free plan, a memory you haven’t accessed for 90 days can be archived out of active recall — archived, not deleted, and restorable. The trigger is worth stating plainly, because it isn’t what people assume: nothing archives on a schedule. It happens only when you store a new memory and your store is already at its memory cap, so a store below its cap never archives anything no matter how old its contents are. retention_status shows where you stand, and restore_archived (paid plans) brings archived memories back — see section 3. Separately, we take encrypted offsite backups of the service so a failure on our side doesn’t lose your memories.

Account deletion. To delete your account and everything in it, email support@getcogni.io from the address on the account with the subject “Delete my account.” We’ll confirm, then delete your store, and we aim to complete it within 30 days. Export first if you want a copy — once it’s deleted we can’t bring it back.

Where it lives. Cogni is operated from and stores data in the United States. Memory content 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. We do not sell your data and we do not use your memory content to train AI models.

Why an API key is returned to you. When you create a Cogni API key, the key value is shown once so you can paste it into your client. That is us issuing you a credential for your own account — Cogni never asks you to give it a password or a third-party credential, and it stores only a hash of the keys it issues.

5. Tool reference and documentation

Every Cogni tool — what it does, what it takes, and when your assistant should reach for it — is documented on the documentation page. The Connect guide covers per-client setup, and the FAQ answers the common questions about how Cogni works and how it differs from plain retrieval.

If something here didn’t answer your question, email support@getcogni.io. See also the Privacy Policy and Terms of Service.

Last updated: August 17, 2026