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.

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://kemory.sekondbrain.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.

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.

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.

Never write credentials, keys or passwords into memory.

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

12 tools

4 tools

1 tool

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.

Capture with Kora
for Chrome

Kemory is the memory; Kora is one way to fill it. Kora is a Chrome extension that 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.

Tools returning s9nmem_* migration errors mean a client is running an outdated configuration. Reconnect it.

Support

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