Connect your agent to Knownbase.

claude mcp add --transport http knownbase https://knownbase.dev/mcp

{
  "mcpServers": {
    "knownbase": {
      "url": "https://knownbase.dev/mcp"
    }
  }
}

The endpoint

Every client below uses the same URL:

https://knownbase.dev/mcp

There are two ways to authenticate against it. Use whichever your client supports.

Option A: sign in with OAuth (recommended)

Claude, ChatGPT, Cursor, and most modern MCP clients can sign a human in interactively instead of asking for a pasted key. Give the client the endpoint URL above and nothing else — it discovers the rest itself and opens a Knownbase login/consent screen where you pick which workspace to grant access to.

• Claude.ai / Claude Desktop — Settings → Connectors → Add custom connector → paste the URL.
• Claude Code (CLI) — claude mcp add --transport http knownbase https://knownbase.dev/mcp. The first tool call opens a browser to finish sign-in automatically.
• ChatGPT — Settings → Connectors → Add connector → paste the URL.
• Cursor — add {"url": "https://knownbase.dev/mcp"} (no headers) to mcp.json; Cursor opens a browser on first use.

You can review and revoke connected apps any time from Settings → Connected apps. If a client shows a raw error or "can't connect" on this URL, it likely doesn't support remote MCP servers yet — use an API key instead.

Option B: paste an API key

Works with every MCP client, including ones that only support static config. Sign up for a free workspace, then open Settings → Workspace & MCP and generate a key (it looks like kb_..., and is shown in full only once).

{
  "mcpServers": {
    "knownbase": {
      "url": "https://knownbase.dev/mcp",
      "headers": {
        "Authorization": "Bearer kb_YOUR_KEY_HERE"
      }
    }
  }
}

A key can optionally be marked read-only (queries only, no writes) or scoped to a single project (every note operation restricted to that one project) — both set when you create it in Settings.

MCP tool reference

Once connected, these are the tools your agent can call. All are workspace-scoped: an agent only ever sees the notes its key or OAuth grant can reach.

• get_context — the one to start with. Returns a project's current state in a single call: its summary and agent instructions, active constraints, canonical decisions, current status, open items, notes relevant to a query, recent changes, and any unresolved conflicts — ranked and packed to a token budget (detail: lean/balanced/deep, or an explicit maxTokens). Superseded and historical claims are excluded by default, so what comes back is what is true now rather than everything that was ever true.
• get_changes_since — the one to resume with. Start with an exclusive ISO since timestamp, then persist the returned opaque cursor. Results are oldest-first and safely page across notes sharing the same millisecond. Current notes are the default; historical memory and deleted tombstones require explicit opt-ins. Each entry is excerpt/token bounded and reports the source-backed document action and current state rather than guessing what a change meant.
• remember — the write counterpart to get_context. Give it content and a type; it derives the title, checks the project for near-identical or contradicting memories, and reports what it did (created, updated, duplicate, or conflict) instead of silently storing a second copy of something already known. Supports an idempotencyKey so a retried call is safe.
• checkpoint — the one to end substantial work with. Send a concise summary plus structured decisions, discoveries, changes, failed approaches, open/resolved items, and next actions — never the raw conversation. Knownbase folds each item through the same duplicate/conflict checks as remember, keeps only the latest checkpoint summary current, preserves resolved notes as history, and returns an itemized result if one element fails. Pass an idempotencyKey for safe retries.
• search_notes — search notes by text, and filter by project, tag, status, or last-modified date. Lean by default; pass includeBody:true for full content inline. (Semantic search is coming soon; semantic:true is accepted today and falls back to keyword results, and workspace_info's plan.semanticSearch tells you whether it is live yet.)
• get_note / get_notes — read one note, or up to 50 by id in one call, full body included with resolved links and backlinks.
• upsert_note — create or update a note. Set memory (type, importance, status, supersedes) so get_context can rank and age the note correctly; naming an id in supersedes marks that note superseded so the old claim stops being returned as current. Updates are partial: omit a field to leave it unchanged, so "just fix the tags" can't silently wipe the body. Notes are identified by id, not title: omitting id always creates a new note, even if the title matches one you already have — look the id up first (search_notes/get_notes) if you mean to update.
• delete_note — move a note to trash (soft delete, restorable from the dashboard).
• list_note_revisions / get_note_revision — browse or fetch a note's prior versions.
• list_projects — every project in the workspace with note counts by status.
• rename_project / rename_tag — bulk-rename (or remove) across every note in one call.
• workspace_info / usage_summary — plan, limits, current usage, and this credential's own access.
• backup_project — full content for one project, returned inline for your agent to persist wherever you like.

backup_now is a reserved compatibility name for instance operators and is refused for every tenant credential. Use backup_project for agent-accessible project export, or export the full workspace from Settings.

Every tool call is workspace rate-limited at 300 requests/minute, with tighter limits on expensive compound operations such as checkpoint. Tenant write tools (including remember, checkpoint, upsert_note, and bulk renames) are refused for read-only keys with a clear error, not a silent no-op.

REST API

The dashboard itself runs on a JSON REST API under /api/*, authenticated the same way — a browser session, or the same Authorization: Bearer kb_... key you use for MCP. If you'd rather script against notes directly instead of going through an agent, the core routes include GET/POST /api/notes, GET/DELETE /api/notes/:id, GET /api/notes/:id/revisions, POST /api/remember, and POST /api/checkpoint.

MCP is the primary, stable interface for programmatic access (the tool names and shapes are a compatibility contract we don't break); the wider REST surface is what the dashboard uses internally and may evolve alongside it.