Decispher

Integration

MCP Server

One install. Every AI tool your team uses gets live access to your knowledge graph. Cursor, Claude Code, and VS Code Copilot all query the same, always-current context.

Quickstart

Set up the Decispher MCP server in Claude Code in 5 minutes

Three steps: generate a key, register the server, ask a question. Claude Code runs the server via npx, so there is nothing to install.

1. Generate a project-scoped API key. In the dashboard go to Project → Integrations → MCP Server → Generate Key. Copy it now; the full key is shown only once. Grab your DECISPHER_COMPANY_ID from Settings.

2. Register the server with Claude Code. Run:

claude mcp add decispher \
  -e DECISPHER_API_KEY=dsk_your_key_here \
  -e DECISPHER_API_URL=https://api.decispher.com \
  -e DECISPHER_COMPANY_ID=your-company-uuid \
  -- npx -y @decispher/mcp-server

Verify it registered with claude mcp list (or /mcp inside Claude Code). You should see Decispher's tools listed.

3. Ask your first question. In a Claude Code session, just ask, and Claude will call ask_knowledge_base and answer from your team's record, with citations:

> What did we decide about the worker queue, and why?

Decispher → ask_knowledge_base
We use BullMQ over SQS: SQS cold-starts add latency to the worker
fleet, so BullMQ + Redis keeps workers warm.
Captured from #engineering, approved 2026-06-18.  [decision:8f2c…]

That answer came from your decision record, not a guess, and the retrieval is logged with the tokens it saved. Want the same in Cursor or VS Code? Configs are below, or follow the Cursor team-context guide.

What is it?

Your team's knowledge graph, live over MCP

The Decispher MCP Server is an npm package that implements the Model Context Protocol, a standard interface that AI coding tools use to fetch external context at query time. Once installed, any MCP-compatible agent can call Decispher tools to retrieve your team's decisions, constraints, and conventions in real time.

Unlike CLAUDE.md or .cursorrules files, which are static snapshots loaded once at session start, the MCP server serves live data. A decision captured in Slack at 9am is queryable by your agents at 9:01am.

📄

Static files (CLAUDE.md, .cursorrules)

Loaded once at session start. Stale until the next Git sync. No token metering. No per-query freshness.

⚡

MCP Server

Queried on demand. Always current. Receipted per call. Project-scoped isolation. Symbol-graph retrieval.

Why use it?

Because static context files have a freshness problem

A CLAUDE.md committed to your repo was accurate the day it was generated. The next day, your team ships three decisions, one constraint gets superseded, and a new convention gets adopted. The committed file has no idea.

The MCP server solves this by serving context from the live Decispher knowledge graph, the same source of truth your dashboard queries. The agent always gets the current state, not a snapshot from the last Git sync.

Always current

New context captured from Slack or GitHub is queryable immediately, with no commit, PR, or cache invalidation needed.

Project-scoped isolation

A project-scoped API key only returns context units active in that project. Agent for project-A can't accidentally see rejected or irrelevant decisions from project-B.

Symbol-graph retrieval

get_context_for_file matches against function names, type identifiers, and canonical tech labels, not just keyword search or embedding similarity.

Receipted per call

Every MCP call is logged with tokens saved, model used, and project scope. Your dashboard shows exactly what each agent is consuming and what it saves you.

What you get

Measurable token savings, receipted per call

Every MCP call that returns context saves your agent from having to discover that context the slow way, by searching, asking, or hallucinating. Decispher measures this saving on every call and shows you the running total in your dashboard.

Example: single check_intent call

agent query tokens: 240

counterfactual (no MCP): 1,840 ← estimated re-discovery cost

tokens saved (net): +1,600

at frontier model rates: ≈ $0.0048 saved

All 21 tools

One tool for every query pattern

check_intent1 credit

Send a description of what the agent is about to do. Decispher returns conflicting rules AND relevant context units before any code is written. Returns BLOCKED (hard conflict, stop), WARN (tension, proceed with caution), or CLEAR. Call this before every significant change.

decispher.check_intent({ description: "add redis caching to the auth token lookup", files: ["src/auth/token-manager.ts"] })

search_decisions1 credit

Semantic search across all 7 context types. Pass types to scope (e.g. ["constraint", "decision"]) or omit to search everything. Results ranked by relevance to the query and freshness.

decispher.search_decisions({ query: "why BullMQ not SQS", types: ["decision", "rationale"] })

get_constraints1 credit

Fetch all active architectural constraints for the project: the hard rules the agent must not violate. Supports pagination via cursor and a token budget. Call once per session and cache for the run.

decispher.get_constraints()

check_conventions1 credit

Retrieve all active coding conventions. Use to align generated code with team standards before submitting. Covers naming, patterns, library choices, and style decisions.

decispher.check_conventions()

get_context_for_file1 credit

Pass one file path (or up to 10 via filePaths[]). Decispher reads the file from disk, extracts identifiers and symbols, and returns context units whose captured decisions relate to that file or those symbols. Uses hybrid symbol + embedding scoring.

decispher.get_context_for_file({ filePath: "src/auth/token-manager.ts" })

ask_knowledge_base1–8 credits

Ask a natural language question. Decispher retrieves relevant context units and synthesises an LLM answer with source citations. Cost scales with effort mode (Saver 1 / Balanced 2 / Pro 6). Every answer shows which units it drew from.

decispher.ask_knowledge_base({ question: "why do we use HNSW not IVFFlat for vector indexes?" })

list_topicsFree

List all canonical topic slugs available in this project. Free: the discovery primitive. Use this first when you need to explore an unfamiliar area or confirm a topic ID before calling get_context_for_topic.

decispher.list_topics()

get_context_for_topic1 credit

Fetch the curated context cluster for a topic. Returns spine units inline (the always-load CRITICAL rules) plus IDs and titles of expansion units; call get_decision on any of those IDs for the full body.

decispher.get_context_for_topic({ topic: "auth" })

get_decisionFree

Fetch the full body of a specific context unit by ID: title, problem statement, rationale, alternatives considered, affected files, and sources. Use after any tool returns an ID worth deep-fetching. Direct lookup, no LLM.

decispher.get_decision({ decisionId: "0e3f1c2a-bc91-d109-..." })

get_related_context1–4 credits

Walk the knowledge graph around one unit before you change or contradict it: what it supersedes, extends, derives from, documents, confirms, or conflicts with, returned as one bounded subgraph instead of a chain of ID lookups. Depth 1 or 2, filterable by relation type. Units outside your key's project scope appear as relation-only stubs and are never expanded, so a conflict you cannot read is still a conflict you are told about. Deterministic traversal, no LLM.

decispher.get_related_context({ decisionId: "0e3f1c2a-…", depth: 2 })

capture_decisionFree

Write new knowledge back into the team's knowledge base. Use only for durable, reusable knowledge worth recalling next session. If a near-duplicate already exists, the existing unit's ID is returned with alreadyExists: true and nothing is inserted, so an agent re-capturing the same thing is safe rather than noisy. Agent captures are labelled as such so humans reviewing the record can tell them apart.

decispher.capture_decision({ type: "constraint", title: "Use HNSW not IVFFlat for new vector indexes", decision: "...", rationale: "..." })

copy_chat1–8 credits

Compress the current AI conversation into a portable snapshot. Server returns a random clipKey you can share across machines, IDEs, or AI tools. LLM distills a structured resume: goal, status, decisions, code & files, mental model, open questions, alternatives, next steps. Stored in Redis only, never enters the knowledge graph. 7-day TTL. Flat charge per copy.

decispher.copy_chat({ messages: history, title: "Auth refactor" }) // → { clipKey: "dsk-clip-…", summary: "…" }

paste_chatFree

Restore a snapshot by clipKey. The returned content becomes the new session's working memory, so the agent reads it cold and continues exactly where the previous session left off. Always free. Works on any machine and any Decispher-connected AI tool. Returns a graceful empty state if the key is wrong or the snapshot has expired.

decispher.paste_chat({ clipKey: "dsk-clip-…" })

update_context_metadataFree

Patch the lifecycle metadata of an existing unit: expiry, tags, affected files, severity. Or set stillAccurate to reset its freshness clock after re-validating it. Bodies are never edited here; a decision that actually changed must be captured as a new superseding unit. Off by default until an admin enables agent updates.

decispher.update_context_metadata({ contextId: "0e3f1c2a-…", stillAccurate: true })

store_readFree

Read the branch store: the shared working memory for a git branch. Returns the resume header (last state and open questions), staged units awaiting review, recent attributed entries from other agents and humans, and linked knowledge-graph units. Call it at the start of a session on an existing branch to begin warm instead of cold.

decispher.store_read({ repo: "acme/api", branch: "feat/token-refresh" })

store_writeFree

Append an attributed entry to the branch store. entryType drives the resume header: state and handoff replace the last state, question opens one, answer closes one, note is timeline only. Write a handoff before you stop so the next agent picks up exactly where you left it.

decispher.store_write({ repo: "acme/api", branch: "feat/token-refresh", entryType: "handoff", content: "Refresh path done, rotation still open" })

store_listFree

List the branch stores visible to this key: branch, repo, last state, open question count, last activity. Use it to find where work is already in flight before picking up a branch.

decispher.store_list()

store_linkFree

Link the branch to an existing knowledge-graph unit by ID, such as a decision this branch implements or depends on. Linked units then appear by title in every store_read on that branch.

decispher.store_link({ repo: "acme/api", branch: "feat/token-refresh", decisionId: "0e3f1c2a-…" })

session_recordFree

Self-report a noteworthy moment from this session: a non-obvious decision, a constraint discovered the hard way, an approach tried and abandoned, or a clarifying question whose answer shaped the work. The report is staged for a human to promote, never written straight into the record. Use it sparingly for durable knowledge; use store_write for progress notes.

decispher.session_record({ repo: "acme/api", branch: "feat/token-refresh", type: "history", statement: "Tried rotating on every request, hit the provider rate limit" })

remember1–3 credits

Save a durable personal or team memory: a preference, a working style, an environment fact, a team norm. Explicit human requests are saved active; anything the agent volunteers becomes a proposal the owner confirms. Default scope is the user's private memory, and sharing wider is a request an admin approves. Requires Memory to be enabled for your company.

decispher.remember({ body: "Use pnpm, never npm, in this org", userRequested: true })

get_memoryFree

Dereference one memory by ID from a served manifest, returning the full body and provenance. There is deliberately no memory search tool: relevant memory is injected into the session for you, so the agent only ever dereferences.

decispher.get_memory({ memoryId: "b41c7e90-…" })

Installation

One npm package, three config files

The server ships as @decispher/mcp-server. You don't need to install it globally; all three config examples below use npx to pull the latest version automatically.

Cursor setup

Project-scoped or global

Add to .cursor/mcp.json in your project root (scoped to this repo) or ~/.cursor/mcp.json (all projects).

{
  "mcpServers": {
    "decispher": {
      "command": "npx",
      "args": ["-y", "@decispher/mcp-server"],
      "env": {
        "DECISPHER_API_URL": "https://api.decispher.com",
        "DECISPHER_API_KEY": "dsk_your_key_here",
        "DECISPHER_COMPANY_ID": "your-company-uuid"
      }
    }
  }
}

Claude Code setup

Via the Claude Code CLI

Or add directly via the Claude Code UI: Settings → MCP Servers → Add server.

VS Code setup

GitHub Copilot + MCP

Add to .vscode/mcp.json in your workspace root:

{
  "servers": {
    "decispher": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@decispher/mcp-server"],
      "env": {
        "DECISPHER_API_URL": "https://api.decispher.com",
        "DECISPHER_API_KEY": "dsk_your_key_here",
        "DECISPHER_COMPANY_ID": "your-company-uuid"
      }
    }
  }
}

API keys

Company-scoped or project-scoped

Generate keys from your project's Integrations page: Project → Integrations → MCP Server → Generate Key. Keys are shown once, so copy immediately.

Company keydsk_co_…

Returns results across all projects. Use for a personal dev environment where you work across multiple repos.

Project keydsk_pr_…

Returns only context units active in this project. Use for per-repo CI, project-specific IDE config, or agent pipelines scoped to one service.

Required env vars: DECISPHER_API_KEY · DECISPHER_API_URL (default: https://api.decispher.com) · DECISPHER_COMPANY_ID (find in dashboard → Settings)

Credit costs

Pay only for what you query

Per-call costs

list_topicsFreeRead-only namespace discovery, no LLM or vector query
get_decisionFreeDirect ID lookup, no LLM call
capture_decisionFreeWrite-back is free: we want agents recording what they learn
update_context_metadataFreeLifecycle patch or freshness reset, no LLM call
store_read / store_writeFreeBranch working memory, always free
store_list / store_linkFreeBranch discovery and linking, always free
session_recordFreeStaged for human review, always free
get_memoryFreeDereference one served memory, no LLM call
paste_chatFreeRead clipboard, always free, ephemeral cache only (7-day TTL)
check_intent1 creditVector + keyword conflict scan (Saver/Balanced 1 · Pro 2)
search_decisions1 creditSemantic search across all 7 context types
get_constraints1 creditRead-only filtered query
check_conventions1 creditRead-only filtered query
get_context_for_file1 creditSymbol-graph + embedding hybrid
get_context_for_topic1 creditCurated topic cluster with spine inline
remember1–3 creditsEmbeds and fuses before returning: Saver 1 · Balanced 2 · Pro 3
ask_knowledge_base1–8 creditsLLM-synthesised answer: Saver 1 · Balanced 2 · Pro 6
copy_chat1–8 creditsLLM-compresses conversation to clipboard: Saver 1 · Balanced 2 · Pro 4 · Super 8

Ready to wire your agents in?

Request beta access and get your first API key in minutes.

Request Access

Decispher

Documentation

MCP Server

Set up the Decispher MCP server in Claude Code in 5 minutes

Your team's knowledge graph, live over MCP

Because static context files have a freshness problem

Measurable token savings, receipted per call

One tool for every query pattern

One npm package, three config files

Project-scoped or global

Via the Claude Code CLI

GitHub Copilot + MCP

Company-scoped or project-scoped

Pay only for what you query