Windsurf, Codeium's AI-powered IDE, has earned a devoted following among developers who want deep AI assistance without leaving their coding environment. MCP support in Windsurf unlocks a new level of capability — your AI coding assistant can now reach outside the IDE to databases, GitHub, documentation, and any service with an MCP server.
Here's how to build the optimal MCP stack for Windsurf.
Setting Up MCP in Windsurf
Windsurf supports MCP through its settings configuration. Add servers via the Windsurf settings panel (CMD+, → Extensions → MCP) or by editing your configuration file directly. Each MCP server runs as a local process that Windsurf's Cascade AI can call during conversations.
The key difference from other IDEs: Windsurf's Cascade is specifically optimized for multi-step coding tasks and agentic workflows, making MCP servers that provide structured data particularly valuable.
1. Filesystem MCP — The Non-Negotiable Foundation
While Windsurf already has excellent file access within your open workspace, the Filesystem MCP server extends that to any configured directory on your system — allowing Cascade to reference documentation folders, configuration files, and project assets outside the active workspace.
Key capabilities:
- Read and write files outside the current workspace
- Search across directories with glob patterns
- Access system configuration and dotfiles
- Browse file trees and directory structures
Windsurf-specific tip: Configure the Filesystem MCP to access your ~/.config directory so Cascade can reference your personal configs, SSH keys (read-only), and dotfile setups when helping you configure new development environments.
2. GitHub MCP — PR Reviews and Issue Management Without Leaving Windsurf
The GitHub MCP server is essential for any developer using Windsurf professionally. Instead of switching to a browser to check PRs, create issues, or review code, Cascade can interact with GitHub directly.
Key capabilities:
- Create, review, and comment on pull requests
- Open and manage issues from within your coding session
- Search code across repositories for examples and patterns
- Access CI/CD status and run logs
Power workflow: While writing code, ask Cascade to "check if there's an existing GitHub issue for the bug I just fixed and close it with a reference to this PR" — complete GitHub housekeeping without context-switching.
3. Git MCP — Deep Repository Intelligence
The Git MCP server (distinct from GitHub) gives Windsurf's Cascade direct access to your local git history — enabling context-aware code assistance that understands how your codebase evolved.
Key capabilities:
- Query commit history, blame, and diff data
- Search commits by message, author, or date
- Access branch information and merge history
- Navigate git log to understand code evolution
Best for: Debugging sessions where understanding why code was written a certain way is as important as fixing it.
4. PostgreSQL MCP — Query Your Database Conversationally
Web and backend developers working in Windsurf often need to reference database schemas while writing queries or building ORM models. The PostgreSQL MCP server gives Cascade direct schema access — dramatically reducing errors in database-related code.
Key capabilities:
- Inspect table schemas, columns, types, and constraints
- Execute read-only queries to verify data assumptions
- Access foreign key relationships and indexes
- Generate accurate SQL based on real schema data
Power workflow: "Write a migration to add an index on the users.email column, and check if that column already has any unique constraints" — Cascade checks the actual schema before generating migration code.
5. SQLite MCP — Local Database for Rapid Prototyping
For developers building apps with local SQLite databases — Electron apps, mobile apps with local storage, data processing scripts — the SQLite MCP server is invaluable during development and debugging.
Key capabilities:
- Read and query SQLite databases directly
- Browse table structures and sample data
- Run diagnostic queries during debugging
- Export and analyze data
6. Sequential Thinking MCP — Better Code Architecture
One of the most underrated MCP servers for coding work. Sequential Thinking helps Windsurf's Cascade break complex engineering problems into structured reasoning chains — leading to more architecturally sound solutions rather than quick-fix patches.
Key capabilities:
- Structured multi-step reasoning for complex problems
- Backtrack and revise thinking chains
- Explicit uncertainty and assumption tracking
- Better handling of ambiguous requirements
Best for: Architecture design, refactoring decisions, debugging complex multi-system interactions.
7. Memory MCP — Persistent Project Context
Windsurf sessions don't always remember context from previous coding sessions. The Memory MCP server provides persistent storage for project-specific context — architecture decisions, coding conventions, API quirks, and "don't do this because..." notes.
Key capabilities:
- Store and retrieve key-value pairs and knowledge graphs
- Persist architecture decisions and rationale
- Remember coding conventions specific to each project
- Track known bugs, workarounds, and technical debt
8. Brave Search MCP — Documentation and API Reference
When Cascade needs to look up API documentation, find code examples, or verify a library's behavior, Brave Search MCP provides real-time web access without leaving Windsurf.
Key capabilities:
- Real-time web search from within coding sessions
- Find documentation for any library or framework
- Search Stack Overflow and GitHub for code examples
- Access recent articles about APIs and services you're integrating
Recommended Windsurf MCP Configuration
Here's a starter configuration that covers 90% of development workflows:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/projects"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token" }
},
"git": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-git"]
},
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
}Add PostgreSQL or SQLite based on your stack, and Brave Search if you want web access for documentation lookups.
Related guides: