Guides9 min read

Best MCP Servers for Cline: Complete Setup Guide 2026

Supercharge Cline, the autonomous VS Code coding agent, with the best MCP servers. Database access, browser automation, GitHub integration, and more — step-by-step setup.

By MyMCPTools Team·

Cline is one of the most powerful autonomous coding agents available for VS Code. Unlike simpler AI assistants, Cline can plan multi-step tasks, run terminal commands, read and write files, and iterate until the job is done. Add MCP servers and it becomes something else entirely — a development partner with direct access to your databases, browsers, APIs, and external services.

This guide covers the best MCP servers for Cline, how to configure them, and the workflows that change your daily development experience.

How Cline Uses MCP Servers

Cline integrates MCP servers through VS Code's MCP configuration. Once connected, Cline can autonomously invoke MCP tools as part of its planning loop — it doesn't just suggest using a tool, it uses it. This means when Cline is debugging a database issue, it can directly query your PostgreSQL schema rather than asking you to copy-paste table definitions.

Cline reads MCP server configurations from ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json on Linux/macOS or the equivalent Windows path.

1. Filesystem MCP Server — Your Codebase, Fully Accessible

The Filesystem server is Cline's foundation. While Cline already has native file access through VS Code's extension API, the Filesystem MCP server extends this to structured operations across any directory Cline is configured to access — including paths outside the current workspace.

Why it matters for Cline: Cline's autonomous planning mode works best when it can read existing code, understand directory structure, and write new files without interrupting you for confirmation at every step. The Filesystem MCP server makes this seamless.

Setup:

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

2. GitHub MCP Server — Full Repo Control Inside Cline

The GitHub MCP server gives Cline the ability to manage your repositories directly. Create branches, open pull requests, review diffs, and manage issues — all without leaving your Cline conversation.

Power workflows with Cline + GitHub MCP:

  • Ask Cline to "implement this feature, create a branch, and open a PR" — it executes the entire workflow autonomously
  • Have Cline review an existing PR's diff and suggest improvements
  • Let Cline search across all your repos for similar implementations before writing new code

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 Queries

Database work is where Cline + MCP truly shines. The PostgreSQL MCP server lets Cline inspect your schema, run queries, and understand your data model — so when you ask it to "write a query for this report", it actually knows your table structure instead of guessing.

What becomes possible:

  • Ask Cline to write optimized queries based on actual schema introspection
  • Have Cline debug slow queries by examining execution plans
  • Let Cline generate migration scripts that account for existing constraints

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

The Playwright MCP server gives Cline the ability to control a real browser. For frontend developers, this means Cline can test its own output: write a component, then navigate to your dev server and verify it renders correctly.

Key use cases:

  • End-to-end testing as part of Cline's development loop
  • Scraping reference data from documentation sites
  • Testing form submissions and API responses through the browser
  • Taking screenshots to visually verify UI changes

5. Git MCP Server — Deep Version Control Context

The Git MCP server gives Cline direct access to your git history, diffs, and branch state. Rather than relying on VS Code's built-in git integration, this server allows Cline to programmatically query commit history and use it as context for understanding why code was written a certain way.

Powerful with Cline's autonomous mode: Tell Cline "figure out when this bug was introduced" and it can bisect through recent commits using git log and diff tools to identify the offending change.

6. Brave Search MCP Server — Real-Time Web Knowledge

Cline's training data has a cutoff. The Brave Search MCP server fills that gap — when Cline needs current documentation, error messages, or API references, it can search the web and pull the result into context without you having to tab-switch.

Especially useful for:

  • Looking up error messages from libraries that have been updated since Cline's training
  • Finding recent Stack Overflow solutions
  • Checking current API documentation versions

7. Docker MCP Server — Container Management in Context

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

8. Redis MCP Server — Cache & Session Debugging

The Redis MCP server gives Cline read access to your Redis instance. Useful for debugging caching issues, inspecting session data, or verifying that cache invalidation logic is working as expected after Cline makes changes to your application.

Recommended Cline MCP Stack

For most developers, this is the right starting stack:

  1. Filesystem — always-on foundation
  2. GitHub — repo operations and PR workflow
  3. PostgreSQL or SQLite — depending on your project
  4. Playwright or Puppeteer — browser testing
  5. Brave Search — web lookup when needed

Add Docker and Redis as your stack complexity grows. Avoid adding every available server at once — each server adds tool options to Cline's context, and having too many can slow down its planning and increase API costs.

Cline vs Other MCP Clients

Cline's autonomous mode makes MCP particularly powerful compared to passive clients like Claude Desktop. Where Claude Desktop presents MCP results for you to read, Cline acts on them — it queries your database, reads the results, and incorporates them into its next action, all without waiting for you to approve each step.

Find more MCP server options in the Cline integration directory or browse by coding category for developer-focused servers.

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 MCP Server

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Local
💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
🌍

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. One maintenance fact the listings omit, checked against GitHub and npm on 2026-08-15: this repository has not been pushed since 2025-12-13 and npm 1.0.12 was published 2025-12-12, with 32 issues open. It is neither archived nor deprecated, so nothing warns you at install time — it installs, connects and works while its Playwright dependency drifts, whereas Microsoft's server ships continuously. Weigh the codegen, 143-preset device emulation and HTTP request tools against running an eight-month-old build. Note also that headless defaults to false on playwright_navigate, so it opens a visible browser window unless told otherwise, and that stdio-mode logging goes only to ~/playwright-mcp-server.log to keep the JSON-RPC stream clean.

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 (ckreiling/mcp-server-docker) gives an AI assistant direct control of a Docker daemon over the Model Context Protocol: containers, images, networks and volumes, as tools rather than shell commands. It is the community server most people mean by "Docker MCP" — distinct from Docker’s own Docker MCP Gateway, which does not manage your containers at all but runs *other* MCP servers inside containers. If you want to ask Claude why the postgres container keeps restarting, you want this one; if you want a single secure endpoint in front of twenty catalog servers, you want the gateway. The tool surface is explicit and small enough to reason about: list_containers, create_container, run_container, recreate_container, start_container, fetch_container_logs, stop_container and remove_container for containers; list_images, pull_image, push_image, build_image and remove_image for images; list_networks / create_network / remove_network and list_volumes / create_volume / remove_volume for the rest. Two resource templates, docker://containers/{id}/logs and docker://containers/{id}/stats, let a client read logs and live stats by container ID or name without a tool call. It also ships a docker_compose prompt that puts the model into a plan-then-apply loop — you describe the containers you want under a project name, the model proposes a concise plan, and nothing runs until you approve it; reopening the prompt with the same project name re-reads the state of everything created under it, which is how you clean up after a lost chat. It runs on the Python Docker SDK’s from_env, so DOCKER_HOST applies: set ssh://user@host and the same server administers a remote engine. Two limits are deliberate and stated by the project — privileged options like --privileged and --cap-add/--cap-drop are not supported, and container configuration passes through the model, so no secrets belong in it.

Local📘
🗄️

Redis MCP Server

The Redis MCP Server (redis/mcp-redis) is Redis's own natural-language interface for agentic applications, letting an AI client read and write Redis data over the Model Context Protocol. Note which one you install: the server most tutorials still point at is Anthropic's reference implementation, which now lives in modelcontextprotocol/servers-archived, and its npm package @modelcontextprotocol/server-redis is explicitly marked "Package no longer supported" with a last publish of 2025-04-25. The maintained server is a Python package instead, run with uvx --from redis-mcp-server@latest, and it covers far more of Redis than the reference one did: string, hash, list, set and sorted-set tools; JSON document tools; pub/sub with stateful channel and pattern subscriptions; Streams tools including consumer-group create, read, acknowledge and destroy; vector index management and vector search through the query engine; a docs search tool; and a server-management tool for database info. Connection is a redis:// or rediss:// URL passed as --url, or the REDIS_HOST/REDIS_PORT/REDIS_PWD/REDIS_SSL environment variables, with Redis Cluster mode behind REDIS_CLUSTER_MODE and EntraID service-principal, managed-identity and default-credential auth flows for Azure Managed Redis. There is no --read-only flag: the documented way to stop an agent writing is a Redis ACL user (ACL SETUSER readonlyuser on >pw ~* +@read -@write). Ships as a PyPI package, a GitHub install via uvx, and an official mcp/redis Docker image; stdio transport only.

Local📘

📚 More from the Blog