Hub · Connectors Integrations / Windsurf · Cascade · MCP

Cascade reads your code in flow. Knovya holds why your team wrote it.

Windsurf was one of the first AI-native IDEs to ship MCP — Cascade has called external servers since 2025, well before VS Code's Agent mode caught up. Cognition AI's 2025 acquisition added SWE-1.5 (13× faster than Sonnet 4.5), Codemaps, and Memories on top. Speed plus context.

Cascade's built-in tools cover your repo: file ops, terminal, the Memories that learn your patterns. What they don't cover — the ADRs, the customer interviews, the retros — that's Knovya. One mcp_config.json entry, every Cascade workflow.

34/100 Knovya tools fit in Cascade's 100-tool budget · ~third, room to spare
2025 First wave of MCP-native IDEs · alongside Cursor
Free · Pro · Pro Plus · Teams · Enterprise — all tiers
The install moment

One mcp_config.json. Every Cascade workflow that calls a tool.

Windsurf reads MCP servers from ~/.codeium/windsurf/mcp_config.json — same root key (mcpServers) Claude Desktop and Cursor use. Add Knovya once; Cascade calls it the same way it calls GitHub or Playwright.

Path I

MCP Marketplace

Click the MCPs icon in the top-right of the Cascade panel (or Settings → Cascade → MCP Servers). Search Knovya, click Install. The marketplace handles the config file; OAuth handles sign-in. The fastest path.

Path II

Command Palette

Cmd/Ctrl+Shift+P → Windsurf: Configure MCP Servers. Paste the Knovya block under mcpServers, save, fully quit Windsurf, reopen. Cascade picks up the new tools on the next chat session.

Path III

Manual config file

Edit ~/.codeium/windsurf/mcp_config.json directly (Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json). Same shape Claude Desktop uses — paste the Knovya entry, restart, done. Useful for shared team configs in version control.

Behind the door

Same archive, 34 tools, organized for the conversation.

Cascade reaches into Discovery first when you ask "refactor this with the patterns we already use." Read tools fire when it cites past ADRs. Write tools save the outcome as a structured retro — with your approval. The same 34 tools that Claude and Cursor use; Cascade reads them the same way, just faster (SWE models pair well with cheap context lookups).

  • 0 Discovery 7 tools

    Where am I, what's here. Read-only orientation tools Cascade calls before guessing — workspace scope, schema, context for a topic. Pairs especially well with Memories — Cascade's 48-hour learned patterns plus Knovya's structured archive.

    pingworkspacehomepersonacontextsearchschema
  • 1 Read 7 tools

    Open the note. Trace a link. Pull an attachment. Where Cascade's flow shines — pull a whole ADR chain alongside the actual source files (and Codemaps render on everything in scope), ask the agent to find the inconsistency.

    readexperiencememoryfoldershistorylinksattachments
  • 2 Write 4 tools

    Capture, edit, organize, archive. Save the Cascade session as a structured ADR, tag it, file it. Cascade confirms before destructive ops — your archive doesn't change without you approving the plan first.

    writeeditorganizedelete
  • 3 Mesh 11 tools

    When more than one model is in the room. Cascade hands a research finding to Claude in Claude Code, or to Cursor's Composer in another window — presence, channels, shared attention, consensus voting. Multi-model workflows without losing context. Disable these on the per-tool toggle if you're solo and need budget for other servers.

    presencechannelscoordinateattentionthoughtscommitteeagentseventsmesh_adminpipelinenotifications
  • 5 Transform 5 tools

    Shape the archive. Convert a Cascade session into a structured ADR. Apply your team's template. Export to Markdown for review. Where Knovya itself becomes a tool Cascade can wield mid-task.

    aitemplatesexportimportshare
The problem

Cascade reads your code in flow. Knovya holds why your team wrote it.

Cascade shipped with a strong default kit — file read and write, terminal commands, the Memories that learn your patterns over 48 hours, Codemaps for visual structure, and Fast Context (swe-grep) retrieving relevant code 10× faster than standard agentic search. Pair that with the official MCP Marketplace's GitHub, Slack, and Postgres servers and the repo + tooling layer is covered.

What the kit doesn't cover: the architecture decision your team made six months ago that the code now reflects. The customer interview that flipped the spec. The retro from the last incident that explains why the timeout is 30 seconds and not 10. The reasoning behind the code lives somewhere else — usually a wiki the IDE doesn't index, a markdown file in another repo, a Slack thread that decayed past the search window.

Knovya is the part Cascade reads about your team's decisions. Same archive across every Windsurf surface — Cascade in the editor, Cascade in the 40+ plugin IDEs, multi-step flows that pause for your approval. The repo holds the code; Knovya holds the why.

↓ §5 Lineage · How Cascade got an MCP layer, in five steps

Lineage

How Windsurf got an MCP layer.

Five steps from "free Copilot alternative" to "Cognition's agentic IDE that reads any MCP server."

  1. 2023

    Codeium launches as the free Copilot alternative.

    Free AI code completion for VS Code, JetBrains, and 30+ other editors. No subscription, no credit system, no paywall. Builds a reputation among developers who don't want to pay $10/month to Microsoft. Multi-IDE plugin reach becomes the brand's signature differentiator.

  2. 2025 · late

    Codeium becomes Windsurf — the agentic IDE.

    The rebrand isn't cosmetic: Windsurf ships Cascade, a planning agent that reads across a whole repo, edits multiple files, runs the terminal, and pauses for approval at checkpoints. One of the first AI-native IDEs to ship MCP support natively — alongside Cursor, ahead of VS Code Copilot.

  3. 2025 · Dec

    Cognition AI acquires Windsurf for ~$250M.

    The biggest AI dev-tools M&A deal at the time — Windsurf at $82M ARR, 350+ enterprise customers, 210 employees. Cognition (the team behind Devin, the autonomous coding agent) signals a future direction: deeper Cascade ↔ Devin integration, more autonomy. Google takes a separate licensing deal on the underlying tech.

  4. 2026

    SWE-1.5 + Codemaps + Memories ship.

    Cognition brings proprietary models: SWE-1.5 (950 tokens/sec, 13× faster than Sonnet 4.5, 6× faster than Haiku 4.5), all 0-credit. Codemaps render visual structure of any codebase. Memories learn architecture patterns over 48 hours. Windsurf ranks #1 in LogRocket's AI Dev Tool Power Rankings — ahead of Cursor and Copilot.

  5. 2026 · today

    Knovya is the MCP server Cascade calls about your team.

    One ~/.codeium/windsurf/mcp_config.json, every Cascade workflow, one archive of what your team decided. 34 tools fit comfortably in Cascade's 100-tool budget. Cascade reads the repo at SWE-1.5 speed; Knovya holds the reasoning.

First mover

Cascade's toolset is broad. Each tool covers one shape. Knovya is the one that covers your team's writing.

Built-in Cascade tools

File read and edit, terminal commands, codebase search, the Plan/Approve/Execute loop. Cover the inner loop — read code, edit code, run code, see what broke. SWE-1.5 makes them fast (10× faster context retrieval via swe-grep). Don't reach outside the workspace.

Repo-local

Memories & Codemaps

Cascade learns architecture patterns and coding conventions over 48 hours; Codemaps render visual structure. Powerful for "what does this codebase look like" — limited for "why did the team decide it should look this way." Implicit, not explicit.

Implicit memory

GitHub MCP server

Available via the Marketplace (and pre-configured in many setups) — issues, pull requests, repo metadata, code search. Fits the Cascade workflow naturally; uses ~26 of the 100-tool budget. Doesn't read what's outside GitHub.

GitHub-scoped

Playwright / Postgres / Slack MCPs

Browser drives, database query, Slack search. Operational layer that lets Cascade reach beyond the editor — query staging DB schema before refactoring, screenshot a regression, pull a Slack thread that mentioned the bug. Reactive, not reflective.

Operational

Custom internal MCPs

Your team's deploy MCP, your CI MCP, your design-system MCP. Marketplace + manual config support both — Windsurf Teams adds custom registries with admin whitelist (regex-matched server IDs). Useful, narrow scope per server.

Internal tools

Knovya for Cascade

Structured archive — decisions, retros, ADRs, customer interviews, postmortems — exposed as 34 MCP tools (about a third of Cascade's 100-tool budget). Per-tool toggling means you can disable mesh tools if you're solo. Same archive Claude, ChatGPT, Cursor, Copilot, and Gemini also read from. Travels with your team across every IDE and every model.

Reasoning

They stack. Built-in Cascade tools handle the code. Memories + Codemaps hold the implicit patterns. GitHub MCP handles the issues. Playwright + Postgres handle the operational reach. Custom MCPs handle internal systems. Knovya handles the reasoning that doesn't fit in any of them — the decisions you wrote down so future-you (or future-Cascade) could find them.

Surfaces

Four moments. One archive.

Where Knovya actually shows up across the Windsurf stack — the Cascade panel, the Marketplace install, the Command Palette flow, the config that keeps it portable.

Windsurf · Cascade · Agent i.

"Refactor /api/auth using past decisions."

// Windsurf · Cascade · SWE-1.5
→ Refactor /api/auth — cite past decisions
↓ Plan
1. Search archive for auth ADRs
2. Read related retros + check Codemap
3. Apply changes to src/auth/
knovya_search(query="auth strategy ADR")
knovya_experience(topic="auth migration")
↓ ADR-014 · 2 retros · 1 cautionary precedent
✓ Patch drafted. Cites ADR-014. Approve to apply?

Cascade pauses for approval at meaningful checkpoints — multi-file edits land only after you say go. The 0-credit SWE-1.5 model handles the planning at 950 tokens/sec.

Cascade panel · MCP Marketplace ii.

One-click install, no JSON.

MCP Marketplace browse
github official ✓
playwright official ✓
knovya install
postgres add

MCPs icon top-right of the Cascade panel, or Settings → Cascade → MCP Servers. The Marketplace handles the config file; OAuth handles sign-in. Quit and reopen Windsurf to load.

Cmd/Ctrl+Shift+P · palette iii.

Power-user path.

// Command Palette
> windsurf: configure mcp servers
↓ Filtered matches
▸ Windsurf: Configure MCP Servers
Windsurf: Open Settings
Windsurf: Reload MCP Configuration
↵ Opens mcp_config.json — paste, save, full restart.

The fastest keyboard path. Windsurf opens ~/.codeium/windsurf/mcp_config.json for direct editing — useful when committing a shared team config.

~/.codeium/windsurf/mcp_config.json iv.

The schema, portable across editors. 

{
  "mcpServers": {     // same key Claude Desktop & Cursor use
    "knovya": {
      "serverUrl": "https://mcp.knovya.com/mcp"
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp"]
    }
  }
}

Windsurf, Cursor, and Claude Desktop all use "mcpServers". VS Code Copilot uses "servers" (different schema). Same Knovya URL across all three.

Bonded with

Cascade isn't alone. Same archive, four other doorways.

The same Knovya Cascade reads from is also one paste away in Cursor, Claude, GitHub Copilot, and any custom integration via REST. Whichever IDE-pair-programming tool catches your next thought, it's reading from the same archive.

Cursor

The other AI-native IDE. Composer Agent reads the same archive — different editor, same Knovya.

Walk through Cursor
Claude

Claude Code in your terminal, Claude Desktop on your laptop. Built to Anthropic's MCP spec.

Walk through Claude
GitHub Copilot

VS Code Agent mode, JetBrains, Visual Studio, the Copilot CLI. Same Knovya across every IDE Copilot ships in.

Walk through Copilot
Knovya API

REST + webhooks. For internal tools, custom CI scripts, anything that doesn't speak MCP yet.

Walk through the API
Free 50 calls / month — enough to try Knovya inside Cascade
Pro · $15/mo 5,000 calls · encrypted notes
Team · $25/seat Unlimited · shared archive
See pricing
Questions, in advance

Windsurf & Knovya — before you ask.

Does Windsurf support MCP?

Yes — Cascade, Windsurf's AI agent, has supported MCP natively since 2025, putting Windsurf in the first wave of MCP-native IDEs alongside Cursor and (later) GitHub Copilot. Three transports are supported: stdio, Streamable HTTP, and SSE.

The Cascade agent reaches MCP tools automatically when relevant to your prompt; toggle MCP under Windsurf Settings → Cascade if it isn't on yet, then restart the editor (closing the window alone doesn't reload).

How do I add Knovya to Windsurf?

Three paths. (1) MCP Marketplace: click the MCPs icon in the top-right of the Cascade panel, search Knovya, click Install. (2) Command Palette: Cmd/Ctrl+Shift+P → Windsurf: Configure MCP Servers, paste the Knovya block, save. (3) Manual: edit the config file directly — ~/.codeium/windsurf/mcp_config.json (Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json).

Quit Windsurf completely and reopen — closing the window alone doesn't reload MCP. About 90 seconds end-to-end.

Can I use Knovya with Cascade in Windsurf?

Yes — that's the whole point. Cascade calls Knovya's tools mid-task: searching past ADRs before refactoring, citing customer interviews when planning, reading retros when fixing similar bugs. Knovya works with all of Cascade's transports and respects per-tool toggling, so you can pick exactly which Knovya tools Cascade can reach.

The 0-credit SWE models (SWE-1.5, SWE-1, SWE-1-mini, swe-grep) pair well with knovya_search and knovya_read for cheap, fast context lookups — no per-call charges burning your credit budget.

Does Knovya MCP work in Codeium?

Two different things share the Codeium name. The Codeium plugin — autocomplete-only, lives inside VS Code, JetBrains, Vim, etc. — is separate from Cascade. That plugin is not an MCP client; MCP servers like Knovya don't surface there.

Windsurf, the AI-native IDE Cognition AI now develops, ships Cascade with full MCP support. If you're on Codeium-the-plugin and want the agentic + MCP workflow, switch to Windsurf-the-IDE — your config carries over to the same ~/.codeium/windsurf/ directory.

What about Windsurf's 100-tool limit?

Windsurf caps Cascade at 100 active MCP tools across all servers, and 20 tool calls per response (auto-continue lifts the second cap when enabled in Cascade settings). Knovya exposes 34 tools across five families — about a third of the budget — leaving room for GitHub MCP, Playwright, and other servers.

Use Windsurf's per-tool toggling to disable Knovya tools you don't need — for example, turn off the 11 mesh tools if you're not running multi-agent flows, and recover that budget for another server.

Did anything change after Cognition AI acquired Windsurf?

Cognition AI acquired Windsurf in December 2025 (~$250M, $82M ARR at the time) and brought the SWE-1.5 model, Codemaps, and the Memories feature into the IDE. MCP support didn't change shape — same mcp_config.json, same mcpServers schema, same Cascade integration.

Pricing has shifted (Free 25 credits, Pro $15/mo with 500 credits, Pro Plus $35/mo, Teams $30/seat, Enterprise $60/seat as of mid-2026), and the announced direction is deeper Devin integration. Knovya's MCP works the same way across that transition — we wired Cascade's mcpServers schema, not anything Cognition-specific.

Should I use Knovya in Windsurf or Cursor?

Both, if you switch between them — that's the point of MCP. The same Knovya archive shows up in either editor. Choose Windsurf when you want Cascade's autonomous multi-step flow with Codemaps and 0-credit SWE models; choose Cursor when you want Composer's parallel agents and BugBot.

Windsurf's per-tool toggling and 100-tool cap are stricter; Cursor lets a single workspace run more servers without that ceiling. Knovya's 34 tools fit comfortably in either, and the same mcpServers shape works in both config files — paste once, copy across.

Open Windsurf. Cascade in flow.
Knovya in the toolset.

The Marketplace for the quick install, the palette for the keyboard-first flow, the config file for the team-shared setup. One ~/.codeium/windsurf/mcp_config.json entry, same archive on the other side.

Get connected Browse all 7 connectors

Or jump to the install moment, then see pricing.

Cascade-native MCP since 2025 · 34/100 tools, room to spare · OAuth 2.1 · Free tier 50 calls/month · 14-day Pro trial.