Guides8 min read

Best MCP Servers for Windsurf IDE in 2026

Top MCP servers for Windsurf, Codeium's AI-powered IDE. Database access, GitHub integration, browser automation, and web search — step-by-step configuration.

By MyMCPTools Team·

Windsurf is Codeium's AI-first IDE — built from the ground up for developers who want an agentic coding experience without the context-switching tax of external tools. Its Cascade agent can plan multi-step tasks, write code, run terminal commands, and iterate on feedback. Connect MCP servers and Windsurf becomes something more powerful still: an IDE with direct access to your databases, browsers, APIs, and version control, all without leaving your editor.

This guide covers the best MCP servers for Windsurf in 2026, how to configure them, and the workflows they unlock.

How Windsurf Handles MCP Servers

Windsurf supports MCP servers through its Cascade configuration panel. Once connected, the Cascade agent can invoke MCP tools as part of its planning and execution loop. Unlike passive AI completions, Cascade actively uses MCP tools to gather information, take action, and verify results — all as part of a single conversation thread.

Configure MCP servers through Windsurf's settings: Settings → Cascade → MCP Servers. The configuration format is identical to Claude Desktop's JSON format, so any server that works there will work in Windsurf.

1. Filesystem MCP Server — Essential Foundation

The Filesystem server is the starting point for any Windsurf MCP setup. While Windsurf's native editor access already gives Cascade read/write capability within open files, the Filesystem MCP server extends this to structured directory operations — listing, reading metadata, and navigating project structure programmatically.

Why it matters: Cascade's multi-file refactoring and code generation tasks work best when it can survey the full project structure rather than only the files you've opened. The Filesystem server makes this survey fast and explicit.

Setup:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/your/project"]
    }
  }
}

2. GitHub MCP Server — Full Repository Control

The GitHub MCP server gives Cascade the ability to manage your repositories without leaving the IDE. Create branches, commit changes, open pull requests, review diffs, and manage issues — the complete PR workflow inside Windsurf.

Power workflows with Windsurf + GitHub MCP:

  • Ask Cascade to "implement this feature, create a branch, and open a PR with a description" — it handles the entire flow
  • Have Cascade review an open PR's diff and suggest test cases
  • Search across your org's repos for prior implementations before writing new code
  • Let Cascade draft release notes from recent merged PRs

Setup:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here" }
    }
  }
}

3. PostgreSQL MCP Server — Schema-Aware Database Work

Database queries are where Windsurf's Cascade agent truly earns its keep. The PostgreSQL MCP server lets Cascade inspect your actual schema — table names, column types, relationships, indices — before writing SQL, ORM code, or migration scripts. No more generated queries that fail because of a column name mismatch.

What becomes possible:

  • Ask "write a migration that adds soft delete to the orders table" — Cascade reads the existing schema and writes the correct migration
  • Debug a failing query by having Cascade explain the execution plan
  • Generate ORM models directly from an existing database schema

4. Playwright MCP Server — Browser Testing in Your Agent Loop

The Playwright MCP server gives Cascade the ability to control a real browser. After making frontend changes, Cascade can navigate to your dev server, interact with the UI, and verify that its changes work visually — closing the loop without requiring manual testing between every iteration.

Key workflows:

  • Build a component in Windsurf, then have Cascade navigate to localhost and screenshot the result
  • Write an end-to-end test and have Cascade run it against your dev environment
  • Scrape API documentation from external sites when docs aren't available in text format
  • Test form submissions and verify the full user flow after implementing a feature

5. Git MCP Server — Version Control Context

The Git MCP server gives Cascade direct access to your repository's commit history, diffs, and branch state. This context is invaluable for understanding why code was written a certain way — blame and log tell the story that comments usually don't.

Useful for:

  • Understanding which commit introduced a bug ("find when this function's signature changed")
  • Generating meaningful commit messages based on actual diffs
  • Reviewing your own changes before opening a PR

6. Brave Search MCP Server — Live Documentation Lookup

Windsurf's Cascade has a training data cutoff. The Brave Search MCP server fills the gap — when Cascade needs current library documentation, recent error message solutions, or updated API references, it can search the web in real time.

Most useful when:

  • Working with libraries that have released breaking changes since Cascade's training cutoff
  • Looking up recent Stack Overflow answers for specific error messages
  • Verifying that a proposed API pattern is still recommended in the current version

7. SQLite MCP Server — Local Development Databases

For projects using SQLite — common in local development, mobile apps, or smaller self-contained tools — the SQLite MCP server gives Cascade direct query access. Useful for inspecting test fixtures, verifying migration outputs, and debugging data-layer issues without switching to a separate database client.

8. Docker MCP Server — Container Management

The Docker MCP server lets Cascade interact with running containers and compose stacks. When debugging a containerized application, Cascade can check container logs, inspect environment variables, and verify service health — all as part of its diagnostic reasoning loop.

9. Redis MCP Server — Cache Debugging

The Redis MCP server gives Cascade read access to your Redis instance. Useful for debugging caching issues, inspecting session state, or verifying that cache invalidation logic works correctly after implementing changes in Windsurf.

Recommended Windsurf MCP Stack

Start here:

  1. Filesystem — project navigation foundation
  2. GitHub — complete PR workflow without leaving the IDE
  3. PostgreSQL or SQLite — database-aware code generation
  4. Brave Search — current documentation lookup

Add Playwright for frontend work, Docker for containerized environments, and Redis as your stack grows in complexity. Avoid loading every available server at once — each server adds tools to Cascade's context, and more isn't always better.

Windsurf vs Other MCP Clients

Windsurf's Cascade agent is agentic by design — it plans multi-step tasks and executes them, not just completes individual prompts. This makes MCP particularly powerful in Windsurf compared to passive clients: Cascade can chain multiple MCP tool calls together as part of a single task without waiting for you to approve each step.

See the full Windsurf MCP server integration list or browse coding category servers for more developer tools. Also see Best MCP Servers for Cline and Best MCP Servers for Cursor for comparison.

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

📁

Filesystem

Secure file operations with configurable access controls. Read, write, and manage files safely.

Local
💻

GitHub MCP Server

The GitHub MCP server is GitHub's official Model Context Protocol integration, giving AI assistants like Claude and Cursor direct, authenticated access to the GitHub platform and its full developer surface. With this MCP server, you can ask your AI to read and write repository files, create and merge branches, open and review pull requests, comment on and close issues, trigger GitHub Actions workflows, search across code repositories with GitHub's code search, and inspect commit history — all through natural-language prompts in your AI interface. Developers use it to supercharge code review workflows, automate issue triage, generate PR descriptions from diffs, bulk-update repository settings, and wire AI agents into CI/CD pipelines. The GitHub MCP server connects via a GITHUB_PERSONAL_ACCESS_TOKEN environment variable with scopes for the operations you need, keeping authentication clean and auditable. Install with Docker: `docker run -e GITHUB_PERSONAL_ACCESS_TOKEN=<token> ghcr.io/github/github-mcp-server` — or configure it as a remote MCP server in Claude Desktop, Cursor, VS Code, Windsurf, and Cline. With over 8,000 GitHub stars, it is the most widely deployed official code-platform MCP server and the reference implementation for AI-native GitHub automation.

Auth required
🗄️

PostgreSQL MCP Server

The PostgreSQL MCP server is an official Model Context Protocol server maintained by Anthropic that gives AI assistants read-only access to PostgreSQL databases. By connecting Claude Desktop, Cursor, or VS Code to a running Postgres instance, developers can ask natural-language questions about their data schema, run exploratory SQL queries, inspect table structures, list available schemas, and analyze query results — all without leaving their AI chat interface. The server operates in read-only mode by design, preventing any accidental data mutations, making it safe to connect against production databases for reporting, debugging, and data exploration workflows. Core tools include executing SELECT queries, listing tables and schemas, describing column types and constraints, and inspecting indexes. Setup requires a running PostgreSQL instance and a standard connection string in postgres:// format. Install via npx using the @modelcontextprotocol/server-postgres package, passing your database URI as an argument. Teams use it to power data analysis conversations, generate schema documentation automatically, debug production data anomalies by asking Claude to inspect table contents, and build ad-hoc reports through natural-language SQL generation. Works with any PostgreSQL 12+ instance including Amazon RDS, Supabase, Neon, and self-hosted deployments.

Local
🌍

Playwright MCP Server (ExecuteAutomation)

ExecuteAutomation's Playwright MCP Server is a community-maintained browser automation server (5,500+ GitHub stars) distinct from Microsoft's official microsoft/playwright-mcp — it leans further into test generation and visual workflows rather than pure accessibility-tree navigation. Beyond standard navigate/click/fill/screenshot tools, it can generate Playwright test code from a live browsing session, scrape full page content and structured data, execute arbitrary JavaScript in the page context, and drive API testing (GET/POST/PUT/PATCH/DELETE requests) alongside the browser tools. A standout feature is 143 real device presets for responsive testing — a single call like playwright_resize({ device: "iPhone 13" }) swaps in the correct viewport, user-agent, touch support, and device pixel ratio, and natural-language prompts like "test on iPad landscape" work directly through Claude. Install via `npm install -g @executeautomation/playwright-mcp-server`, Smithery, mcp-get, or the one-line `claude mcp add --transport stdio playwright npx @executeautomation/playwright-mcp-server` for Claude Code; VS Code one-click installers are also published. No API keys are required — it launches and drives a local Chromium/Firefox/WebKit browser directly. Choose this over Microsoft's official server when you specifically need auto-generated Playwright test scripts, JS execution, or device-emulation testing; choose Microsoft's for pure lightweight accessibility-tree page navigation.

Local
💻

Git

Tools to read, search, and manipulate Git repositories. Full Git operations support.

Local
🔍

Brave Search MCP Server

The Brave Search MCP Server is the official server from Brave that gives AI assistants privacy-first web search through the independent Brave Search API — no tracking, no profiling, and results drawn from Brave's own web index rather than Google or Bing. It exposes five distinct tools that map directly to the Brave Search API endpoints: brave_web_search for general queries with pagination, freshness filters, and safe-search controls; brave_local_search for businesses, restaurants, and points of interest with automatic location filtering; brave_news_search for recent articles and current events; brave_image_search for image discovery; and brave_video_search for finding videos across the web. Authentication uses a single BRAVE_API_KEY (free tier available at brave.com/search/api) or a mounted BRAVE_API_KEY_FILE for Docker-secret setups. Install in Claude Desktop, Cursor, Windsurf, or VS Code with one npx command and choose stdio or streamable-HTTP transport. Because Brave operates its own crawler and index, the Brave Search MCP server is a strong choice for developers who want an alternative to Google-dependent search tools, need reproducible non-personalized results, or care about data privacy in agent workflows — Claude can pull fresh web context, verify facts, and research topics without leaking queries to ad-tech pipelines.

Local
🔧

Docker MCP Server

The Docker MCP server connects your AI assistant directly to your local or remote Docker daemon, exposing container lifecycle management and image orchestration as Model Context Protocol tools. With this integration, developers can prompt Claude, Cursor, or Windsurf to inspect running containers, view real-time logs, build new images from Dockerfiles, start and stop services using Docker Compose, and prune unused system resources through natural language. Rather than switching to a terminal to type complex docker inspect commands, you can simply ask your AI to "find out why the postgres container keeps crashing" or "tail the last 100 lines of the frontend container logs and find the React error". This is a game-changer for DevOps engineers, backend developers, and system administrators who want to streamline container debugging, automate compose cluster orchestration, and troubleshoot networking issues faster. The server interacts securely with the Docker Engine API, meaning it can both read system state and execute commands like port binding or volume inspection. It works cross-platform wherever Docker Desktop or the Docker daemon is running. Docker's official implementation ships as the Docker MCP Gateway (docker/mcp-gateway), a `docker mcp` CLI plugin that acts as a single secure gateway in front of many containerized MCP servers from the Docker MCP Catalog — each downstream server runs in its own isolated container with resource limits and secret injection, so an assistant connects once to the gateway instead of wiring up dozens of individual servers. Start it with `docker mcp gateway run`, then point Claude Desktop, Cursor, or another client at the gateway; `docker mcp server enable <name>` toggles which catalog servers (including the Docker/container-management tools) are exposed. This container-per-server isolation is the key security benefit over running MCP servers directly on the host.

Local
🗄️

SQLite MCP Server

The SQLite MCP server is an official Anthropic reference implementation that gives AI assistants direct, conversational access to SQLite databases — the world's most widely deployed database engine. Through natural language, you can ask Claude or Cursor to run SELECT queries, insert and update rows, inspect table schemas, create new tables, and generate business intelligence reports without writing a single SQL statement manually. Common use cases include exploring local data files, prototyping application schemas, auditing CSV imports, running ad-hoc analytics on app databases, and letting AI agents manage lightweight structured storage during agentic workflows. The server exposes tools for query execution, schema introspection, and memo-style business insights that synthesize query results into readable summaries. It requires a path to an existing .db file as a startup argument. Install with: npx @modelcontextprotocol/server-sqlite /path/to/your-database.db. Works with Claude Desktop, Cursor, VS Code, and all MCP-compatible clients. For developers who want AI to reason directly over structured data stored locally, the SQLite MCP server is the fastest path from question to answer without leaving your AI chat interface.

Local
🗄️

Redis MCP Server

The Redis MCP server is an official Anthropic reference implementation that lets AI assistants interact with Redis key-value stores for caching, session management, pub/sub messaging, and real-time data operations. Redis is the most popular in-memory data store, widely used for rate limiting, leaderboards, job queues, and ephemeral session state — and this MCP server brings all of that within reach of natural-language AI prompts. With it, you can ask Claude or Cursor to get and set string/hash/list/set/sorted-set values, inspect TTLs, flush specific keys, publish messages to channels, and scan keyspaces for debugging — all without opening redis-cli. Developers use it during backend debugging sessions, to inspect live cache state, to manage feature flags stored in Redis, and to wire AI agents into event-driven architectures via pub/sub. The server connects to a Redis instance via a connection URL (defaults to redis://localhost:6379). Install with: npx @modelcontextprotocol/server-redis. Works with Claude Desktop, Cursor, VS Code, and any MCP-compatible client. It is the reference implementation for Redis + AI integration in the MCP ecosystem.

Local

📚 More from the Blog