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 one to reach for: it carries hooks that make memory get used rather than merely be available. The manual entry under Connect a local client works too, and gives you the same tools with none of the hooks.

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. Seven hooks, none of which need remembering — five on by default, and the two that could surprise you ship 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.

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. Prompt recall is on by default and sends the 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. Capture is off unless you set it, because it uploads your own turns. Context injection sends only your credential, and the approval, 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 quiet by design: with no credentials and no Kemory server they no-op rather than erroring, so a broken setup looks like an idle one. The plugin prints a short setup notice the first time and 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.

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.

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 28 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.

18 tools

7 tools

3 tools

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 →

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.