> ## Documentation Index
> Fetch the complete documentation index at: https://docs.akumi.eu/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP server

> Connect Claude and other MCP clients to your governed memory and knowledge.

Akumi is an [MCP](https://modelcontextprotocol.io) server. Connect Claude, or any client that speaks the Model Context Protocol, and it can recall and store your memory and search your knowledge from inside the assistant, over OAuth, scoped to one organization, metered, audited, and held in the EU.

The server lives at a single endpoint:

```
https://api.akumi.eu/mcp
```

It uses the streamable HTTP transport and authenticates with OAuth 2.1. There is nothing to install and no key to paste: your client registers itself, you authorize in the browser, and you pick which organization to grant access to.

## Before you connect

* **Enable Recall** under **Services > Recall** in the organization you plan to
  connect. Every tool needs it: `recall`, `remember` and `forget` read and write
  facts, and `knowledge.search` reads your documents.
* **Add at least one collection** if you want `knowledge.search` to return
  anything. It also needs the organization to firewall personal data or to have
  accepted external processing, or it fails closed (see [Governance](#governance)).
* You do not create an API key for this. The connection is authorized per user, in the browser.

## Connect your client

Most clients take the same URL, `https://api.akumi.eu/mcp`, and handle the OAuth handshake for you. When the browser opens, sign in, choose an organization, and approve. Here are the common ones.

### Claude Code

Add the server from the CLI:

```bash theme={null}
claude mcp add --transport http akumi https://api.akumi.eu/mcp
```

The first time a tool is used, Claude Code opens the browser to authorize. Run `claude mcp list` to confirm it connected, and `/mcp` inside a session to see the tools.

### Claude Desktop

Open **Settings > Connectors > Add custom connector**, give it a name (`Akumi`), and paste the URL:

```
https://api.akumi.eu/mcp
```

Click **Connect**, authorize in the browser, and pick your organization. The tools then appear in the client's tool menu.

### Cursor

Add the server to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per project):

```json theme={null}
{
  "mcpServers": {
    "akumi": {
      "url": "https://api.akumi.eu/mcp"
    }
  }
}
```

Cursor prompts you to authorize on first use. You can also add it from **Settings > MCP > Add new MCP server**.

### VS Code

VS Code (with GitHub Copilot) reads `.vscode/mcp.json` in your workspace. Note the key is `servers`, and the transport is set explicitly:

```json theme={null}
{
  "servers": {
    "akumi": {
      "type": "http",
      "url": "https://api.akumi.eu/mcp"
    }
  }
}
```

### Any other MCP client

Most clients use the same `mcpServers` object in a JSON config file. Point it at the URL and the client handles registration and OAuth:

```json theme={null}
{
  "mcpServers": {
    "akumi": {
      "type": "http",
      "url": "https://api.akumi.eu/mcp"
    }
  }
}
```

If your client only supports command-based (stdio) servers, put a remote-to-stdio bridge such as `mcp-remote` in front of it:

```json theme={null}
{
  "mcpServers": {
    "akumi": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.akumi.eu/mcp"]
    }
  }
}
```

## The tools

Once connected, the client can call four tools. Memory here is **your own**, scoped to the organization you authorized: the facts you store are yours, not an end-user's, which is the difference from the [Memory](/guides/recall) service on the inference API.

| Tool               | What it does                                                                                                                                                                                    | Needs                                   |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- |
| `recall`           | Read the facts relevant to a query from your memory.                                                                                                                                            | Memory enabled                          |
| `remember`         | Store a new fact in your memory.                                                                                                                                                                | Memory enabled                          |
| `forget`           | Remove a fact from your memory.                                                                                                                                                                 | Memory enabled                          |
| `knowledge.search` | Search your organization's Recall collections. Blends every collection by default; pass `collection` (a slug, or a list of them) to read only those. An unknown slug is refused, never ignored. | Recall enabled, residency condition met |

There is also a `whoami` resource that echoes the organization the connection is bound to, so you can confirm you are pointed at the right one, and a `knowledge-collections` resource listing the slugs `knowledge.search` accepts.

## Choosing an organization

You pick one organization on the consent screen, and the access token is bound to it. A connection only ever sees that organization's memory and knowledge, never another one's.

To switch organizations, reconnect: remove the server in your client and add it again, then choose the other organization at consent. This is deliberate, so a single connection can never quietly reach across organizations.

## Governance

The MCP surface is governed by the same services as the rest of the platform, so it is not a way around your controls.

* **Metered.** Every `recall`, `remember`, `forget`, and `knowledge.search` is metered and appears in your usage, on its own line.
* **Audited.** Every call writes a metadata-only entry to the audit log recording which client called which tool, for which organization, and when, never the content. Review it on **Platform > Audit logs**.
* **Residency, fail-closed.** `knowledge.search` returns your knowledge to a client that may run outside the EU, which is a transfer. It stays closed unless the organization firewalls personal data with the [PII firewall](/guides/pii) or has recorded acceptance of external processing. Nothing leaves the region by accident.

## Good to know

**One connection is one organization.** The token is bound at consent. Reconnect to switch.

**Memory over MCP is yours, per organization.** The `recall`, `remember` and
`forget` tools act on your own facts within the authorized organization, not on a
per-end-user memory. Use [Recall](/guides/recall) on the inference API for
per-end-user facts.

**Capabilities follow entitlements.** A tool only works if the organization has
Recall enabled, and `knowledge.search` also needs a satisfied residency
condition. Without them, the tool reports that the service is unavailable rather
than returning data.