Memory your AI
doesn't forget.

Before you connect

You need a SeKondBrain account. 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 a local client

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

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.

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.