Coding & Dev MCP Servers

Reference/test server with prompts, resources, and tools. Perfect for testing MCP implementations.

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

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.

GitLab's official MCP server enabling AI tools to securely access GitLab project data, manage issues, and perform repository operations via OAuth 2.0.

The Linear MCP server connects your AI assistant directly to Linear's project management platform via an officially hosted remote endpoint at mcp.linear.app — no local installation required. This is Linear's own first-party server, authenticated with OAuth 2.1 and centrally managed so you always run the latest version without updates. Available tools let you search issues by keyword, team, cycle, or filter; create new issues with title, description, and assignee; update status, priority, labels, and comments; and navigate Linear's project and cycle structure. In Claude Code, add it with: `claude mcp add --transport http linear-server https://mcp.linear.app/mcp`, then run /mcp to complete the OAuth flow. For older clients, use the mcp-remote bridge for backwards compatibility. Claude Desktop and Claude.ai users can connect via Settings > Connectors. Cursor and Codex have native support via their MCP config. Linear is used by thousands of engineering and product teams to plan, track, and ship software — the Linear MCP server brings that data into every AI-powered workflow without copy-paste or context-switching.

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.

Run code in secure sandboxes hosted by E2B for safe code execution.

The Figma MCP Server connects AI coding assistants directly to your Figma design files, enabling real-time access to design tokens, component properties, frame layouts, and node data without leaving your editor. Figma's official MCP integration runs via the Figma Desktop app's Dev Mode — select any frame, component, or layer in your design and Claude, Cursor, or other MCP-compatible clients can read exact colors, typography, spacing, auto-layout properties, and component variants to generate pixel-accurate implementation code. The popular community alternative, Figma-Context-MCP by GLips (6,000+ GitHub stars), uses your Figma Personal Access Token (created in Figma Settings > Personal Access Tokens) to fetch any file your account can access, exposing tools to get full Figma document JSON, retrieve specific nodes by ID, list components with properties, extract text content from frames, and download rendered images of individual nodes. This approach works without the Figma Desktop app and is compatible with Claude Desktop, Windsurf, and Cline. Both routes give Claude the ability to read your exact design specs and translate Figma layouts into accurate React, Tailwind, or plain HTML/CSS code — eliminating the guesswork of approximating designs from screenshots or verbal descriptions. The Figma MCP Server is most powerful in front-end development workflows where design-to-code fidelity matters.

The Jira MCP server is Atlassian's official Remote MCP Server, giving AI assistants like Claude and Cursor direct, enterprise-grade access to Jira Software project management through natural-language interactions. Powered by Atlassian's Teamwork Graph and hosted on Cloudflare infrastructure, it requires no local process to run — authentication is handled via OAuth 2.1, making it the most secure way to connect AI to Jira in corporate environments. With this MCP server, product managers, engineers, and team leads can ask their AI to create and update Jira issues, transition ticket statuses through workflow stages, search with JQL (Jira Query Language), summarize sprint progress, view open epics and their child issues, retrieve assignee workloads, and bulk-triage backlogs. AI assistants can connect sprints to related Confluence documentation through Atlassian's graph layer, giving richer context for planning and retros. Enterprise customers including AT&T, NVIDIA, and Pfizer use Atlassian's MCP integration in production. Connect from Claude Desktop via Settings > Connectors, or add it to Claude Code with: `claude mcp add --transport http atlassian https://mcp.atlassian.com/v1/mcp`. Cursor and Windsurf users add the remote URL to their MCP config file. No install command needed — it's a fully hosted remote MCP server.

API development platform MCP for Postman. Run collections, manage environments, inspect API definitions, generate code snippets, and test API endpoints.

Parse and interact with OpenAPI/Swagger specifications via MCP. Explore API endpoints, generate client code, validate request/response schemas, and test APIs.

The Blender MCP server by ahujasid bridges Claude and the Blender 3D creation suite, letting AI assistants generate, modify, and render 3D scenes through natural language commands — no manual Blender UI required. With 2,800+ GitHub stars, it is one of the most popular creative-category MCP servers available. The integration consists of two components: a Blender Python addon that runs a local socket server inside Blender, and an MCP server layer that translates Claude's tool calls into Blender Python API (bpy) commands. Together they expose tools to create primitive objects (mesh cubes, spheres, cylinders, planes), apply materials with custom colors and PBR shader properties, position and scale objects in 3D space, set up lights and cameras, run arbitrary Python in Blender's scripting context, and trigger renders to PNG files. Compatible with Blender 3.0 and newer. Setup: install the Blender addon ZIP from the GitHub releases page (Edit > Preferences > Add-ons > Install), enable it, and start the socket server from the addon panel. On the MCP side, install blender-mcp with pip or uvx and point your MCP client to it. Works with Claude Desktop and any client supporting stdio MCP servers. Install with: uvx blender-mcp. The Blender MCP server is the go-to tool for product visualization, game asset prototyping, scene generation, and rapid 3D concept iteration using AI.

E2B secure cloud sandbox MCP server. Execute Python, JavaScript, and R code in isolated sandbox environments, run data analysis scripts, generate matplotlib visualizations, and install packages dynamically via E2B SDK.

Microsoft's official Playwright browser automation MCP server with 33K+ GitHub stars. Uses Playwright's accessibility tree rather than screenshots — fast, lightweight, and LLM-friendly. Enables Claude to navigate web pages, fill forms, click elements, extract structured data, and automate browser workflows without vision models.

Dynamic and reflective problem-solving through thought sequences.

Create crafted UI components inspired by the best 21st.dev design engineers.

Open-source tool for collaborative editing, versioning, evaluating, and releasing prompts.

There is no official, Snyk-published Model Context Protocol server as of this writing — a commonly referenced `snyk/mcp-server` repo does not exist. The most active real alternative is sammcj/mcp-snyk, a community-built, MIT-licensed MCP server that wraps Snyk's API and CLI for agentic security scanning (marked alpha by its author, so expect rough edges). It exposes tools to scan a GitHub or GitLab repository by URL for vulnerabilities, scan an existing Snyk project by ID, and verify that a configured API token is valid, returning the associated user and organization info. Authentication uses a Snyk API token and an org ID, supplied via `SNYK_API_KEY`/`SNYK_ORG_ID` environment variables, falling back to the locally configured Snyk CLI org if one isn't set explicitly. Install with `npx -y github:sammcj/mcp-snyk` in your MCP client config (Claude Desktop, Cursor, etc.). Typical use: ask Claude to "scan https://github.com/org/repo for security vulnerabilities using Snyk" and get back a structured findings summary instead of switching to the Snyk web console. Snyk's own engineering org separately maintains snyk/agentic-integration-wrappers, a set of wrappers for plugging Snyk scanning into agentic workflows more broadly — worth checking if this community MCP server doesn't cover your use case, since it isn't an official Snyk product and has no guaranteed support or roadmap.

The official SonarQube MCP Server, built and maintained by SonarSource, connects AI agents like Claude, Cursor, and VS Code Copilot to SonarQube Server or SonarQube Cloud so code quality and security become part of the agent's workflow rather than a separate CI step. Through it an assistant can pull the projects a token can see, retrieve open issues and code smells, inspect quality gate status and project metrics, and — notably — analyze a code snippet directly inside the agent context without the code first being committed and scanned by a pipeline, which lets Claude check its own just-written code against SonarQube's rules before you ever push. Authentication is a SonarQube user token supplied via the `SONARQUBE_TOKEN` environment variable; SonarQube Cloud users also set `SONARQUBE_ORG` (organization key), and self-hosted SonarQube Server users set `SONARQUBE_URL` to point at their instance (SonarQube Cloud US uses `https://sonarqube.us`). The server is distributed as a Java-based OCI container image at `sonarsource/sonarqube-mcp` on Docker Hub — run it with `docker run --pull=always -i --rm -e SONARQUBE_TOKEN -e SONARQUBE_ORG sonarsource/sonarqube-mcp`, or pin a version tag for reproducible deployments — and works with any OCI-compatible runtime such as Podman or nerdctl. SonarSource also provides an interactive Configuration Generator at mcp.sonarqube.com that emits ready-to-paste client config. Ideal for teams that want AI-assisted code review grounded in the same rules and quality gates their SonarQube project already enforces.

No official Retool MCP server currently exists, but starigade/retool-mcp-server is a focused community implementation that gives Claude and other MCP clients read access to a Retool workspace via the Retool REST API. Once configured with a `RETOOL_API_TOKEN`, it exposes tools to list every app the token can see (`retool_list_apps`, with optional search filtering), pull the full structure, queries, and components of a specific app (`retool_get_app`), extract the underlying SQL or REST/GraphQL queries embedded in an app for review (`retool_get_queries`), enumerate the database and API resources connected to the workspace (`retool_list_resources` / `retool_get_resource`), browse the folder hierarchy (`retool_list_folders`), and export a full app configuration for deep, offline analysis (`retool_export_app`). That combination is aimed squarely at low-code audits and migrations: a developer can ask Claude to summarize what a given internal tool does, trace which database a query hits, or flag apps that share a risky resource connection, all without opening the Retool editor. It supports both Retool Cloud and self-hosted instances — self-hosted deployments add a `RETOOL_BASE_URL` environment variable alongside the API token. Install by cloning the repository, running `npm install && npm run build`, then pointing an MCP client at the built `dist/index.js` entry point with `node`.

Feature flags as a service for continuous delivery.

Split.io was acquired by Harness and rebranded to Harness FME (Feature Management & Experimentation) — a `splitio/mcp-server` repo does not exist, and Harness has not published a first-party MCP server for it. The best available option is kud/mcp-harness-fme, a community-built, MIT-licensed TypeScript server exposing 30 tools across workspaces, environments, feature flags, flag definitions, segments, rule-based segments, and change requests. It supports a zero-config startup that reads the `MCP_HARNESS_FME_API_KEY` environment variable and exits immediately if it is missing, plus a "kill & restore" flow that instantly forces all traffic to a flag's default treatment (or restores it) with a single tool call. Every destructive operation — delete, kill, archive, disable — requires an explicit `confirm: true` argument, preventing accidental changes from an agent acting on ambiguous instructions. It also supports the full change-request flow for rule-based segments, letting teams submit segment-definition changes with optional approvers for orgs that require approval gates. Install with `npx --yes @kud/mcp-harness-fme@latest`, or add it directly via `claude mcp add --transport stdio --scope user harness-fme --env MCP_HARNESS_FME_API_KEY=your_api_key -- npx --yes @kud/mcp-harness-fme@latest` in Claude Code. An optional `get_flag_url` deep-link tool activates when `MCP_HARNESS_FME_ACCOUNT_ID` and `MCP_HARNESS_FME_ORG_GUID` are also set. Works with any stdio MCP client — Claude Desktop, Claude Code, Cursor, Windsurf, Cline, Zed.

The Flagsmith MCP Server is Flagsmith's official, Speakeasy-generated Model Context Protocol server for its Core and SDK APIs, letting AI assistants read and manage feature flags, remote config values, and environment/identity segmentation directly from a conversation. It ships as an installable Desktop Extension (`mcp-server.mcpb`) for Claude Desktop — drag-and-drop install with no additional setup — and as an npm package (`flagsmith`) for CLI-based clients, started with `npx flagsmith start --token-auth <your-api-token>` and wired into Claude Code, Cursor, Gemini, and Windsurf via each client's standard MCP config or one-line `mcp add` command. Progressive discovery keeps the tool surface manageable across the full Flagsmith API rather than dumping every endpoint into context at once. Typical use: ask Claude to "list all feature flags enabled for the beta segment in production" or "toggle the new-checkout-flow flag off for the EU environment," with the assistant calling the live Flagsmith API instead of requiring a dashboard visit. NOTE: as of this writing the repo carries an explicit "not yet ready for production use" notice from its Speakeasy-generated setup flow — expect rough edges and check the repo before depending on it for anything mission-critical.

Fast and secure execution of your AI generated code with Daytona sandboxes.

Code execution and development environment.

Cloud development environments.

Gitpod does not publish a Model Context Protocol server — a `gitpod-io/mcp-server` repo does not exist, and a GitHub search for "gitpod mcp" turns up nothing beyond an unrelated Minecraft joke repo. Gitpod's own product direction has moved toward Gitpod Flex and CDE-as-infrastructure rather than shipping an MCP tool surface, and unlike GitHub Codespaces (which has an official codespaces-mcp) no community project has stepped in to fill the gap either. If you want an AI agent to provision or control a Gitpod workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Gitpod or the community ships one. In the meantime, the closest cloud-dev-environment MCP options are the CodeSandbox and StackBlitz servers listed in this directory, or GitHub Codespaces MCP for a GitHub-native workflow.

An MCP server for reading files and project structure from StackBlitz projects, built by sxzz. Note this is a community project, not an official StackBlitz release — the previously-listed `stackblitz/mcp-server` repo does not exist. It exposes four tools: `resolve_project` looks up a StackBlitz project by ID or full stackblitz.com/edit/ URL and returns metadata (title, description, preset, visibility, file count); `list_files` renders the project's files as an ASCII tree, optionally filtered by a path prefix; `read_file` pulls the raw contents of a single file by path; and `search_files` runs a text or regex search across the project with case-sensitivity and result-limit options. It also exposes two MCP resource URI patterns — `stackblitz://{projectId}/tree` for the file tree and `stackblitz://{projectId}/files/{path}` for individual file contents — so an agent can browse a StackBlitz reproduction repo the same way it would a local directory. The server is read-only (no file writing or sandbox execution) and requires no API key, since it works against StackBlitz's public project data. It's aimed at the common "someone shared a StackBlitz repro link, now debug it" workflow: paste the project ID into Claude/Cursor and let the agent inspect the code directly instead of you copy-pasting files by hand. Install via npm as a global CLI (`stackblitz-mcp`) and wire it into any MCP-compatible client's config.

A Model Context Protocol server that exposes the official CodeSandbox SDK as MCP tools for AI agents, built by techlibs. This is a community project (not an official CodeSandbox release) — the previously-listed `codesandbox/mcp-server` repo does not exist. Unlike simpler read-only sandbox browsers, this server is fully stateless and covers the entire sandbox lifecycle: `createSandbox` (optionally forking a template, with privacy/title/tags/VM-tier/hibernation settings), `resumeSandbox` and `hibernateSandbox` for VM power state, `getSandboxInfo` for metadata without starting the VM, and `updateSandbox` for changing VM tier (Pico through XLarge) or hibernation timeout. File and shell access go through per-call sessions — `createSession`/`resumeSession` (with read/write permission, environment variables, and optional Git identity for commits) back `readFile`, `readdir`, and `writeFile`, all of which connect per call using a sandboxId + sessionId rather than holding open server-side state. A `--read-only` CLI flag disables all mutating tools and defaults new sessions to read permission, which is the recommended mode for agents you don't fully trust with a live VM. Requires a `CODESANDBOX_API_TOKEN` (or `CSB_API_KEY`) from your CodeSandbox account and Node.js 18+. Run via `npx @techlibs/codesandbox-mcp` in any MCP client config; the CLI binary is `mcp-server-codesandbox`.

Codeium does not publish a Model Context Protocol server — a `codeium/mcp-server` repo does not exist, and a GitHub/npm sweep for one turns up nothing beyond unrelated demo and research repos. That is because Codeium's product direction went the other way: the company rebranded its flagship product to Windsurf, an AI-native code editor (parent org Exafunction) that acts as an MCP *client*, letting its built-in Cascade agent call out to external MCP servers (filesystem, databases, GitHub, etc.) the same way Claude Desktop or Cursor do — it does not expose Codeium/Windsurf itself as a tool server. Exafunction's public repos are IDE plugins (windsurf.vim, windsurf.nvim, CodeiumJetBrains, codeium.el) rather than an MCP integration. If you want an AI assistant to read from or control a Codeium/Windsurf workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Codeium ships one.

Tabnine does not publish a Model Context Protocol server — a `tabnine/mcp-server` repo does not exist, and neither GitHub nor npm turn up a real first-party or community MCP integration for it (searches surface only unrelated demo/config repos with 0-3 stars). Tabnine's public engineering effort (org: codota) is entirely IDE-plugin-shaped — clients for VS Code, JetBrains, Vim/Neovim, Sublime, Atom, and JupyterLab that wire Tabnine's completion models into each editor's native autocomplete UI, plus a separate PR-review agent (tabnine-pr-agent). None of these expose Tabnine as an MCP tool server that Claude, Cursor, or another MCP client could call into. This entry is kept for search/reference purposes and will be updated if Tabnine ships a genuine MCP server in the future.

najva-ai's Sourcegraph MCP Server is a Python server that gives AI assistants AI-enhanced code search across large, multi-repo codebases using Sourcegraph's query engine. It exposes three tools: `search` (run Sourcegraph queries with full advanced syntax — regex patterns, `lang:`/`file:`/`repo:` filters, and boolean operators — across sourcegraph.com or a self-hosted instance), `search_prompt_guide` (generate a context-aware guide that helps the model construct effective queries for a stated objective), and `fetch_content` (retrieve file contents or explore directory structures inside a repository). Auth is via a `SRC_ENDPOINT` environment variable (required — e.g. https://sourcegraph.com) plus an optional `SRC_ACCESS_TOKEN` for private instances. The server runs locally over SSE / Streamable-HTTP (default ports 8000/8080) and is installed from source with UV (`uv sync && uv run python -m src.main`), pip (`pip install -e .`), or a bundled Dockerfile; clients like Cursor connect by pointing `.cursor/mcp.json` at the local `http://localhost:8080/sourcegraph/mcp/` URL. It's ideal for agents that need to find and understand code patterns across many repositories rather than a single local checkout.

The official Semgrep MCP server lets an AI assistant run Semgrep — a fast, deterministic static analysis engine that semantically understands 30+ languages and ships over 5,000 security rules — directly against the code it is writing or reviewing, so you can "secure your vibe coding" without leaving Claude, Cursor, VS Code, or Windsurf. It exposes a focused tool surface: `security_check` scans code for vulnerabilities, `semgrep_scan` runs a scan with a given rule config, `semgrep_scan_with_custom_rule` applies a custom Semgrep rule you supply inline, `get_abstract_syntax_tree` returns the AST of a snippet so an agent can reason about code structure, `supported_languages` lists the languages Semgrep can parse, and `semgrep_rule_schema` fetches the latest rule JSON Schema for writing new rules. With a Semgrep AppSec Platform login and token, `semgrep_findings` pulls findings from your organization's cloud account. The server runs three ways — as a Python package via `uvx semgrep-mcp` (PyPI: semgrep-mcp), as a Docker container `ghcr.io/semgrep/mcp`, or against Semgrep's hosted endpoint at mcp.semgrep.ai — and supports stdio, Streamable HTTP, and SSE transports. Note: the standalone semgrep/mcp repository is now deprecated, with ongoing development folded into the main `semgrep` binary (semgrep/semgrep, under cli/src/semgrep/mcp), so future updates ship through the official Semgrep CLI itself.

The CodeRabbit MCP Server lets Claude and other MCP-capable coding agents pull CodeRabbit's AI code-review output directly into their working context and act on it programmatically, instead of a developer manually reading through GitHub PR comments. Tools cover the full review lifecycle: get_reviews retrieves every CodeRabbit review left on a given pull request, get_review_details returns the configuration and file list behind a specific review, get_comments extracts individual line-level comments together with CodeRabbit's AI-generated prompts and suggested fixes, get_comment_details digs into one comment's full context and example fix, and resolve_comment marks a comment addressed, won't-fix, or not-applicable so the PR thread stays in sync with what the agent actually did. A bundled /coderabbit-review slash command chains these into an automated "fetch, triage, and implement fixes" workflow, which is the main use case: point an agent at a PR that CodeRabbit has already reviewed and have it work through the suggestions autonomously. Installation is npx coderabbitai-mcp@latest with no local build step; the only required credential is a GitHub Personal Access Token (repo scope for private repos, public_repo for public ones) passed as GITHUB_PAT, since the server reads PR review data through GitHub's API rather than CodeRabbit's own API. This is a community integration, not published by CodeRabbit itself, and depends on a repository already having CodeRabbit reviews enabled.

Interact with Codacy API to query code quality issues, vulnerabilities, and coverage insights.

Static code analysis by JetBrains.

AI-powered development assistance for Canva apps and integrations.

MCP server for Mobile Development and Automation - iOS, Android, Simulator, Emulator.

BrowserStack's official MCP server connects Claude, Cursor, VS Code, and other MCP clients to the BrowserStack Test Platform so agents can manage, run, debug, and even fix tests using plain-English prompts. It surfaces BrowserStack's real-device and browser cloud directly inside your IDE or LLM: launch manual app and web test sessions on thousands of real iOS/Android devices and desktop browser/OS combinations, reproduce and debug crashes without local device setup, run and triage automated test suites, and perform accessibility testing against WCAG guidelines. Because context stays in one place, agents can read failing-test output, propose a code fix, and re-run the test in the same conversation — cutting the context-switching between IDE, dashboard, and device lab. Distributed as the official npm package `@browserstack/mcp-server` (Node.js >= 18 required) with one-click setup buttons for VS Code and Cursor via mcp.browserstack.com, plus a hosted remote option. Authentication uses your BrowserStack username and access key from the account settings. Ideal for QA and dev teams that want an AI assistant to drive cross-browser/real-device testing, debug flaky automation, and validate accessibility without leaving their editor or writing boilerplate BrowserStack API calls.

Connect AI assistants with your testing workflow for accessibility, SmartUI, automation.

Boost security via SAST, SCA, Secrets & IaC scanning with Cycode.

Scan projects using GitGuardian's API with 500+ secret detectors to prevent credential leaks.

Find and fix security risks in your code, scan and secure from vulnerabilities and secret leaks.

MCP guardrails coding agents against introducing dependencies with vulnerabilities, malware.

Connect your GraphQL APIs to AI agents.

Turn your GraphQL API into an efficient MCP server with schema intelligence.

Get instant AI-powered access to 300,000+ help topics on DevExpress UI Component APIs.

Structured access to Microsoft's official documentation for code generation and Q&A.

Allows Homebrew users to run Homebrew commands locally.

CLI for interacting with GitKraken APIs, includes MCP server for Jira, GitHub, GitLab.

Work on your code with JetBrains IDEs: IntelliJ IDEA, PhpStorm, etc.

Enable AI coding assistants to debug web pages directly in Chrome.

Free open-source platform for building production-ready AI systems with RAG, evaluations, and fine-tuning.

Ready-made features for AI & human collaboration—use to develop your Liveblocks app quicker.

The DevRev MCP Server lets MCP-capable clients like Claude Desktop, Cursor, and Windsurf search and manage DevRev's unified customer-and-dev platform directly from chat, without switching to the DevRev web app. Its search tool queries across multiple DevRev namespaces at once — issues, tickets, articles, and more — using DevRev's own query syntax (e.g. `product:payments api` scopes a search to a specific product part), so an agent can locate relevant work items in one call instead of paging through separate endpoints. Work-item tools cover listing works filtered by type/owner/related-part, fetching full object detail by ID, and creating new issues or tickets tied to a specific feature or part — useful for turning a bug report surfaced in a support ticket into a linked engineering issue without leaving the assistant. Parts-management tools expose the product hierarchy (products, capabilities, features, epics) so an agent can navigate DevRev's org structure, and a built-in devrev_context() tool returns comprehensive documentation on every available tool, namespace, and parameter — handy for self-onboarding an agent into an unfamiliar DevRev workspace. Authentication uses a DevRev Personal Access Token set as the DEVREV_API_KEY environment variable; the server runs as a local Python process (SSE transport on 127.0.0.1:8888 by default) that Cursor or another client connects to over HTTP. This is an unofficial, community-maintained implementation — DevRev itself has not published a first-party MCP server as of this writing — so treat it as the best available option for AI-assisted DevRev workflows rather than a vendor-supported integration.

Modern product teams connect their AI assistant to Atono to create and update stories, bugs.

Interact with your database through Prisma ORM. Query data, run migrations, explore schema, and generate code using AI-directed Prisma operations.

Get Tailwind CSS class suggestions, documentation lookups, and component generation assistance. Accelerates front-end development with AI-powered Tailwind knowledge.

Access shadcn/ui component documentation, generate component code, and get installation instructions for Radix UI-based component library integration.

Control JupyterLab notebooks from AI assistants. Execute cells, inspect variables, visualize outputs, and manage kernels programmatically.

Run TypeScript and JavaScript scripts with Deno from AI assistants. Execute code, manage packages with JSR, and interact with Deno Deploy.

JavaScript runtime and toolkit MCP server. Run scripts, manage packages, execute tests, and work with Bun's built-in bundler and APIs.

High-performance build system for JavaScript monorepos. Query task graphs, run builds, manage caching, and optimize pipelines with AI.

Smart build system for monorepos. Run tasks, understand project graph, generate code, and optimize CI pipelines across frameworks with AI assistance.

Next-generation frontend build tool MCP. Inspect bundle contents, analyze dependencies, troubleshoot HMR issues, and optimize build configurations.

Rust language server MCP integration. Provides code completion, type inference, refactoring, and diagnostics for Rust projects.

Official Go language server (gopls) MCP integration. Navigate codebases, find usages, refactor Go code, and run tests intelligently.

Python LSP MCP server. Intelligent Python code analysis, autocompletion, linting with pylint/flake8, and formatting with black/autopep8.

Build automation MCP for Java/Kotlin/Android projects. Run tasks, manage dependencies, analyze build scripts, and inspect Gradle project structure.

Java build and dependency management MCP server. Manage POM files, run lifecycle phases, resolve dependencies, and analyze Maven project structure.

Google's build system MCP server. Navigate Bazel build graphs, run targets, manage deps, and analyze large monorepo builds across languages.

Swift language server MCP integration for Apple platform development. Code completion, error diagnostics, and refactoring for iOS/macOS/SwiftUI apps.

Kotlin language server MCP integration. Intelligent code analysis, refactoring, and navigation for Kotlin JVM, Android, and Multiplatform projects.

Manage GitHub Actions workflows, runs, and secrets. Trigger workflows, inspect run logs, manage environment variables, and debug CI failures via AI.

Create and modify Excalidraw diagrams and sketches with AI. Generate architecture diagrams, flowcharts, and wireframes from natural language descriptions.

Project management MCP for software teams using Shortcut (formerly Clubhouse). Manage stories, epics, iterations, and workflows via natural language.

Open-source project management MCP. Manage issues, cycles, modules, and pages in Plane. Self-hostable Jira/Linear alternative with full API access.

End-to-end testing MCP for Cypress. Run test suites, inspect test results, generate test code, and debug failing tests with AI-powered analysis.

JavaScript testing framework MCP for Jest. Run tests, analyze coverage, inspect failures, and generate test code. Works with React, Node, and TypeScript projects.

Next-generation unit testing framework MCP. Run Vitest tests, inspect coverage reports, snapshot testing, and debug failures in Vite-powered projects.

Python testing framework MCP for pytest. Run test suites, analyze failures, measure coverage with pytest-cov, and generate fixture-based test code.

Web design and prototyping MCP for Framer. Create pages, manage components, publish sites, and automate design workflows for interactive prototypes.

Webflow's official MCP server exposes the Webflow Data API — CMS collections, pages, custom code, assets, and site publishing — to AI coding tools and to Webflow's own AI-assisted Designer workflow. The recommended path is Webflow's hosted remote server at mcp.webflow.com/sse: add it to Cursor, Claude Desktop (via the `mcp-remote` bridge), or another MCP client, authenticate with OAuth against your Webflow workspace, then open the "Webflow MCP Bridge App" from the Designer's Apps panel (press E) to sync your live canvas with the AI agent in real time — letting you ask it to analyze recent blog posts for new topic ideas, add internal links between related posts, or build out a new hero section with a responsive CTA. Teams that want a fully self-hosted setup can instead register their own Webflow Bridge App with Admin permissions and run the open-source `webflow-mcp-server` npm package locally (`npx -y webflow-mcp-server@latest`) with a scoped WEBFLOW_TOKEN, giving full control over the OAuth flow and hosting. The server requires Node.js 22.3.0+ for the remote/local hybrid flow. Under the hood it's generated from Webflow's OpenAPI spec via Fern, so it tracks new Data API endpoints automatically as Webflow ships them. Typical use cases lean CMS-heavy: bulk content edits, SEO audits across blog collections, and automating repetitive Designer tasks that would otherwise mean clicking through the visual builder by hand.

Headless CMS MCP for Sanity. Query and mutate content using GROQ, manage datasets, import/export content, and work with Sanity's schema-driven data.

Enterprise headless CMS MCP for Contentful. Manage content types, entries, assets, and locales. Query and publish content across digital channels via AI.

Open-source headless CMS MCP for Strapi. Manage content types, create and update entries, handle media uploads, and configure API permissions via AI.

Manage WordPress sites via the REST API MCP. Create and edit posts, manage pages, handle media, configure plugins, and automate content publishing workflows.

Professional publishing platform MCP for Ghost. Create and manage posts, newsletters, members, and tags. Automate content workflows and analyze publication metrics.

IoT messaging protocol MCP for MQTT. Publish and subscribe to topics, inspect message payloads, and interact with IoT sensors and devices via MQTT brokers.

Durable execution platform MCP for Temporal. Start and query workflows, signal and cancel executions, inspect workflow history, and manage worker processes.

Distributed task queue MCP for Celery. Monitor task execution, inspect queues, revoke and retry tasks, and analyze worker performance and failure patterns.

Make HTTP requests via MCP. GET, POST, PUT, DELETE with custom headers, authentication, cookies, and response parsing. Debug APIs and web services.

Build, test, and debug regular expressions via MCP. Match patterns, extract groups, validate formats, and explain regex syntax across multiple languages.

Parse, validate, and generate cron expressions via MCP. Get human-readable descriptions, next execution times, and validate scheduling syntax.

Encode, decode, and verify JSON Web Tokens via MCP. Inspect JWT claims, validate signatures, generate test tokens, and debug authentication issues.

Parse, transform, and render Markdown documents via MCP. Convert to HTML/PDF, lint formatting, extract headings and links, and validate CommonMark syntax.

Parse, validate, transform, and query YAML and JSON documents via MCP. Convert between formats, run JSONPath/JMESPath queries, and validate against schemas.

Execute GraphQL queries and mutations against any GraphQL API via MCP. Introspect schemas, explore types, run operations, and debug resolver performance.

Work with Protocol Buffer definitions via MCP. Parse .proto files, encode/decode messages, generate language bindings, and inspect gRPC service definitions.

Execute WebAssembly modules via MCP using Wasmtime or WASI. Run sandboxed Wasm code, inspect memory, and test cross-platform compiled applications.

Manage and query databases through Prisma's ORM MCP. Run Prisma Studio queries, manage migrations, inspect schema, and generate type-safe database access code.

TypeScript ORM MCP for Drizzle. Run type-safe queries, manage schema migrations, explore database structure, and generate SQL for multiple database backends.

MCP server for interacting with the Godot game engine. Edit, run, debug, and manage scenes in Godot projects using natural language with your AI assistant.

MCP server for Unity Editor and Unity-built games. Control the Unity Editor, manage assets, run scripts, and interact with your game from your AI assistant.

Generate mathematical animations using Manim directly from your AI assistant. Create explanatory videos, data visualizations, and animated diagrams with natural language.

Run Bruno API collections from your AI assistant. Execute requests, manage environments, inspect responses, and run collections as part of your testing workflow without opening the Bruno GUI.

Connect to Insomnia API workspaces from your AI assistant. Execute stored requests, manage environments, import/export API collections, and run API tests with full response inspection.

Hono web framework MCP server for building and testing ultra-fast API routes. Scaffold endpoints, generate middleware, test route handlers, and deploy to Cloudflare Workers or other edge runtimes with AI assistance.

FastAPI MCP server that exposes your FastAPI application's routes as MCP tools automatically. Turn any FastAPI app into an AI-accessible tool suite — query endpoints, test with parameters, and inspect OpenAPI schemas.

Gradle build system MCP server for JVM and Android projects. Run tasks, inspect dependencies, check build variants, manage Android SDK configurations, and debug build failures through your AI assistant.

Sketch design tool MCP server via Sketch Assistant. Inspect artboards, extract design tokens, export assets, query layer properties, and sync design system components across files via Sketch JavaScript API.

Zeplin design handoff MCP server. Access design specs, extract CSS properties, retrieve component documentation, query style guides, and manage project assets for developer handoff workflows via Zeplin API.

InVision design prototyping MCP server. Access prototypes, retrieve screen comments and feedback, export assets, query design system (DSM) components, and manage project versions via InVision API.

Payload CMS MCP server for Next.js-native headless CMS. Query collections, manage globals, upload media, run hooks, and interact with Payload local API for TypeScript-first content management workflows.

Keystone.js headless CMS and application framework MCP server. Query and mutate content via GraphQL, manage lists and relationships, access Keystone Admin UI data, and run custom hooks via Keystone API.

Ethereum development environment via Hardhat. Compile and deploy Solidity contracts, run tests on local Hardhat Network, generate coverage reports, and interact with deployed contracts.

Unreal Engine game development via MCP. Control the Unreal Editor, spawn and manipulate actors, run Blueprint scripts, trigger level streaming, execute console commands, and automate asset pipeline tasks.

Test and evaluate LLM prompts with Promptfoo. Run automated evaluations, compare model outputs, detect regressions, and find security vulnerabilities in AI applications.

Browse, use, and share prompts from LangChain Hub. Discover community prompts, pull templates into your applications, and publish your own prompt library entries.

LLM testing framework MCP integration. Run automated evaluations on LLM outputs, measure hallucination rates, check factual accuracy, and CI/CD integration for AI quality gates.

Connect to Dev.to developer community via MCP. Search articles, fetch user profiles and followers, query tags and reading lists, retrieve comment threads, and publish posts to the developer writing platform.

Connect to Hoppscotch open-source API development platform via MCP. Access collections, environments, history, and team workspaces. Import OpenAPI specs, run requests, and share API testing workflows across teams.

Integrate with Autodesk BIM 360 construction management platform via MCP. Access 3D model versions, issue tracking, RFI and submittal logs, quality and safety checklists, document sheets, meeting minutes, and project member permissions. Automate BIM coordination workflows and pull clash detection reports.

Nx monorepo build system MCP — query project graph, run targeted builds and tests, manage dependencies between apps and libs, inspect affected projects, and leverage Nx caching and distributed task execution.

Turborepo monorepo task runner MCP — query pipeline configurations, run tasks with caching, inspect workspace dependencies, manage remote cache settings, and speed up builds across your JavaScript and TypeScript monorepo.

Backstage internal developer portal MCP — search the software catalog, retrieve service ownership and metadata, query TechDocs documentation, list registered APIs and components, check scaffolded templates, and explore your engineering ecosystem.

ROS / ROS2 robot control MCP server — publish and subscribe to ROS topics, call services, query node graph, control robot actuators, read sensor data, and interface with robotic systems using natural language commands. Supports ROS Noetic and ROS2 Humble/Iron.

Microsoft Dynamics 365 Finance & Operations MCP server — IntelliSense-like code navigation for X++ objects, intelligent EDT suggestions, AI-driven table/form generation, and pattern-based code completion. Covers standard and custom indexed D365 F&O objects.

Open-source project management via Plane's API. Create and track issues, manage cycles and modules, organize projects, and run agile sprints. Self-hostable alternative to Jira with full MCP integration.

StackBlitz Bolt AI app builder integration via MCP. Create full-stack web applications with a single prompt, manage project files in the WebContainer runtime, install npm packages, preview running apps, and export production builds. Supports React, Vue, SvelteKit, and more.

Lovable AI-powered full-stack app builder via MCP. Generate React + Supabase applications from natural language, manage project repos, trigger build deployments, update component code, and integrate databases. Ideal for rapid SaaS prototyping without writing boilerplate.

Vercel v0 generative UI design tool via MCP. Generate shadcn/ui React components from text descriptions, refine existing UI components, export clean TypeScript code, and integrate with Vercel deployments. Produces production-quality Tailwind CSS components instantly.

PX4 flight controller integration via MCP. Read MAVLink telemetry streams, arm and disarm vehicles, set flight modes, send position setpoints, read sensor data, and access PX4 parameter trees. Supports SITL simulation for testing autonomous drone mission logic from your AI assistant.

ArduPilot open-source autopilot integration via MCP. Connect to ArduCopter, ArduPlane, and ArduRover via MAVLink. Read GPS, IMU, and battery telemetry. Upload and execute mission waypoints, set flight parameters, trigger automated takeoff/land, and inspect AHRS attitude data.

OpenXR VR/AR runtime integration via MCP. Query connected headset capabilities, enumerate eye tracking and hand tracking inputs, read pose data from XR spaces, and enumerate available extensions. Useful for debugging and testing OpenXR applications across Meta Quest, HTC Vive, Valve Index, and Windows Mixed Reality.

Autodesk AutoCAD integration via MCP. Read and write DWG/DXF drawing files, extract entity geometry, query layer structure, search for blocks and attributes, export to PDF or image formats, and run AutoLISP routines programmatically. Supports AutoCAD 2020+ via COM API on Windows.

SOLIDWORKS 3D CAD integration via MCP. Open and inspect part and assembly files, read feature trees and design parameters, export STL/STEP/IGES, query mass properties, run interference detection, and interact with SOLIDWORKS macros via the COM API. Requires SOLIDWORKS 2020+ on Windows.

FreeCAD open-source parametric CAD integration via MCP. Create and modify 3D models using FreeCAD's Python API, run Part Design and Sketcher operations, export to STEP/IGES/STL, query model properties, and automate drawing generation. Cross-platform and completely free.

Official Anthropic Claude connector for Autodesk Fusion 3D CAD/CAM software. Design and modify 3D models, create parametric sketches, run simulations, generate toolpaths for CNC machining, and manage design files through natural language conversations with Claude. Requires an active Fusion subscription.

Official Anthropic Claude connector for SketchUp 3D modeling. Turn Claude conversations into starting points for architectural design, interior layouts, urban planning models, and 3D visualization. Create geometry, apply materials, generate scenes, manage groups and components, and export to various formats directly from natural language prompts.

SAP ABAP development tools via MCP with full CRUD support, JWT/XSUAA, and service-key authentication. Supports SAP BTP ABAP Cloud and On-Premise ECC/S/4HANA. Read, create, modify, and test ABAP programs, classes, and function modules; run ABAP unit tests; and navigate ADT objects in live SAP systems from AI assistants.

Universal CAD control MCP server supporting AutoCAD, GstarCAD, and ZWCAD through natural language. Draw lines, arcs, circles, and polylines; create and modify layers; insert blocks; run AutoLISP commands; query object properties; and export drawings to DXF/DWG formats — all from AI conversation.

EPLAN Electric P8 and EEC PRO 2026 automation via MCP. Drive EPLAN P8 directly from a local MCP server using AI-assisted script generation. Includes a documentation scraper and local RAG indexer for EEC Pro, plus remote MCP servers on Cloudflare Workers exposing indexed electrical engineering documentation via semantic search.

Appsmith open-source internal tools builder MCP server. Query datasources, trigger workflows, manage apps and pages, and interact with Appsmith widgets and APIs.

Budibase low-code platform MCP server. Build and query internal tools, manage data sources, automate workflows, and interact with your self-hosted or cloud Budibase apps.

ToolJet open-source low-code platform MCP server. Connect to databases and APIs, run queries, trigger app actions, and manage your ToolJet workspace programmatically.

Bubble no-code app builder MCP server. Interact with Bubble's Data API and Workflow API to query and modify app data, trigger workflows, and manage user records.

Glide no-code app builder MCP server. Read and write data from your Glide apps, trigger actions, manage tables, and build AI-powered data integrations with Glide's API.

FlutterFlow visual app builder MCP server. Query project structure, access generated Dart code, manage Firebase collections, and trigger FlutterFlow build actions.

Draftbit visual React Native app builder MCP server. Access component libraries, manage screens and navigation, connect REST APIs, and export project code.

Thunkable no-code mobile app builder MCP server. Manage components, data sources, and variables in your Thunkable projects, and query app analytics.

Generate and manipulate Three.js 3D scenes, geometries, materials, lights, and animations via natural language.

Create D3.js data visualizations — bar charts, line charts, force graphs, and custom SVG renders.

Interact with Observable notebooks — run cells, read data, and create visualizations programmatically.

Parse, inspect, and generate Lottie animation JSON files for web and mobile applications.

Generate Apache ECharts configurations for line, bar, pie, radar, candlestick, and geo map visualizations.

Automate Roblox Studio scripting — generate Luau scripts, place objects, configure game services, and run Studio commands.

Scaffold and query Vercel AI SDK streaming apps, route handlers, and multi-step agent implementations.

Generate and deploy full-stack web apps via Bolt.new — StackBlitz's AI-powered WebContainer dev environment for instant in-browser project creation.

Connect to Speckle — the open-source data platform for AEC. Receive and send BIM/CAD data, manage streams, and query geometry and metadata across design tools.

Manage Perforce Helix Core version control — check out files, submit changelists, sync depots, manage users, and query revision history at enterprise scale.

Manage artifacts in Sonatype Nexus Repository — search Maven/npm/Docker components, check vulnerability data via OSS Index, and manage repository policies.

Integrate with CodeSignal engineering assessments — retrieve candidate results, scoring reports, and skill certifications via CodeSignal API for hiring workflows.

Pack your entire repository into a single AI-friendly file. Prepare codebases for LLM analysis and context windows.

AI-powered codebase search and Q&A. Ask questions about any GitHub/GitLab repo in natural language.

Code-coupled documentation platform. Keep docs automatically synced with code changes and access them via AI.

Stacked pull requests and code review for GitHub. Manage PR stacks, reviews, and merges programmatically.

Inngest serverless event-driven functions and background jobs — trigger, monitor, and manage workflows via MCP.

Trigger.dev background jobs and long-running tasks — create, monitor, and manage jobs from AI assistants.

Val Town serverless JavaScript platform — create, run, schedule, and manage vals (functions) from your AI assistant.

Deno Deploy edge serverless platform — deploy, manage, and monitor JavaScript/TypeScript functions globally.

Django web framework integration — inspect models, run management commands, query ORM, and manage migrations.

Ruby on Rails integration — inspect models, run console commands, manage migrations, and explore routes.

Laravel PHP framework integration — artisan commands, Eloquent ORM queries, route inspection, and queue management.

Browse GitHub repositories, explore directory structures, and view file contents through AI assistants with full MCP protocol support.

Turn any GitHub repository into an MCP server. Chat with codebases and documentation through natural language queries.

Git repository MCP server for reading, searching, and manipulating Git repositories through natural language with LLM assistants.

Run an MCP server directly on ESP32 microcontrollers for embedded IoT AI applications and sensor data.

Control Z-Wave smart home devices — locks, lights, thermostats, and sensors — through AI-powered automation.

Interact with Ray clusters for distributed ML training, hyperparameter tuning, data processing, and AI serving at scale.

Query EdgeDB — the next-generation graph-relational database with a built-in type system, schema migrations, and EdgeQL through AI agents.

Scan code, containers, and infrastructure for vulnerabilities using Snyk with automatic fix suggestions, license compliance checking, and developer security workflows.

Integrate Checkmarx application security testing for static code analysis (SAST), software composition analysis (SCA), IaC security scanning, and API security testing in CI/CD.

Connect to Veracode application security platform for static analysis, dynamic analysis (DAST), software composition analysis, penetration testing management, and policy compliance.

Access SonarCloud cloud-based code quality and security platform for continuous code inspection, technical debt tracking, security hotspots, and code coverage analysis in CI/CD.

Integrate Codecov code coverage platform for test coverage reporting, coverage trend analysis, pull request comments, flagging, and team coverage metrics across repositories.

Integrate Code Climate automated code review for maintainability, test coverage, code smells, duplication detection, and velocity metrics across engineering teams.

Access Coveralls test coverage service for coverage history tracking, pull request comments, badge generation, and team coverage trend analysis across multiple languages.

Integrate Trunk code quality meta-linter for running multiple linters, formatters, and security scanners with unified configuration, caching, and CI/CD integration.

Connect to Depot remote Docker build service for 40x faster Docker builds with shared caching, native ARM support, and drop-in compatibility with existing CI/CD pipelines.

Integrate Earthly reproducible build tool for containerized builds with Makefile-like syntax, local and CI caching, monorepo support, and language-agnostic build definitions.

Connect to Tilt smart rebuilds for Kubernetes development workflows — automatic live updates, dependency graphs, health monitoring, and team dev environment standardization.

Run 200,000+ Hugging Face models via Inference API — text generation, image classification, speech recognition, translation, summarization, and embedding generation.

Deploy and run Python functions on Modal serverless GPU infrastructure — model fine-tuning, batch inference, scheduled jobs, and web endpoints with pay-per-use GPU pricing.

Developer-friendly localization via Tolgee API — manage translation keys and their values across multiple languages, upload and export translation files in various formats, trigger machine translation suggestions, manage screenshots and context for translators, access project statistics, and integrate with CI/CD pipelines for automated translation delivery.

Scalable build system integration via Bazel — query build targets and dependency graphs, run incremental builds and tests with caching, retrieve build event protocol data, analyze build performance and bottlenecks, manage remote execution and caching configuration, query workspace rules and macro definitions, and integrate with CI/CD systems for hermetic, reproducible builds.

Manage infrastructure as code via Terraform CLI and the Terraform Cloud API — run plan, apply, and destroy operations, query state files and resource inventory, manage workspaces and variable sets, access run history and logs, handle module registry, manage Sentinel policies, query cost estimates, manage team permissions, and integrate IaC workflows into GitOps and CI/CD pipelines.

Deploy and manage Cloudflare Workers serverless functions via the Cloudflare API — deploy worker scripts, manage KV namespaces and bindings, query R2 storage buckets, handle Durable Objects, manage D1 databases, configure routing and triggers, access analytics for request volume and latency, manage secrets and environment variables, and handle Wrangler-based deployment workflows.

Manage Netlify deployments and JAMstack workflows via the Netlify API — deploy sites from Git, manage build hooks and deploy previews, configure environment variables and secrets, query deploy logs and build status, manage domain DNS and SSL certificates, configure edge functions, access form submissions, manage split testing, pull bandwidth and function invocation analytics, and trigger rollbacks.

Manage Vercel deployments and frontend infrastructure via the Vercel API — deploy projects from Git, manage environment variables across environments, query deployment logs and build output, configure custom domains and SSL, manage edge configs and edge middleware, access serverless function logs, pull project analytics, manage team members and access tokens, and handle preview deployment workflows.

Manage secrets and environment configurations via the Doppler API — fetch secrets for any project, config, and environment; inject environment variables into local dev and CI/CD pipelines; sync secrets across staging, production, and review environments; manage access controls and service tokens; audit secret access logs; rotate API keys; and build automated secret management workflows.

Access Infisical open-source secrets management via their API — read and write secrets across projects and environments; manage secret folders, tags, and overrides; pull secrets for dynamic injection into apps and CI/CD; configure service tokens and machine identities; audit secret change history; sync with AWS Secrets Manager, Azure Key Vault, and GCP Secret Manager; and manage team permissions.

Sync and manage .env files across teams via Dotenv Vault — push and pull encrypted .env files to the vault, manage environment-specific configs for development, staging, and production, share secrets with teammates securely, generate .env.vault encrypted backup files, integrate with CI/CD pipelines for automatic secret injection, and audit who accessed which environment variables.

Integrate Aider AI pair programming tool via its local API — start and manage Aider sessions on local codebases, send natural language coding instructions and receive diffs, manage file context additions and removals, switch between LLM backends, access commit history created by Aider, retrieve session logs and change summaries, and build automated code generation and refactoring pipelines using Aider as a code execution engine.

Control Cognition AI's Devin autonomous software engineer via their API — create and assign coding tasks with natural language specifications, retrieve task status and progress updates, access session transcripts and code outputs, review PRs generated by Devin, manage knowledge base items and playbooks, pull task completion metrics and time tracking, and integrate Devin into engineering workflows for automated feature development and bug fixing.

Integrate Continue open-source AI code assistant via their extension API — manage custom model configurations, retrieve context providers and slash commands, access codebase indexing status and embeddings, configure prompt templates and system prompts, pull usage analytics and model performance metrics, manage team-shared configs via config.yaml, and build custom Continue extensions and context providers for specialized development workflows.

Automate GitHub issue resolution via Sweep AI's coder bot API — create Sweep tasks from issue descriptions, retrieve PR status and code change summaries, access Sweep's codebase understanding and search results, manage sweep.yaml configuration files, pull task completion metrics, access refactoring and test generation workflows, and integrate Sweep into CI/CD pipelines for automated code maintenance and technical debt reduction.

Python Package Index integration. Search packages, get dependency info, check vulnerability advisories, and manage Python project dependencies.

npm package registry integration. Search, inspect, and analyze JavaScript packages. Get download stats, dependency trees, and security advisories.

Rust package registry integration. Discover, search, and analyze Rust crates. Access documentation, version history, dependencies, and download statistics.

Unified developer documentation browser. Search across 100+ documentation sets including MDN, Node.js, React, Python, Ruby, and more in one integration.

AI-powered code explanation and documentation tool. Get instant explanations for any code snippet, function, or codebase section in plain English.

Interact with Lucidchart diagrams via the Lucidchart API — create and update flowcharts, org charts, network diagrams, and ER diagrams, manage document libraries, query shape and connector data, export diagrams to PNG/SVG/PDF, share documents with teams, and integrate visual diagram generation into engineering and business workflow automation.

Interact with Whimsical via the Whimsical API — create and update flowcharts, wireframes, mind maps, and sticky note boards, retrieve document structures, share files with teams, export diagrams, manage workspace folders, and integrate automated diagramming and visual brainstorming into product design and engineering planning workflows.

Search technical documentation and code answers via Phind — query developer-focused search for programming questions, retrieve code examples with explanations, get answers from Stack Overflow, GitHub, and official docs, access Phind's AI-synthesized responses for technical topics, and integrate intelligent developer search into coding assistants and documentation tools.

Manage Vagrant development environments via the Vagrant CLI — create and provision virtual machines from Vagrantfiles, start, stop, and destroy VMs, retrieve VM status and SSH connection info, run provisioning scripts, manage snapshots, list box inventories, and automate local development environment lifecycle with AI-assisted environment orchestration.

Extend GitLab project management and CI/CD via the GitLab REST and GraphQL APIs — manage issues, epics, and milestones beyond the base GitLab MCP, access advanced merge request workflows, retrieve runner status and CI pipeline details, query deployment environments and audit events, manage labels and boards, access time tracking data, and build enterprise GitLab automation workflows.

The Memory Bank MCP server turns the Cline Memory Bank pattern into a centralized remote service accessible from any MCP client. Instead of storing project context in local files that get lost between sessions, this server exposes a structured multi-project memory system over the MCP protocol — read, write, update, and list memory bank files across isolated project directories. It enforces consistent file structure (projectBrief, activeContext, progress, systemPatterns, techContext, codebaseContext), prevents path traversal with strict validation, and keeps each project's context cleanly separated. Works seamlessly with Cline, Roo Code, Cursor, Windsurf, and Claude Desktop. Configure via the MEMORY_BANK_ROOT environment variable pointing to your central storage directory. Install with a single npx command; no backend infrastructure required beyond a shared filesystem. With 900+ GitHub stars and active community adoption, Memory Bank MCP is the standard for persistent AI coding context across sessions and IDE switches.

Task Master AI is the most widely-used AI-driven task management framework for software development, with 12,000+ GitHub stars and a purpose-built MCP server that plugs directly into Claude Desktop, Cursor, Windsurf, and any MCP-compatible coding agent. Created by eyaltoledano, it converts high-level project requirements into structured, dependency-tracked development tasks that an AI agent can plan, execute, and update autonomously across coding sessions. The MCP server exposes tools to initialize a project from a PRD or specification document, parse and break down complex tasks into subtasks, list all tasks with their status and dependencies, get next recommended task based on dependency resolution, mark tasks as in-progress or done, update task details and acceptance criteria, expand single tasks into subtasks with AI-generated breakdowns, and view the full task dependency graph. Task Master AI integrates tightly with Claude's extended thinking for complex planning and supports Perplexity for research-backed task breakdowns. Install globally via npm, then run `task-master init` to scaffold your project. Configure the MCP server in your client's JSON config pointing at the globally installed binary. Task Master AI dramatically improves autonomous coding agent quality by keeping Claude focused on the correct next task, preventing scope drift, and maintaining context across long multi-session projects.

MCP Shrimp Task Manager is an intelligent task management server built specifically for AI coding agents — emphasizing chain-of-thought planning, reflection, and style consistency across development sessions. It converts natural language project descriptions into structured, dependency-tracked development tasks with iterative refinement built in. Rather than treating tasks as a flat to-do list, Shrimp models tasks with explicit dependencies, execution state, and reasoning traces so the AI agent can pick up exactly where it left off across sessions. Supports Cursor, Roo Code, Windsurf, Claude Code, and any MCP-compatible client. Features include an optional GUI for visualizing task graphs, multi-language template support (English, Chinese, and more), configurable data directory, and a demo video showing end-to-end agent-driven development. With 2,100+ GitHub stars and a dedicated documentation site, Shrimp Task Manager is one of the most-starred agentic task management MCP servers available. Install by cloning the repo, running npm install + npm run build, and pointing your MCP client at the built index.js.

AI Data Parser is a credit-based document-parsing API that converts PDFs, images, invoices, receipts, resumes, and unstructured forms into schema-guaranteed JSON via a single POST request. Designed for AI agents and automation pipelines, it accepts your target JSON schema and guarantees the response validates against it — eliminating the fragile post-processing step that breaks most extraction workflows. Free tier ships 50 credits with no card required. Paid packs ($9/500 credits up to $99/10,000) mean you pay per document, not per month — ideal for agent workflows with variable volume. The API ships with OpenAPI spec, llms.txt, and copy-paste tool definitions for OpenAI and Anthropic tool use, so integration into Claude or GPT-4o agents takes minutes. An MCP server is on the roadmap (planned Q3 2026), which will let Claude Desktop, Cursor, Windsurf, and any MCP-compatible coding agent call the parser as a native tool — ask it to "parse this invoice" and get back clean JSON without any boilerplate. Use cases: invoice data extraction, receipt parsing, resume screening, bank statement normalization, contract field extraction, and form digitization.