Integrations

Connections

Kijito speaks MCP, so it plugs into the client you already use. Where MCP does not reach, a REST API does. Both talk to the same account memory, so what one client remembers, another recalls. Setup differs by client - the table below says which paths are verified today.

Connection status

We only call a client verified when a current, founder-independent check passes end to end. Everything else is marked honestly.

Client	Status	Transport	Auth
Claude Code	Verified	MCP	oauth
REST API + scoped keys	Verified	REST	api-key
Claude desktop & web (MCP connector)	In testing	MCP	oauth
Generic MCP host	Protocol-compatible	MCP	oauth
Codex CLI	In testing	MCP	oauth
Local models via an MCP-capable host	Protocol-compatible	MCP	local
ChatGPT connector & OpenAI Apps	Planned	MCP	oauth

Verified A current end-to-end check passes without founder intervention. In testing Actively being validated; not yet a continuous green check. Protocol-compatible The protocol supports it, but Kijito does not continuously test this client. Planned Designed or on the roadmap; not generally available yet.

The connector

There is one hosted endpoint, and it is a Streamable HTTP MCP server:

mcp-url

https://api.kijito.ai/mcp

Use that URL exactly. A trailing-slash or /sse variant will not work - Kijito serves a single modern MCP transport, and that is the only hosted one.

MCP is an open standard, so Kijito is protocol-compatible with any MCP client. But the configuration - where the server is registered, how sign-in works, and how tools are discovered - is different in every client, so follow the specific steps below rather than assuming one recipe. The connect page has the exact files to copy.

Claude Code — verified

Two files in your project root, then restart the session. Claude Code opens a browser to sign in on first connect.

.mcp.json

{
  "mcpServers": {
    "kijito": {
      "type": "http",
      "url": "https://api.kijito.ai/mcp"
    }
  }
}

.claude/settings.local.json

{
  "enableAllProjectMcpServers": true
}

Missing the second file is the most common reason the tools never appear. Without it the project's MCP servers are defined but not enabled, so the session starts cleanly and the agent simply has no Kijito tools.

Other MCP clients — testing or protocol-compatible

These speak MCP and can point at the same connector URL. They are being validated or are protocol-compatible rather than continuously tested - if something does not work, the REST API below always does.

Cursor: add the server to ~/.cursor/mcp.json, then reload Cursor.
Claude desktop & web: add Kijito as a remote MCP connector in settings and complete the OAuth sign-in.
Codex CLI: register the Streamable HTTP server in the Codex MCP configuration.
VS Code, Cline, Continue, Goose, Zed: add a remote MCP server with the URL above (Zed uses context_servers).
Local / open-weight models: any MCP-capable host can reach Kijito. Using a local model does not make the hosted service operator-blind - the memory service is still hosted. The operator-blind path is running the decryption off our servers - Enterprise on-premises, or a local helper you run - both on our roadmap.

~/.cursor/mcp.json

{
  "mcpServers": {
    "kijito": {
      "url": "https://api.kijito.ai/mcp"
    }
  }
}

The REST API — verified

Every route lives under https://api.kijito.ai/api, and every route is also served under a version prefix. Integrations should call the /api/v1 paths.

Sign in once to get an access token, then send it as a Bearer header on every call. The access token is a JWT valid for one hour. For anything long-lived, mint a scoped API key instead.

# Sign in and capture the access token from the response body.
TOKEN=$(curl -s https://api.kijito.ai/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]", "password": "your-password"}' \
  | jq -r .access_token)

Scoped API keys

A kjt_-prefixed bearer token, scoped to a least-privilege subset of your own data and optionally set to expire. The scopes are memory.read, memory.write, memory.curate, and memory.dream. Keys are minted from a full login session; a scoped key cannot mint another.

mint-key.sh

# The secret is shown exactly once, at creation. Save it now.
curl https://api.kijito.ai/api/v1/auth/tokens \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "ci-writer", "scopes": ["memory.read", "memory.write"], "expires_in_days": 90}'

The full endpoint list, request shapes, and error codes are on the API reference.

One account, many clients

Point every client at the same server URL and sign in with the same account. What one client remembers, another recalls. Through an MCP client, each REST endpoint is a tool with the same name, dispatched over the same account memory with the same isolation.

If writes start failing

A new account is capped at a lower limit until you verify your email, which is an anti-abuse gate rather than the tier. Verify to lift it to the full allowance - up to 10,000 memories during alpha. If you are seeing a 429 and your email is already verified, you may have reached your plan's memory cap or the per-minute write-rate limit; GET /api/v1/usage reports both.

Next: API reference →Security & trust →