Connector guide

Connect Kumiho Memory to Claude

Kumiho Memory gives Claude a memory that survives the conversation. Connect it once and Claude starts each conversation knowing who you are, how you like to work, and what you settled last time.

At a glance

Server URL: https://mcp.kumiho.cloud/mcp
Transport: MCP Streamable HTTP (no SSE)
Authentication: OAuth 2.1, authorization code + PKCE (S256)
Tools: 18, all scoped to your own workspace
Team alternative: Workspace API key in an x-api-key header
Requires: A paid Kumiho Cloud workspace (from $7/month)

What it is

Most memory tools store text and hope similarity search finds it again. Kumiho stores a graph: every memory is a typed node — a decision, a preference, a fact, a correction — linked to the things it is about and to the reasoning that produced it. Recall follows those links, so asking "why did we choose Postgres here?" returns the decision, the rationale, and the alternatives that were rejected.

The connector at mcp.kumiho.cloud is a Model Context Protocol resource server. It holds no database of its own: every request is authenticated, scoped to your workspace, and passed through to the Kumiho graph behind it.

When you contradict an old memory, Claude supersedes it rather than accumulating two conflicting versions. When you ask Claude to forget something, it retires the memory so it stops being recalled.

Connect in the Claude apps

Start from the Connectors area on Claude web or desktop. Connected services are also available on supported mobile and Cowork surfaces.

1
Open Customize → Connectors.
2
If Kumiho Memory is available in the directory, select it and connect. Otherwise, add a custom web connector with the server URL above.
3
Sign in to Kumiho in the window that opens and approve the connection.
4
Start a new conversation and ask "what do you remember about me?"

Team and Enterprise owners may need to enable the connector for their organization before members connect with OAuth. For clients that support custom headers, see the API-key alternative below.

Add the Kumiho Memory skill (claude.ai)

The connector gives Claude the memory tools. The Kumiho Memory skill tells Claude when to use them: when to recall, what is worth saving, how to handle the session_required retry, and never to store credentials. With it, memory works throughout a conversation rather than only when you ask.

On claude.ai and in Claude Desktop chat, Claude does not currently receive a connector’s server instructions, so uploading the skill is how Claude gets that guide there. Claude Code and Cowork get it automatically from the Kumiho Memory plugin, so there is nothing to upload.

Before you start

The Kumiho Memory connector is already connected, as described above. The connector needs a paid Kumiho Cloud workspace.
A Claude plan that includes skills: Free, Pro, Max, Team or Enterprise.
Code execution is turned on. On Free, Pro and Max, check Code execution and file creation under Settings → Capabilities. On Team and Enterprise, an owner manages it under Organization settings → Skills.

1
Download the skill. Upload it as a zip: if your browser unpacks it, compress the kumiho-memory folder again.
Download kumiho-memory-skill.zip
2
In Claude, open Customize → Skills. Click +, then Create skill → Upload a skill, and choose the zip.
3
Turn the kumiho-memory skill on in your skills list.
4
Start a new chat and ask "What do you remember about me?"

The zip (5.8 KB) holds a single file, kumiho-memory/SKILL.md, written in plain Markdown. Read it before you turn the skill on, as you should with any skill you download. View SKILL.md on GitHub

On Team and Enterprise plans, an owner can provision the skill for everyone by uploading the same zip under Organization settings → Skills.

Connect in Claude Code

One command. Claude Code runs the OAuth flow in your browser on first use.

claude mcp add --transport http kumiho-memory https://mcp.kumiho.cloud/mcp

Add --scope user to make the connector available in every project rather than the current one.

To remove it again:

claude mcp remove kumiho-memory

What happens on first connect

Claude discovers where to authenticate

The server answers an unauthenticated request with a pointer to its protected-resource metadata, which names control.kumiho.cloud as the authorization server. No configuration on your side.

You sign in to Kumiho

A Kumiho consent screen opens. Sign in with your Kumiho account, and the screen shows which client is asking and where it will redirect you. Have a paid Kumiho Cloud workspace ready before connecting.

You pick a workspace

If you belong to more than one Kumiho workspace, you choose which one this connection uses. The access token carries that workspace, and every call is filtered by it.

Claude gets a scoped token

The connection is granted the memory scope, plus offline_access so Claude can refresh without sending you back through sign-in. Nothing else on your Kumiho account is reachable through it.

The 18 tools

Every tool carries a title and a read-only or destructive hint, so Claude — and you — can tell at a glance what a call will do. None of them reach outside your own workspace.

Read-onlyWritesWrites · can supersedeDestructive

Memory

Reading from and writing to your long-term memory graph.

kumiho_memory_engageRead-only

Recall relevant prior memories and source references for an authorized memory task.

kumiho_memory_recallRead-only

Semantic search over the memory graph for a need described in natural language.

kumiho_memory_retrieveRead-only

Search stored memories by query and context.

kumiho_memory_storeWrites · can supersede

Write one memory with its type and content.

kumiho_memory_reflectWrites · can supersede

Capture several typed memories at once — the normal way something settled gets written down.

kumiho_memory_consolidateWrites · can supersede

Fold this conversation's working buffer into long-term memory and clear the buffer.

kumiho_memory_decomposeWrites · can supersede

Split an overloaded memory into typed entities, facts and relationships so later recall can bridge through them.

kumiho_memory_space_profileWrites

Summarise what a memory space contains and how it is being used.

Knowledge graph

Browsing the workspace the memories live in.

kumiho_list_projectsRead-only

List the projects in the workspace.

kumiho_get_spacesRead-only

List the memory and knowledge spaces in a project.

kumiho_search_itemsRead-only

Search knowledge items by name, kind or context.

kumiho_get_itemRead-only

Read one knowledge item and its metadata.

kumiho_get_revision_by_tagRead-only

Read a specific tagged revision of an item.

kumiho_get_provenance_summaryRead-only

Where a piece of knowledge came from and what it was derived from.

kumiho_create_spaceWrites

Create a new space to organise memories.

kumiho_deprecate_itemDestructive

Retire a memory from normal recall. Earlier data is retained; this is not permanent deletion.

Conversation buffer

Short-term working memory for the conversation you're in.

kumiho_chat_getRead-only

Read this conversation's working memory buffer.

kumiho_chat_clearDestructive

Discard this conversation's working memory buffer.

Why four write tools are marked destructive

store, reflect, consolidate and decompose all carry a destructive hint. Storing a capture can move an existing memory's published tag onto a new revision, consolidate clears the conversation buffer as it folds it in, and decompose can demote a fact that a newer one supersedes. Earlier revisions stay in history — nothing is erased — but the memory Claude recalls next time may not be the one it recalled last time, and that is worth a confirmation prompt.

What is deliberately absent

The Kumiho SDK defines 63 tools; the connector profile is a curated 18. Project and space deletion, revision deletion, bundle management, edge surgery and the git-dependent code tools are not exposed — and the server refuses a call to any tool outside the profile, so hiding them from the tool list is not the only thing keeping them unreachable.

How memory is scoped

Per user, when you connect with OAuth

Your access token names one workspace and one user inside it. Every backend call is filtered by that pair. Another member of the same workspace cannot reuse your token, your conversation buffer, or the handles the server caches for your calls.

Per workspace, for long-term memory

Memories live in the workspace, not in a chat window. That is the point: connect on your phone in the morning and what Claude learned is there in Claude Code that evening — and in the Claude Code plugin, which uses the same workspace.

Shared, when an admin connects with an API key

When a supported client authenticates with a workspace API key, everyone using that key shares its workspace identity. That is the point of a team memory, and it is worth stating plainly: it is not per-user isolation.

Known limitation: one conversation, one buffer

The four buffer tools — reflect, consolidate, chat get and chat clear — need to know which conversation they belong to. Claude does not send a conversation identifier to a remote MCP server, so the connector issues one instead: the first buffer call of a conversation comes back as session_required with a freshly minted id and touches no memory, and Claude retries with that id and reuses it for the rest of that conversation.

Issued ids are bound to your authenticated identity, so one cannot be borrowed across accounts or workspaces. But the separation between two of your own conversations rests on Claude carrying its issued id and not reusing it elsewhere. If it does reuse one, two conversations running at the same time share a single working-memory buffer.

The memory graph is scoped to the workspace. If buffers mix, a consolidation can save context from the wrong conversation. Check summaries before saving important context; clearing a buffer does not delete memories already stored in the graph.

Review, export, forget, disconnect

Review

Everything the connector writes is visible in the Kumiho dashboard — memory by memory, with the revision history behind each one. You can also ask Claude what it remembers about a topic and it will tell you, sourced back to the memories it read.

Export

Export your metadata, graph and relationships as JSON from the dashboard or through the API. Portability is a documented right, not a support request.

Forget

Ask Claude to forget something and it calls the forget tool after confirming with you — the memory is retired and stops being recalled. To remove data outright, delete the memory or the workspace from the dashboard; the Legal page describes what deletion covers.

Disconnect

Remove the connector in Claude under Customize → Connectors, or run claude mcp remove kumiho-memory. That removes the connector from that client; it does not necessarily revoke an already-issued token. It does not delete your memories, deliberately: reconnecting brings them back. Delete them from the dashboard if that is what you want.

API-key alternative for supported clients

Claude Code and other MCP clients that support custom headers can use a workspace API key. Calls made with the same key share its workspace identity. The standard Claude app connection uses OAuth.

1
In the Kumiho dashboard, open API Keys and create a key. Copy it — it is shown once.
2
Use an MCP client that supports a custom x-api-key header, such as Claude Code.
3
Configure the server URL and pass the key through the client’s x-api-key header setting. Do not paste it into a chat.
4
Keep the key in your local environment or the client’s credential settings, then connect.

Deleting the key in the dashboard disconnects everyone within about a minute — the server checks each key against the control plane and caches the answer for no longer than that.

The same key works in Claude Code:

claude mcp add --transport http kumiho-memory https://mcp.kumiho.cloud/mcp \
  --header "x-api-key: $KUMIHO_API_KEY"

Hosted connector vs the Claude Code plugin

The hosted connector is the lite tier: it works everywhere Claude does, and it cannot run code on your machine. The Claude Code and Cowork plugin is the pro tier, and stays that way — a remote server has no hooks, no repo, and no filesystem of yours. Both read and write the same memory graph.

	Hosted connector	Claude Code plugin
Where it runs	Kumiho's servers	Your machine, in a managed virtualenv
Claude apps, Cowork, mobile	Yes	No — Claude Code and Cowork only
Local Python install	None	Yes, set up for you
Tools exposed	18, curated	63
Recall at the start of a conversation	Model-initiated — Claude calls engage, guided by the server instructions (on claude.ai, by the Kumiho Memory skill)	Automatic — a SessionStart hook injects memory before the first token
Decision Memory over a git repo	No — there is no checkout on a hosted server	Yes
Backfill from past sessions	No	Yes
Dream State consolidation	Not in v1	Yes
Self-hosted Community Edition backend	No	Yes
Memory graph	One workspace, shared with the plugin	The same workspace

Plugin install guide

Data handling

The connector receives the arguments of the tool calls Claude makes — the text being remembered, and the natural-language query when recalling. It does not receive your conversation. If Claude never calls a memory tool, nothing about that conversation reaches Kumiho.

Claude decides what is worth remembering, and writes a memory when something is settled. Tell it not to store something and it will not. Send it only what you mean to store: the tools are not a vault for passwords, tokens or recovery codes, and the server instructions and the Kumiho Memory skill tell Claude to refuse those outright.

What Kumiho stores, how long it keeps it, where it lives, how to export it and what deletion covers are all set out on the Legal page. That page is the authority; this one does not restate it.

Read the Legal page

Questions about the connector: support@kumiho.io. Security reports: security@kumiho.io.

Ready to connect?

Create a Kumiho account, add the connector, and Claude starts remembering.

Create an account Pricing