Memory your AI
doesn't forget.

Before you connect

You need a SeKondBrain account. Create one, and reach every setting named on this page, at kemory.sekondbrain.ai — that is the dashboard. Sign-in is handled by SeKondBrain's identity service; Kemory never sees or holds a password.

There is nothing to install for a web AI. Local clients need a config-file entry, shown below. Every user connects to the same address; there is no per-tenant URL and nothing to provision before you begin.

Transport. Streamable HTTP, JSON-RPC 2.0, single endpoint. Protocol revisions 2024-11-05 through 2025-11-25 are negotiated on initialize. Server-sent events, server-initiated messages and persistent sessions are deliberately not implemented — every request is stateless and self-authenticating.

Connect a web AI

For Claude, ChatGPT, Perplexity, Manus and any other AI that supports remote MCP connectors.

1. Open your AI's connector settings and choose Add custom connector.
2. Paste the server address above.
3. Your browser opens a SeKondBrain sign-in page. Sign in and approve.
4. The connector reports the tools it found. You are connected.

There is no key to copy, paste or keep safe. The connector holds a short-lived token that refreshes itself and that you can revoke at any time from your Kemory dashboard.

Connected is not the same as remembering: a model decides for itself when to call a tool, and an AI given one with no instruction about it will usually not reach for it. Optimise your AIs for Kemory is the standing instruction that fixes that, and where to paste it.

Connect Claude Code

Claude Code can connect two ways. The plugin is the recommended path: it carries hooks that make memory get used rather than merely be available. Connecting the server on its own works too, and gives you the same tools, prompts and resources with none of the hooks — see Server only below.

1. Install it, in a Claude Code terminal:

/plugin marketplace add SeKondBrainAILabs/kemory-plugin
/plugin install kemory@kemory
/reload-plugins

/reload-plugins is not optional — until it runs, the plugin's commands do not exist yet. Nothing is downloaded beyond the plugin itself: its bundled MCP entry launches a script inside the plugin, so there is no binary to install and nothing to put on PATH.

2. Sign in.

/kemory:login

It prints one link. Open it, approve in the browser, and the credential is written for you — nothing to install, nothing to paste. It writes the same file the CLI does, so a CLI installed later finds you already signed in. On a headless machine, export KEMORY_API_KEY="kemory_..." instead.

3. Restart Claude Code fully — quitting the window is not enough — then confirm:

/kemory:status

Two checks have to pass: credentials resolve, and the API accepts them. The same output prints which server will serve the tools and how capture and context injection are configured. /mcp then shows which Kemory server Claude Code is actually talking to. Context injection begins with your next session, because the hook that performs it runs at session start.

What the plugin adds

Connected is not the same as remembering. Tools sit unused unless something prompts the model to reach for them; that prompting is the whole of what the plugin contributes. It loads your context at session start, recalls under every prompt, and captures the session as it goes. Six hooks, none of which need remembering — five on by default, and the store nudge ships off:

It also ships /kemory:login, /kemory:status, and a skill covering how to recall, rate, store and phrase memories so semantic search can find them again. That skill is the standing instruction from Optimise your AIs, already written and kept current — with the plugin installed you do not need to paste it into CLAUDE.md yourself. The server's prompts arrive with the plugin too, under plugin-namespaced names: /mcp__plugin_kemory_kemory__enhance and /mcp__plugin_kemory_kemory__save-session.

Auto-approval of read-only Kemory tools, a status line and an in-app panel live in a separate, optional add-on, kemory-panel (/plugin install kemory-panel@kemory). Without it, read-only Kemory tools ask for permission like any other tool.

Every environment variable, what each hook sends, the surfaces that do and do not have plugins, and what to do when nothing seems to happen: the plugin documentation. Source: SeKondBrainAILabs/kemory-plugin.

Run one server, not two

There are three ways to give Claude Code the Kemory tools, and they stack silently. Two servers means two copies of every tool in every request — wasted context, and no way to tell which lane a result came from. Pick one:

You do not have to police this yourself: the bundled entry stands down when this machine already has a server for the same Kemory, and says so rather than starting and exposing nothing. The hooks are unaffected either way — they call the API directly. The one case it cannot detect is a claude.ai connector, which lives inside Claude and is invisible from a shell; disable the bundled entry under /mcp if you use it.

What leaves your machine

Two hooks transmit anything, and both are on by default. Prompt recall sends the redacted text of each prompt to your Kemory instance as a search query — it skips prompts under 12 characters and anything starting with /, ! or #, so slash commands are never sent. Session capture sends a bounded, redacted digest of your own turns, never file contents or tool output, and stores it as a private memory; KEMORY_AUTO_CAPTURE=0 turns it off. Context injection sends only your credential, and the rating and store-nudge hooks make no network calls at all. The full per-hook policy, with the redaction rules and the local files the plugin keeps, is in the plugin documentation.

If nothing seems to happen

The hooks fail open by design: with no credentials or no Kemory server they print one short warning and carry on rather than erroring or blocking the session, so a broken setup can look like an idle one. The setup notice then stays silent for 24 hours rather than nagging.

Run /kemory:status — it names which check failed. Unknown command: /kemory:login means the plugin is installed but not loaded yet; run /reload-plugins. No credential means nothing was exported into the environment Claude Code started from and no browser login is stored. A rejected one means it expired or was revoked. Tools present but no context at session start is the config-file case — a key inside an MCP config file authenticates the tools, and the hooks never read MCP config. The full troubleshooting table covers the rest.

Server only

To connect the server without the plugin:

claude mcp add --transport http kemory https://api.kemory.s9n.ai/mcp/v1

Then run /mcp, choose kemory → Authenticate, and sign in in the browser. You get the tools, the prompts as /mcp__kemory__enhance and /mcp__kemory__save-session, and the resources under @kemory: — but none of the hooks, so nothing is recalled or captured unless the model decides to call a tool. Do not add this alongside the plugin; see Run one server, not two above.

Connect a local client

For Claude Desktop, Cursor, Cline, Windsurf, Warp, Codex, Gemini CLI and any other client that reads MCP servers from a config file. Claude Code has a plugin instead — see Connect Claude Code.

These clients authenticate with an API key sent as an X-API-Key header. Create one from Dashboard → Keys. It is shown once.

The entry below is exactly what a local client needs. Read it before you connect anything — this is the whole surface.

{
  "mcpServers": {
    "kemory": {
      "type": "http",
      "url": "https://api.kemory.s9n.ai/mcp/v1",
      "headers": {
        "X-API-Key": "kemory_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

Restart the client fully after editing — quitting the window is not enough. Ask it to list your Kemory namespaces; a response means authentication, agent registration and permissions are all green.

A key inherits the organisation of the person who created it, so an agent holding one stays inside your tenant. Keys can be listed and revoked from the dashboard, and revocation takes effect on the next call. Never commit one.

There is also a command-line tool that writes this entry for you, using a browser login instead of a key in a file — useful if you are wiring several clients on one machine. See the Kemory CLI.

Making an AI actually use memory

Most clients treat a tool as something to reach for when asked. Put this in your project instructions and it becomes the first thing checked instead. The Kemory plugin ships this as a skill, so plugin users can skip it.

Optimise your AIs for Kemory has the same instruction sized for every field it has to fit in, and names where that field lives in each AI.

You have Kemory memory tools available.

At the start of each session: call kemory_list_namespaces, then
kemory_recall_memory on the current topic.

Write a memory immediately when: I state a preference or a way of
working, we make a decision, or we learn something non-obvious about
this codebase or domain. Tell me what you wrote and to which namespace.

Do not write credentials, keys or passwords into memory unless I ask you to.

Use Kemory from
the Claude API

The Claude API's MCP connector can call Kemory's tools from a Messages API request, with no MCP client of your own. Pass a Kemory API key as the server's authorization_token:

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-client-2026-09-15" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 4096,
    "messages": [{"role": "user", "content": "What did we decide about the release process?"}],
    "mcp_servers": [{
      "type": "url",
      "url": "https://api.kemory.s9n.ai/mcp/v1",
      "name": "kemory",
      "authorization_token": "<KEMORY_API_KEY>"
    }],
    "tools": [{"type": "mcp_toolset", "mcp_server_name": "kemory"}]
  }'

The connector uses tools only, so the prompts, resources and cards described below do not apply on this path. With this beta header a response can begin with an mcp_tool_listing block; send the assistant message back unchanged on the next request. Keep the key on your server, never in client-side code.

Quickstart

Write one memory, then read it back in a session that has never seen it.

1. Write it

Ask your AI: "Remember that I prefer imperative-mood commit messages, no emoji. Put it in user:preferences." It calls kemory_store_memory and tells you the namespace it used.

2. Read it back

Quit the client entirely and reopen it — a new chat is not enough, the point is to cross a process boundary. Then ask: "What is my commit-message preference?" It calls kemory_recall_memory and answers correctly.

That is the whole product. Everything below is detail.

The tools

Kemory exposes 31 tools, all prefixed kemory_. Every one carries a title and MCP behaviour annotations, so your client can tell reading from writing from deleting before it runs anything.

19 tools

4 tools

8 tools

Saving a session: capture, then refresh the summary

Two write tools work as a pair.

kemory_capture_session stores discrete items the user has confirmed — at most 10 per call, each with its content, an existing namespace and a content_type, and the call requires user_confirmed: true. It does not take a conversation window or a transcript: the model picks the items, shows them to you, and sends only those. An optional session_id tags every item so it counts towards that session's summary.

kemory_consolidate_session brings a session's summary up to date and returns it. Kemory already keeps a summary of every session automatically: it is rebuilt as memories carrying the session id arrive, and older exchanges are folded into a rolling digest. Consolidate refreshes both on demand (before /compact, say) and returns the summary for each namespace the session wrote to. It stores no new memory and never changes or deletes the session's memories; they age through normal decay into the archive, where search can still find them. Run it twice and the second call reports already_current.

Ask and Enhance use these session summaries: when a result comes from a session, its summary is added to the background the answer is grounded in.

The save-session prompt below runs both in order.

When a save updates a memory you already had

If you save something very close to a memory you already have, Kemory updates that memory instead of keeping two near-copies, and the save reports it. The earlier wording is not thrown away: it is kept in the memory's history, and kemory_get_history returns it under displaced_revisions.

kemory_restore_version puts that earlier wording back. It takes the memory id and the revision id (the save names it as dedup.previous_version_id). The wording it replaces is kept in history in the same step, so nothing is lost, and the response's previous_version_id undoes the restore. Use it when the two were meant to stay different. It needs write access to the memory.

Prompts, resources
and cards

Tools are not the whole surface. Kemory also offers MCP prompts, which hosts surface as slash commands, and resource templates, which hosts surface as @-mentions. These are rolling out server by server; a server that does not offer them yet simply shows none.

Prompts

In Claude Code: /mcp__kemory__enhance <request>, /mcp__kemory__save-session and /mcp__kemory__cards off. With the plugin the server is plugin-namespaced, so the names are /mcp__plugin_kemory_kemory__enhance and /mcp__plugin_kemory_kemory__save-session.

Resources

A signed-in resource list also shows each of your projects individually. A memory or project you cannot see reads exactly like one that does not exist, so a resource never confirms that something is there. In Claude Code, type @kemory: and pick.

Cards in chat

Cards are rolling out behind a feature flag. Hosts that support MCP Apps — Claude on the web and desktop, ChatGPT, VS Code — render recall results and "memory saved" confirmations as interactive cards instead of plain text.

Cards stay out of the way of the conversation:

• One line until you open it. Every card starts as a single line, such as "Used 5 memories · from Claude, ChatGPT" or "Saved · project:kemory" with Undo. Open it to see the detail; lists (memories, sources, the two sides of a conflict) page one at a time as a carousel.
• No more than two per turn. A third card in the same turn takes no space; its result still reaches the assistant as text. The saved card, which carries Undo, always shows.
• Nothing to show, no card. A recall that found nothing shows no card. Each result says Why this: — how strong the match is, which AI's chat it came from, and how many passages agree.
• First card, a short welcome. The first card you ever get, in any AI, opens with a five-slide introduction to Kemory, the Chrome extension and the web app, and ends with a choice of how cards should show up.

Choose how cards show up: open, collapsed to one line (the default) or hidden, for every AI or for one app — for example open in claude.ai and hidden in Claude Code. Set it in Kemory's Settings → Kemory cards in your AI chats, with the cards prompt above, or by asking your AI ("turn off Kemory cards"), which calls kemory_settings. A change applies from the next card; reconnect Kemory or refresh its tools if an empty space still shows where a hidden card was.

• Recall card. Results grouped by conversation: each chat's title, Kemory, AI and date once, the best passage first and the rest a click away, with the best overall marked Best match. Thumbs up or down tells Kemory whether a result helped; thumbs down asks why (not relevant, out of date, duplicate). Open chat and Open in Kemory open the item inside its own Kemory, and the Kemory label opens the Kemory itself. Forget sits behind the ⋯ menu, needs a second click, and is not offered on memories shared with you.
• Saved card. Says plainly what happened: saved, updated a memory you already had, already in your Kemory, or not saved. A brand-new memory offers Undo (second click to confirm). An update shows the earlier and the new wording side by side, with Restore previous, which kemory_restore_version carries out and which can itself be undone.
• Conflict card. After kemory_resolve_conflict, what was kept and what was replaced, side by side. Keep both or Keep the other one instead undo the decision through kemory_reinstate_memory; each needs a second click, and nothing is deleted.
• Answer card. A kemory_ask answer with how well it is grounded in your Kemory, and the sources it used, each opening in its own Kemory.
• Overview card. For kemory_list_projects, kemory_plan_usage and kemory_get_namespace_summary: your Kemories at a glance (totals, recently active, largest), your plan usage, or one Kemory's summary.

Cards are self-contained and make no network requests of their own; their buttons act through your host's ordinary tool calls, under the same connection and permissions. Hosts without MCP Apps, Claude Code among them, show the same text results as before.

Authentication

Two paths, one authorisation model.

OAuth 2.1 with PKCE — web AIs

Authorisation is handled by SeKondBrain's identity service. Clients register dynamically, so there is nothing to configure. You are redirected to sign in, you approve, and the client receives a short-lived access token and a refresh token. Kemory never sees your password. No long-lived credential exists anywhere on this path.

API keys — local clients

A key is minted from an authenticated dashboard session, displayed once, and stored hashed. It carries your organisation and identity. Present it as X-API-Key. Revoke it when the machine or agent is retired.

Whichever path issued it, a credential resolves to the same authorisation context — a user, an organisation, and an agent identity — and every tool call is checked against it before it runs.

Revoking access

Dashboard → Connectors lists every agent connected to your account, with the client it came from and when it last called. Revoke one and its next request returns 401.

Scoping, namespaces
and sharing

This is the part worth reading twice, because it determines what other people can see.

Organisation isolation is structural

Every query against tenant-scoped data carries an organisation filter applied beneath the API layer, not by the calling code. A request cannot read across organisations, and no tool, transport or client setting changes that.

Within an organisation, you are the default boundary

Memories you write are yours. Colleagues in the same organisation do not see them by default, and neither do their agents.

Namespaces are how you organise memory

A namespace is a label you choose — they are free-form. Conventions that work well:

Sharing is explicit

A memory becomes visible beyond you when it is written to, or promoted into, a namespace your team can read. Nothing is promoted automatically. kemory_promote_memory is the tool that does it, and it is a write — so a client that asks before writing will ask before sharing.

If you are unsure whether something would be visible to a colleague, kemory_check_access answers the question without changing anything.

What agents can see

An agent sees exactly what the person who connected it can see — no more. Two agents connected by the same person share that person's memory. Two agents connected by different people do not.

Benchmarks

Kemory scores 89.6% — 448 of 500 — on the LongMemEval-S oracle benchmark, run against the live production deployment. That is end-to-end answer accuracy: retrieve, generate, then judge the answer against the reference. It is not a retrieval-recall figure, which is the number most memory systems publish and is not the same thing.

The method, the per-category breakdown, the run-to-run variance and the four caveats that matter when comparing it are all set out in full — along with how to reproduce it.

Read the benchmark method and results →

A second benchmark measures cost rather than accuracy. Replayed over 1,314 real sessions, Kemory's tiered context sends 72.2% fewer reader tokens than re-sending the full conversation on every turn — and more than full history on sessions of five exchanges or fewer. The saving lives in long sessions, and the sample is dominated by one account; both are set out in full.

Read the context-compaction method and results →

Capture with Kora's
Chrome extension

Kemory is the memory; Kora is one way to fill it. Kora is SeKondBrain's Chief of Staff AI, and her Chrome extension captures your conversations with ChatGPT, Claude, Gemini, Perplexity and Manus as you have them, keeps them in your browser, and syncs them into Kemory — so a chat you had in one AI becomes a memory any connected AI can recall.

It keeps what the host platforms eventually drop: full message text and structured blocks — code, tables, reasoning, citations, artifacts — uploaded and generated files, inline images, and conversation metadata. It groups related chats across tools by topic, so your React hooks thread in ChatGPT and your React state thread in Claude land in the same place.

Local first

Conversations are captured into browser storage first, and sync only to the Kemory you connect — your SeKondBrain account's, or a self-hosted instance you point it at. They go nowhere else.

Connecting is the sign-in

Choose your environment and Sign in with SeKondBrain. That single sign-in also connects Kemory: a per-install key is issued for you in the background and the connection indicator turns green on its own — there is no separate key to paste. An Advanced mode still accepts a pair code, a pasted key, or a custom URL for manual and self-hosted setups.

What reaches Kemory

Captured chats become memories in your account, routed into namespaces automatically — a chat with no routing signal lands in an inbox namespace and is sorted from there. Once in Kemory they behave like any other memory: kemory_recall_memory and the rest return them, scoped to you, from any AI you have connected.

Your data

Kemory stores memory content, the namespaces and metadata you attach to it, and the vector embeddings computed from it. Where you connect a capture surface, it stores the conversation content that surface sends. Account identity comes from SeKondBrain sign-in.

Memory content is processed by third-party language models for enrichment, compression and embedding. Which providers, what is retained, how long, and how to have material erased are set out in full in the privacy policy.

kemory_delete_memory is a soft delete: the memory stops being returned by any read tool. The privacy policy describes what the audit trail retains afterwards and how to request complete erasure.

Errors and limits

Tool failures come back inside a successful JSON-RPC response with isError: true and a typed message, rather than as an HTTP error — an AI can read the message and adjust.

Calls using the old s9nmem_* tool names return Unknown tool — the prefix was retired in August 2026 and no longer resolves. Something is still naming the old tools, and it is usually a standing instruction or rules file written before the rename rather than the connection itself. Change those names to kemory_*; reconnecting on its own will not fix it.

Memory storage, search and MCP tool calls are governed by your plan limits rather than metered inference. Where usage limits do apply — the Kora features that run inference we pay for — they are set out in the Kemory Fair Usage Policy.

Support

Kemory is built by SeKondBrain AI Labs. We own and operate the API, the domain and the infrastructure this connector reaches.