Cursor's Composer is brilliant at any single moment. Then the session ends, and the reasoning ends with it. Knovya is the part that stays — the architecture decision you wrote in October, the postmortem from last sprint, the thread your team pinned about caching strategy. Cursor reaches into the same archive every time you open a file.
Composer reads from your archive. Agent mode cites your ADRs. The decisions your team made last quarter become context the IDE already has, instead of context you copy-paste from another tab.
Cursor speaks MCP — the open standard for AI tools. Adding Knovya is one paste into
~/.cursor/mcp.json and a restart.
{
"mcpServers": {
"knovya": {
"url": "https://mcp.knovya.com/mcp",
"transport": "http"
}
}
}
// OAuth handles sign-in; no API key needed.
Edit ~/.cursor/mcp.json. Knovya appears in every project you open from this
machine.
Drop .cursor/mcp.json at the repo root. Commit it. Knovya scopes to that
codebase only — clean for client work.
From our connectors page, hit Connect to Cursor. We pre-fill the config; you OAuth in.
Composer reaches into Discovery first when you Cmd+K. Read tools fire when you
@knovya a doc. Agent mode unlocks Mesh — when more than one AI is in the room.
Where am I, what’s here. Read-only orientation tools Cursor uses first to map your archive before anything else.
pingworkspacehomepersonacontextsearchschema Open the note. Trace a link. Pull an attachment. Everything below the search bar — the tools Composer reaches when you cite an ADR or a retro.
readexperiencememoryfoldershistorylinksattachments Capture, edit, organize, archive. Agent mode surfaces a confirmation step before changing your archive — destructive ops are gated by user consent.
writeeditorganizedelete When more than one AI is in the room. Agent mode in Cursor talks to Claude in another window — presence, channels, shared attention, consensus voting.
presencechannelscoordinateattentionthoughtscommitteeagentseventsmesh_adminpipelinenotifications Shape the archive. AI rewrites. Templates. Imports, exports, shares. Where Knovya itself becomes a tool Cursor’s agent can wield.
aitemplatesexportimportshare Cursor's Composer is brilliant in any single session. Then the session ends, and what you decided ends with it.
Yesterday you reasoned through the auth migration. You weighed three approaches, picked one, wrote a long Composer thread justifying the choice. Today you open the file again. Composer starts over — same questions, same trade-offs, no memory of what your team already settled.
The intelligence is enormous. The memory is somewhere else — in a Notion page nobody opens, a Slack thread that scrolled away, a half-finished doc in Google Drive. Composer re-derives it from scratch, every time.
Knovya is the part that doesn’t reset. Same archive, every conversation. The reasoning sticks.
↳ Lineage How we got here, in five steps
Five turns. Four years. The doorway between Cursor and your archive didn’t exist until last.
AI starts pair-programming inside the chat window. The IDE is still elsewhere — two tabs, copy-paste in between.
The chat moves into the IDE. Composer ships. Agent mode arrives the year after. The model finally lives where the code does.
An open spec for AI ↔ tools. Any client can talk to any server, the same way browsers talk to web servers. Knowledge becomes portable.
Composer and Agent mode become MCP clients. Filesystem, GitHub, Context7 — every server in the ecosystem — lights up inside the IDE.
Filesystem reads files. GitHub reads commits. Knovya reads your reasoning — ADRs, retros, decisions, customer notes. Cursor stops asking the same questions.
Fetches up-to-date documentation for libraries and frameworks.
Docs lookupPR reviews, issue triage, commit operations from inside Composer.
Repo opsReads and writes local files outside the active workspace.
Local filesChain-of-thought scaffolding for multi-step reasoning.
CoT scaffoldBrowser automation — Cursor drives a real Chromium.
Browser autoYour knowledge graph — decisions, retros, ADRs, customer notes — as first-class IDE context. The reasoning that doesn’t live in the repo.
Decision memoryThey stack. Most Cursor power users run two or three MCPs at once — Filesystem for local reads, Context7 for fresh docs, Knovya for the reasoning. Different layers of the same context.
Where the connector actually shows up — Composer, Agent, the JSON config, the sidebar.
Composer treats Knovya like any source. Type @knovya and search results stream
in, ranked.
Agent mode picks the right tool per step — Discovery, then Read, then writes back the patch. Each call shows up in the chat as it fires.
{
"mcpServers": {
"knovya": {
"url": "https://mcp.knovya.com/mcp",
"transport": "http"
},
"github": { "url": "https://api.githubcopilot.com/mcp/" },
"context7": { "command": "npx", "args": ["@upstash/context7-mcp"] }
}
} OAuth handles sign-in on first call — no API key in the file, no token in your shell history. Restart Cursor and the tool count appears in Settings → MCP.
Each server lists its tool count. Click in to see the manifest — what’s safe, what’s destructive, what scopes the agent has. Audit-friendly by default.
Knovya is the part that doesn’t change between tools. Whichever AI catches your next thought, it’s reading from the same archive Cursor reads.
The morning conversation. Read your decision log. Anthropic-certified install.
VS Code or JetBrains. Agent mode reads RFCs and migration logs from the same archive.
Cascade walks the codebase with the archive open. Reads forward, writes back.
REST + webhooks. For the integration we haven’t pre-built yet — Slack bots, Zapier, custom agents.
Open ~/.cursor/mcp.json (global) or .cursor/mcp.json (per-project). Add a knovya entry with the MCP URL — the snippet we show above is the whole thing. Restart Cursor. The tool count appears in Settings → MCP.
OAuth 2.1 with PKCE handles the sign-in on first call — no API key in the config, no token in your shell history. Most setups take under two minutes.
It depends on what's missing. For documentation lookup, Context7. For repo and pull request operations, GitHub MCP. For local file ops outside the workspace, Filesystem. Knovya is the only MCP server that brings your knowledge graph — decisions, retros, ADRs, customer notes — into Cursor as first-class context.
They stack. Most Cursor power users run two or three MCPs at once; Knovya is the layer that holds your team's reasoning.
knovya_search, knovya_read, knovya_experience, and twenty more tools directly from a prompt. Agent mode invokes them automatically when the model decides it needs context.Context7 indexes public package documentation. Filesystem reads local files. Knovya is your private knowledge graph — the decisions, the sprint retros, the customer interviews, the architecture you wrote.
Different layers of context. Most Cursor power users run two or three MCPs at once; Knovya is the layer that holds your team's reasoning.
Open Composer in the morning, push from Agent mode at night. The code is yours. The reasoning is shared. The doorway closes behind you and opens at the next session.
Or jump to the install snippet, then see pricing.
Open MCP standard · OAuth 2.1 + PKCE. Free tier. 14-day Pro trial. No credit card to start.