MCP Servers for Windsurf

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

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

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

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

Knowledge graph-based persistent memory system. Store and retrieve contextual information.

Dynamic and reflective problem-solving through thought sequences.

Time and timezone conversion capabilities for AI assistants.

The Apify MCP server gives AI agents access to 6,000+ ready-made cloud scrapers, crawlers, and automation tools on the Apify Store — no infrastructure required. Connect to Apify Actors that extract data from social media platforms (Instagram, TikTok, LinkedIn), search engines (Google, Bing), e-commerce sites (Amazon, eBay), maps (Google Maps), and virtually any website. Each Actor runs in the cloud with managed proxies, browser fingerprinting, and anti-bot bypass built in. Use the Apify MCP server to query Actors by task, stream results directly into your AI context, run custom scraping Actors from your Apify account, and chain multiple data extraction steps in a single workflow. Supports tool filtering to expose only the Actors you need, and integrates with Apify's RAG web browser Actor for retrieval-augmented generation use cases.

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.

AWS Labs maintains a monorepo of specialized, open-source MCP servers that bring AWS best practices directly into AI-assisted development workflows, spanning infrastructure, data, AI/ML, cost management, and healthcare/life-sciences domains. Rather than one monolithic server, the project ships dozens of focused servers you install individually depending on the task: the AWS Documentation MCP Server for real-time official docs and API references, dedicated servers for Terraform/CDK/CloudFormation infrastructure-as-code, container and serverless platforms (ECS, EKS, Lambda), SQL/NoSQL databases (DynamoDB, RDS, Aurora), search and analytics (OpenSearch), messaging (SQS/SNS), and cost/billing analysis. Most servers install via uvx with a package name like awslabs.aws-documentation-mcp-server, run locally over stdio, and use standard AWS credential chains (IAM roles, profiles, or access keys) rather than exposing raw account credentials to the model. AWS also now offers a managed, remote "AWS MCP Server" (in preview) that combines full API coverage with pre-built agent SOPs, syntactically validated API calls, and complete CloudTrail audit logging for teams that want centralized governance instead of running servers locally. The Getting Started with Kiro/Cursor/VS Code/Claude Code sections in the repo provide one-click install configs for each server, making it straightforward to wire up only the AWS services a given project actually touches.

Cloudflare's official mcp-server-cloudflare repo ships 13+ remote, domain-specific MCP servers rather than one monolith — Documentation, Workers Bindings (storage/AI/compute primitives), Workers Builds, Observability (logs/analytics), Container sandboxes, Browser Rendering (fetch pages, convert to markdown, screenshots), Logpush health, AI Gateway (prompt/response search), Audit Logs, DNS Analytics, Digital Experience Monitoring, Cloudflare One CASB, and GraphQL analytics, each hosted at its own `*.mcp.cloudflare.com/mcp` endpoint over Streamable HTTP (SSE is deprecated but still supported). For broad, code-execution-style access across many Cloudflare products at once, Cloudflare separately publishes a Code Mode server at mcp.cloudflare.com (repo: cloudflare/mcp) — pick domain-specific servers when you want curated, typed tools for one product area (e.g. just Workers or just DNS), and Code Mode when you want fewer, more general-purpose tools. Clients without native remote-MCP support connect via `npx mcp-remote https://<subdomain>.mcp.cloudflare.com/mcp` in their config; clients like the Cloudflare AI Playground accept the URL directly. OpenAI Responses API integration is also documented, requiring a scoped Cloudflare API token per server (e.g. Browser Rendering needs specific dashboard-generated permissions). Typical use: "show me why my Worker is erroring" pulls real-time observability data, or "summarize this URL" drives the Browser Rendering server to fetch and convert a live page to markdown.

Automate browser interactions in the cloud (web navigation, data extraction, form filling, and more).

The Firecrawl MCP server gives your AI assistant the ability to crawl, scrape, and extract structured data from any website — turning raw HTML into clean, LLM-ready Markdown or JSON in seconds. Built by the Firecrawl team, it exposes tools for single-page scraping, deep site crawls (following internal links), and batch URL extraction, all with JavaScript rendering handled automatically so dynamic content is never missed. Developers use it to automate competitive research, build live knowledge bases, extract pricing tables, monitor documentation changes, or feed structured web data into RAG pipelines — all through natural-language prompts without writing a single scraper script. The Firecrawl MCP server handles rate limiting, retries, and proxy rotation behind the scenes. Authentication requires a Firecrawl API key (free tier available). Install with: npx firecrawl-mcp. Works with Claude Desktop, Cursor, VS Code, and any MCP-compatible client. With Firecrawl, any public webpage becomes a structured data source your AI can reason over, compare, and act on — making it the go-to MCP server for web data extraction workflows.

Exa's official MCP server connects AI assistants to a search engine purpose-built for AI, using neural embeddings to match on meaning rather than keywords so agents get clean, ready-to-use content instead of a page of blue links to re-parse. The default tool set covers web_search_exa for quick topical lookups and web_search_advanced_exa for full control over domains, date ranges, and content filters, plus specialized tools for code_search (searching real-world code and GitHub), company_research (building company profiles, competitor lists, and financials), crawling/web_fetch (pulling clean content from a specific URL), people_search and linkedin_search (public professional-profile lookups), and deep_researcher_start/check for long-running multi-step research tasks backed by Exa's Research API. The server is hosted at https://mcp.exa.ai/mcp — no local process to run — and connects via one-line setup in Cursor, VS Code, Claude Code, Claude Desktop (available as a native Connector), Codex, OpenCode, Windsurf, and Antigravity, authenticated with an EXA_API_KEY from the Exa dashboard. Tool exposure is tunable per client via a ?tools= query parameter on the endpoint URL, letting teams ship narrow, purpose-built configurations (e.g. company-research-only or LinkedIn-only agents) instead of exposing the full surface, and Exa ships ready-made Claude Skills/agent definitions for common patterns like company research and people search with built-in query-variation and token-isolation guidance.

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.

The Notion MCP Server is the official integration from Notion that connects AI assistants directly to your Notion workspace via the Notion REST API. With 3,500+ GitHub stars, it is the canonical MCP tool for bringing Notion's knowledge management capabilities into Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. The server exposes a rich set of tools: search your entire workspace by keyword and return matching pages and databases; retrieve full page content and block trees; create new pages inside any parent page or workspace section; update, append, or delete block content on existing pages; list all databases your integration has access to; query database entries with filter and sort parameters; retrieve individual blocks or nested children by block ID; and add comments to pages. Authentication uses a Notion integration token — create an internal integration at notion.so/my-integrations, share specific pages or databases with it, and set NOTION_API_KEY in your environment. Install with a single npx command. The Notion MCP Server is especially powerful for AI workflows that span documentation retrieval, project planning, and knowledge capture — Claude can read product specs from Notion, draft new pages from conversation output, log structured data into databases, and search across thousands of notes without any manual copy-paste.

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.

The Slack MCP server (built by Ivan Korotovsky) connects AI assistants like Claude, Cursor, and Windsurf directly to Slack workspaces, enabling conversational access to your team communication channels without requiring workspace admin approval for a bot install. Its standout feature is a "no permission" stealth mode — it authenticates using your own personal Slack session tokens (xoxc/xoxd, or a stored browser session) rather than requiring a Slack App with OAuth scopes, so it works even in locked-down workspaces where you cannot create bots. It also supports full OAuth Bot Token auth and Enterprise/GovSlack deployments for teams that prefer a conventional app install. Tools exposed include reading channel and DM/group-DM history with smart pagination, searching messages across the workspace, posting messages and thread replies, listing channels and users, and adding reactions. Common use cases include automating standups by posting summaries directly to team channels, searching past Slack conversations to surface decisions or context, monitoring specific channels for keywords or alerts, and drafting replies to thread discussions — all from natural-language prompts. Supports both Stdio and SSE transports plus proxy configuration for corporate networks. Install with: `npx slack-mcp-server@latest --transport stdio`. A separate official-style integration exists from Zencoder (@zencoderai/slack-mcp-server) for teams that prefer standard Bot Token OAuth over session-token auth. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

The HubSpot MCP Server is HubSpot's official Model Context Protocol integration, giving AI assistants direct read and write access to your CRM data — contacts, companies, deals, tickets, and pipelines — without leaving your conversation. Built and maintained by HubSpot, the server connects to the HubSpot APIs using your private app access token and exposes tools that let Claude search contacts by email or name, retrieve company records, create and update deal stages, log notes on CRM objects, list pipeline stages, and query ticket queues. This eliminates the round-trip of switching tabs to look up a contact or manually log an interaction. Setup requires a HubSpot account with a Private App — create one at app.hubspot.com/private-apps, grant the scopes your workflow needs (contacts read/write, crm.objects.deals, crm.objects.tickets), and copy the generated access token into your environment as HUBSPOT_ACCESS_TOKEN. Once connected, Claude can power CRM workflows like: "Find all contacts at Acme Corp and list their recent activity," "Create a new deal in the Prospecting stage for $15,000," or "Log a meeting note on this contact." The server supports Claude Desktop, Cursor, Windsurf, Cline, and any MCP-compatible client. It is especially valuable for sales, RevOps, and support teams who want AI-assisted CRM work without manual data entry or tab-switching.

The Stripe MCP server is Stripe's official Model Context Protocol integration, giving AI assistants direct access to your Stripe account through natural-language interactions. Built and maintained by Stripe as part of the stripe/agent-toolkit repository, this server exposes payment infrastructure as callable MCP tools: create and retrieve customers, generate payment intents, list products and prices, manage subscriptions, query invoice history, and look up charge details — all from within Claude, Cursor, or any MCP-compatible AI client. The Stripe MCP server is designed for indie developers, fintech teams, and SaaS operators who want to query payment data, draft refund workflows, debug failed charges, or generate revenue reports without opening the Stripe Dashboard. Authentication requires a Stripe Secret Key (sk_live_... for production, sk_test_... for sandbox testing). Real-world workflows include asking Claude to summarize yesterday's failed payments, list customers whose subscriptions expire this week, generate subscription cohort breakdowns, or draft dunning email copy based on at-risk MRR segments — all grounded in live Stripe data. Install via npm as part of the agent-toolkit package. Works with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

The MongoDB MCP server is the official Model Context Protocol integration from MongoDB, giving AI assistants conversational access to both MongoDB Community Server and MongoDB Atlas cloud databases. With this MCP server, developers can ask Claude, Cursor, or Windsurf to query collections with natural-language filters that translate to MongoDB query syntax, run aggregation pipelines for analytics, insert and update documents, inspect collection schemas and index definitions, list databases and collections, and even manage Atlas clusters — all without leaving the AI interface. Common workflows include debugging slow queries by asking the AI to explain query plans, generating sample data for development environments, building dynamic dashboards by asking Claude to aggregate and summarize collection data, and automating routine maintenance like dropping orphaned indexes or counting documents matching conditions. The server works with MongoDB Atlas (via Atlas connection string) and self-hosted MongoDB 4.4+ instances. Authentication uses a standard MongoDB URI. Install with: `npx mongodb-mcp-server`. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and all MCP-compliant clients. With official backing from the MongoDB team and strong community adoption, this is the definitive MCP server for MongoDB AI integration.

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.

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.

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.

The Supabase MCP server brings the power of your Supabase backend directly into your AI assistant, enabling conversational access to database, authentication, storage, and edge function features. With this server, developers can ask Claude or Cursor to query Postgres tables, inspect database schemas, manage user auth flows, upload or read files from Supabase Storage buckets, and test Edge Functions without ever leaving their IDE or chat window. This dramatically accelerates backend development and debugging by letting AI agents both read live state and perform safe, constrained operations against your project. Common use cases include asking the AI to "generate a SQL migration for a new profiles table and apply it", "check why the last auth webhook failed in the logs", or "list all users who signed up today and export their emails". It requires a Supabase Management API token and your project reference ID to authenticate. Perfect for full-stack developers building Next.js apps with Supabase, it effectively turns your AI into an expert database administrator and backend co-pilot that inherently understands your project's specific schema and row-level security policies.

The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.

Query your ClickHouse database server for analytics workloads.

Neo4j graph database server (schema + read/write-cypher) and graph database backed memory.

Search, Query and interact with data in your Milvus Vector Database.

Embeddings, vector search, document storage, and full-text search with the open-source AI application database.

The Vercel MCP server is a powerful Model Context Protocol integration that allows AI assistants like Claude, Cursor, and Cline to interact directly with your Vercel infrastructure. It exposes essential platform capabilities as AI-callable tools, meaning you can manage projects, trigger deployments, inspect build logs, and configure custom domains via natural language prompts. For frontend developers and DevOps teams working within the Vercel ecosystem, this eliminates the need to constantly context-switch between an IDE, terminal, and the Vercel dashboard. You can simply ask your AI agent to "check the status of the latest production deployment", "fetch the build logs for the staging environment and identify the Next.js hydration error", or "list all environment variables for the current project". By bridging the gap between your codebase and your hosting platform, the Vercel MCP server turns your AI assistant into an embedded DevOps engineer capable of diagnosing build failures and managing serverless deployments in real time. Vercel ships this as an official hosted (remote) MCP server at https://mcp.vercel.com — there is no package to install locally. Connect an MCP client to that URL and authenticate through the browser-based OAuth flow, which scopes access to the Vercel teams and projects your account can already reach rather than a long-lived Personal Access Token. For example, add it to Claude Code with `claude mcp add --transport http vercel https://mcp.vercel.com`, then complete the OAuth consent screen; the repo vercel/vercel-mcp-overview is the official public overview of this server, with full docs at vercel.com/docs/mcp/vercel-mcp.

The Netlify MCP Server is Netlify's official Model Context Protocol integration (netlify/netlify-mcp), acting as a bridge between AI coding agents and the Netlify API/CLI so they can create, build, deploy, and manage Netlify projects using natural-language prompts instead of manual dashboard clicks or hand-written API calls. Installed via `npx -y @netlify/mcp` (requires Node.js 22+, and the Netlify CLI installed globally for the best experience), it connects to Windsurf, Cursor, Claude Desktop/Code, VS Code Copilot, Cline, Warp, LM Studio, and any other MCP-compatible client, with one-click install links published for several of them. Core capabilities include creating and managing sites, triggering and monitoring deploys, modifying access controls and team permissions, installing or uninstalling Netlify extensions, fetching user/team/site metadata, and creating or updating environment variables and secrets. Authentication runs through the Netlify CLI's existing login session, so agents inherit whatever account/team access the developer already has rather than requiring a separately scoped token. Typical use: ask Claude to "deploy the current branch as a preview and give me the URL" or "add a STRIPE_SECRET_KEY environment variable to the production site" and the agent executes the equivalent Netlify CLI/API calls directly, which is useful for developers who want deploy and config management folded into an AI pair-programming workflow instead of context-switching to the Netlify dashboard.

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.

Browser automation and web scraping with Puppeteer.

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.

The Sentry MCP Server is Sentry's official Model Context Protocol integration, purpose-built for human-in-the-loop coding agents like Claude Code, Cursor, and Windsurf. Rather than exposing every Sentry API endpoint, it focuses tightly on developer debugging workflows: searching and triaging issues, pulling stack traces and event details, inspecting performance traces, and querying project/team/org metadata in natural language. The primary deployment is a hosted remote MCP server at mcp.sentry.dev, built on Cloudflare's remote-MCP infrastructure, so most users connect with zero local setup — just add the remote URL to their client. For self-hosted Sentry instances or local development, a stdio transport is also available via npx @sentry/mcp-server, authenticated with a Sentry User Auth Token scoped to org:read, project:read, project:write, team:read, team:write, and event:write. AI-powered search tools (search_events, search_issues) translate natural-language queries into Sentry's query syntax, but require a configured LLM provider (OpenAI, Azure OpenAI, Anthropic, or OpenRouter) — all other tools work without one. Claude Code users can also install it as a plugin (claude plugin install sentry-mcp@sentry-mcp) for automatic subagent delegation whenever a conversation touches Sentry errors, issues, or traces. This turns "why did this deploy break in production" into a direct conversational debugging session instead of tab-switching into the Sentry dashboard.

The Datadog MCP Server is Datadog's official Model Context Protocol integration that connects AI assistants directly to your Datadog observability platform — metrics, logs, APM traces, infrastructure, and monitors. Built and maintained by Datadog, the server uses your API and application keys to expose tools for querying live time-series metrics with full DQL expressions, searching log events with Datadog Log Management query syntax, retrieving distributed APM traces and service performance summaries, listing infrastructure hosts and their tags, and checking the status of Datadog monitors and downtime windows. This gives Claude real-time visibility into your production systems: ask "What's the p99 latency for the payments service over the last hour?" or "Find all ERROR-level logs from the auth service since the last deploy," and receive answers backed by live Datadog data rather than stale dashboards. Authentication requires a Datadog API key (DD_API_KEY) and an Application key (DD_APP_KEY) with appropriate scope — both available from Organization Settings > API Keys and Application Keys in the Datadog UI. Set DD_SITE to your Datadog region (e.g., datadoghq.com, datadoghq.eu, or us3.datadoghq.com). Works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. Especially powerful for SRE, DevOps, and on-call workflows where engineers need AI to correlate metrics, logs, and traces during incident response without context-switching away from their conversation.

The official Grafana MCP server connects Claude and other AI assistants directly to your Grafana instance and its surrounding observability ecosystem, turning natural-language questions into dashboard lookups, incident investigations, and datasource queries. Dashboard tools cover search, retrieval, JSONPath-scoped property extraction, patch-based editing, and per-panel query/datasource introspection, with context-window-aware helpers like get_dashboard_summary so an agent never has to pull a full multi-megabyte dashboard JSON just to answer a simple question. Query tools speak PromQL against Prometheus (including histogram-percentile helpers), LogQL against Loki, and native query languages for InfluxDB, ClickHouse, CloudWatch, Graphite, Athena, Snowflake, Elasticsearch/OpenSearch, and Quickwit datasources — most gated behind opt-in --enabled-tools flags to keep the default tool surface lean. It also wraps Grafana Incident for creating and updating incidents, Sift for automated error-pattern and slow-request investigations, full alerting CRUD (rules, contact points, notification policies) across Grafana-managed and external Alertmanager sources, Grafana OnCall schedule/shift/alert-group management, RBAC-gated admin tools for teams/users/roles, deeplink generation so the LLM never has to guess a dashboard URL, annotations, snapshots, PNG rendering via the Grafana Image Renderer, and provisioning-repo validation for git-sync workflows. Ships as a Go binary or via uvx, authenticates with a Grafana service account token (Editor role or granular RBAC scopes), and every tool category can be individually disabled to control context-window usage.

Query and analyze your Axiom logs, traces, and all other event data in natural language.

OpenAI does not publish a dedicated, first-party "MCP server" for its own API — a `openai/mcp-server` repo does not exist. Instead, OpenAI's official open-source contribution to the MCP ecosystem is on the client side: openai/openai-agents-python (27,000+ stars), a lightweight framework for building multi-agent workflows with the OpenAI API that ships native support for connecting to MCP servers as a tool source, letting an OpenAI-model-powered agent call out to any MCP server (filesystem, GitHub, databases, etc.) the same way a Claude-based agent would. In other words, OpenAI's MCP investment is "consume MCP tools from an OpenAI agent," not "expose OpenAI itself as an MCP server." Teams that specifically want to call OpenAI's chat, embeddings, or image-generation endpoints as MCP tools from Claude, Cursor, or another MCP client instead rely on small community-built wrapper servers around the OpenAI SDK, authenticated with an `OPENAI_API_KEY`, exposing tools like generate_completion, generate_embedding, or generate_image. Typical use of the Agents SDK side: build a Python agent that uses GPT models for reasoning while pulling live context through an MCP filesystem or web-search server. Update this entry if OpenAI ships a genuine first-party MCP server for its own API in the future.

Connect to Hugging Face Hub APIs - search spaces, papers, explore datasets and models.

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

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.

Twilio's official MCP server, built by the Twilio Alpha team and published as @twilio-alpha/mcp, exposes the entirety of Twilio's public API surface to AI assistants over the Model Context Protocol. Rather than hand-writing tool wrappers, the server auto-generates MCP tools directly from Twilio's OpenAPI specs, so it stays in sync with new Twilio products (Voice, Messaging/SMS, Verify, Lookup, Conversations, and more) as they ship. Because a full API surface can blow past an LLM's context window, the server supports --services and --tags flags to scope which Twilio products are loaded into a given session, keeping tool lists small and relevant. Authentication uses a Twilio Account SID paired with an API Key/Secret pair (created in the Twilio Console), passed as a single credential string at launch rather than long-lived account credentials. The monorepo also ships a companion openapi-mcp-server package that can turn any OpenAPI spec into an MCP server using the same generator, useful for teams building on top of Twilio's partner or vertical APIs. Twilio's security guidance explicitly recommends against running community MCP servers alongside the official one to reduce the risk of a compromised third-party tool touching production SMS, voice, or verification workflows tied to real phone numbers and customer data.

Send emails and manage email templates with SendGrid.

The Resend MCP Server is Resend's official Model Context Protocol integration, letting AI assistants send and receive transactional email, manage contacts, broadcasts, and domains directly from Claude, Cursor, or any MCP-compatible client. Resend offers two ways to connect: a fully hosted remote server at mcp.resend.com (Streamable HTTP, no local install, OAuth login on first connect) that works well for Claude web/desktop and Cursor, or the same open-source code run locally via `npx resend-mcp` (published to npm as `resend-mcp`) using stdio or HTTP transport for CI, headless agents, or self-hosted setups. Authentication is either OAuth (hosted mode, browser-based) or a Resend API key passed as a Bearer token — handy for servers where a browser login isn't possible. Setup is documented for Claude Code, Claude Desktop/web, Cursor, Windsurf, Codex, and GitHub Copilot in VS Code. Typical use: ask Claude to "send a welcome email to this new signup using our verified domain" or "list contacts added to the newsletter audience this week," and the MCP server routes the request through your existing Resend account — no custom SMTP or REST integration code required. With 546+ GitHub stars, it's one of the most widely adopted first-party MCP servers in the email/transactional-messaging category.

The Google Drive MCP Server is Anthropic's official Model Context Protocol integration for Google Drive, enabling AI assistants to search, read, and interact with files stored in your Drive workspace. Part of the original modelcontextprotocol/servers collection, this integration exposes Google Drive's file system as callable MCP tools: search files by name or content across your entire Drive, read the contents of Google Docs and Google Sheets as plain text, list files in specific folders, retrieve file metadata including owner, last modified date, and sharing settings, and export native Google Workspace documents to accessible formats. Real-world use cases include asking Claude to "find my Q2 budget spreadsheet and summarize it," "search all my Drive for documents about the product roadmap," or "read the meeting notes from last week's team sync." Authentication requires Google OAuth 2.0 credentials — create a project in Google Cloud Console, enable the Drive API, download the credentials.json file, and complete the one-time authorization flow on first run. Install via npm using: `npx @modelcontextprotocol/server-gdrive`. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline. Ideal for knowledge workers who want AI-assisted document retrieval and content summarization without manually navigating Google Drive.

Location services, directions, and place details from Google Maps Platform.

dbx-mcp-server (amgadabdelhafez/dbx-mcp-server) is a community-built MCP server that gives AI assistants full read/write access to a Dropbox account through Dropbox's public API. Tools cover core file operations (list, upload, download, copy, move, and safe-delete with recycle-bin support so nothing is destroyed permanently), folder creation, metadata lookups, and content search across an account, letting a client answer "find my Q3 budget spreadsheet" or "move all screenshots from this month into an Archive folder" without a human digging through folders manually. Authentication uses OAuth 2.0 with PKCE: register a Scoped-Access app in the Dropbox App Console, grant the specific permission scopes needed (files.metadata.read, files.content.read/write, sharing.write, account_info.read), and supply `DROPBOX_APP_KEY`, `DROPBOX_APP_SECRET`, `DROPBOX_REDIRECT_URI`, and a `TOKEN_ENCRYPTION_KEY` for secure local token storage with automatic refresh. Install by cloning the repo, running `npm install && npm run build`, then `npm run setup` to complete the OAuth flow. Note this is not affiliated with or endorsed by Dropbox — Dropbox itself ships a separate, narrower official MCP server (dropbox/mcp-server-dash) scoped specifically to Dropbox Dash search and AI-assistant integration rather than general file management.

Microsoft MCP (elyxlz/microsoft-mcp) is a community-built MCP server that wraps the Microsoft Graph API to give AI assistants access to OneDrive files alongside Outlook mail, Calendar, and Contacts in a single unified integration — useful since most OneDrive usage happens inside the same Microsoft 365 account as email and scheduling. The file toolset covers list_files (paginated OneDrive browsing), get_file (download content), create_file (upload), update_file, delete_file, search_files, and a cross-surface unified_search tool that searches emails, events, and files together in one call, letting a client answer "find the contract I emailed myself last week" without knowing whether it lives in Mail or OneDrive. The server supports multiple simultaneous Microsoft accounts (personal, work, school) via list_accounts/authenticate_account/complete_authentication tools using device-code OAuth. Setup requires a free Azure App Registration (Microsoft Entra ID → App registrations, public client flow enabled) with delegated Files.ReadWrite, Mail.ReadWrite, Calendars.ReadWrite, Contacts.Read, and People.Read permissions, then an MICROSOFT_MCP_CLIENT_ID environment variable. Install via `uvx --from git+https://github.com/elyxlz/microsoft-mcp.git microsoft-mcp`, or `claude mcp add microsoft-mcp -e MICROSOFT_MCP_CLIENT_ID=your-app-id -- uvx --from git+https://github.com/elyxlz/microsoft-mcp.git microsoft-mcp` for one-line Claude Code setup. Not an official Microsoft release.

The Airtable MCP Server connects your AI assistant directly to Airtable bases, letting you read records, create entries, update fields, and query structured data using natural language — no manual spreadsheet navigation required. The leading community implementation is domdomegg/airtable-mcp-server, which exposes the full Airtable REST API as MCP tools: list all bases and tables in your workspace, fetch records from any view with optional filter formulas, create or update individual records with typed field values, and delete records by ID. Authentication uses your Airtable personal access token (or API key for legacy accounts), scoped to whichever bases you grant access. Once connected, ask Claude to "show me all leads added this week in my CRM base" or "create a new product entry in my inventory table" and the server handles the API calls. Common use cases include AI-assisted CRM workflows (pull contact records, log meeting notes back into Airtable), inventory management, content calendars, and project tracking where Airtable acts as a lightweight database. Works with Claude Desktop, Cursor, VS Code (Copilot Chat), Windsurf, and any MCP-compatible client. Install via: `npx -y airtable-mcp-server` with `AIRTABLE_TOKEN=your_token` set in your environment.

The Asana MCP Server brings Asana project management into your AI assistant, enabling task creation, project search, and work tracking through natural-language conversation. The top community implementation is roychri/mcp-server-asana, which wraps the Asana REST API as a full-featured MCP server. Available tools include: list workspaces and teams, create tasks with assignee, due date, and custom fields, update task status or move tasks between projects, add comments and subtasks, search for tasks across all projects by name or tag, and list project sections and milestones. Authentication uses a personal access token from Asana's developer console — set it as `ASANA_ACCESS_TOKEN` in your environment. Asana also maintains an official MCP integration for enterprise customers connecting via Asana Intelligence. Common workflows: ask Claude to "create a task for the design review in the Q3 marketing project, due Friday, assigned to me"; pull all overdue tasks across your workspace; or generate a sprint summary by listing open tasks per assignee in a given project. Works with Claude Desktop, Cursor, VS Code Copilot, Windsurf, Cline, and any MCP client. Install: `npx -y @roychri/mcp-server-asana`.

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.

The Atlassian Remote MCP Server brings Confluence and Jira into any MCP-compatible AI assistant, IDE, or agent platform through a centrally hosted, enterprise-grade connection backed by Atlassian's Teamwork Graph. Launched in May 2025 with Anthropic as the first official partner and hosted on Cloudflare infrastructure, authentication is handled via OAuth 2.1 — no local server process to deploy or maintain. For Confluence specifically, available operations include summarizing pages and spaces, creating new pages from AI-generated content, searching across your wiki with natural language, and performing multi-step knowledge retrieval across Confluence spaces. Jira operations include creating, updating, and triaging work items, summarizing sprint state, and linking knowledge to in-flight issues. Atlassian's Teamwork Graph underpins every response — connecting people, services, knowledge, and work items into a unified context for richer AI answers. Enterprise customers at AT&T, NVIDIA, Pfizer, Booking.com, and Visa use the integration in production. Connect from Claude Desktop via Settings > Connectors, or from Claude Code with: `claude mcp add --transport http atlassian https://mcp.atlassian.com/v1/mcp`. Cursor and Windsurf users can add the remote URL directly to their MCP config.

The Todoist MCP Server is Doist's own first-party integration (doist/todoist-mcp) that lets Claude, Cursor, and other MCP clients read and modify a Todoist account on the user's behalf using natural language. It exposes tools for the full task lifecycle — add tasks, find tasks by date or filter query, update, complete, and reopen tasks, and manage projects, sections, labels, and comments — so an assistant can act on requests like "add 'file taxes' to my Finance project due next Friday" or "what's overdue across all my projects?" without leaving the chat. The recommended setup is the hosted, streamable-HTTP server at https://ai.todoist.net/mcp, which runs OAuth in the browser the first time a Todoist tool executes, so there are no API keys to manage. For Claude Code the fastest path is the official plugin: `/plugin marketplace add doist/todoist-mcp` then `/plugin install todoist@doist`; you can also wire it up manually with `claude mcp add --transport http todoist https://ai.todoist.net/mcp`, or point Cursor and VS Code at the same URL via mcp-remote. The underlying tools are additionally published as an npm package (`@doist/todoist-mcp`) that can be imported directly into a custom AI SDK agent for embedding Todoist actions in your own conversational interface. Being maintained by Doist, the maker of Todoist, this is the canonical, officially supported server rather than a community reimplementation.

Enable AI Agents to fix build failures from CircleCI.

Exposing Buildkite data (pipelines, builds, jobs, tests) to AI tooling.

Official Jenkins MCP Server plugin enabling AI assistants to manage builds, check job statuses, and retrieve logs.

The Kubernetes MCP server (mcp-server-kubernetes, built by Flux159) brings cluster management capabilities into AI assistant workflows, letting developers and platform engineers query and manage Kubernetes resources through natural-language interactions with Claude, Cursor, and other MCP-compatible clients. It loads your existing kubeconfig automatically, so it works with any cluster — local minikube and kind setups, Amazon EKS, Google GKE, Azure AKS, or on-premises deployments — with no separate credential setup required. Core tools exposed by the server include: listing pods, deployments, services, and namespaces; describing individual resources and their status; fetching pod logs for debugging; applying and updating manifests; scaling deployments; checking rollout status and history; and querying resource utilization and cluster events. A built-in non-destructive mode can disable delete/scale-down operations entirely, making it safe to point at production clusters for read-only diagnostics. DevOps engineers use it to debug failing deployments by asking Claude to inspect pod logs and recent events, identify resource constraints causing OOMKilled pods, or summarize the current state of a namespace before a production release. For SREs responding to incidents, it enables rapid triage through conversational commands — no memorizing kubectl flags or switching terminal windows mid-incident — and optional OpenTelemetry integration adds observability into what the AI agent actually did against the cluster. Install with: `npx mcp-server-kubernetes`. Pairs well with the GitHub MCP server for full GitOps review workflows.

The Terraform MCP Server is HashiCorp's official integration that brings Terraform's infrastructure-as-code capabilities into AI assistants via the Model Context Protocol. It connects Claude Desktop, Cursor, VS Code, and other MCP clients to the Terraform ecosystem — letting you explore providers, look up module schemas, validate configurations, and work with HCP Terraform (Terraform Cloud) all through natural-language conversation. Core tools include: search the Terraform Registry for modules and providers by keyword, retrieve full provider schema documentation including resource arguments and attribute types, look up specific module input/output variables and their defaults, resolve provider version constraints and compatibility matrices, and run Terraform operations against HCP Terraform workspaces including plan, apply, and state inspection. A key use case is AI-assisted IaC authoring: ask Claude to "generate a Terraform module for an AWS VPC with public and private subnets using the latest aws provider schema" and the server fetches the live provider schema to ensure accurate attribute names and types rather than hallucinating outdated syntax. For HCP Terraform users, workspace integration supports listing workspaces, triggering runs, and checking plan output. HashiCorp maintains the server at hashicorp/terraform-mcp-server and distributes it as a pre-built binary for Linux, macOS (arm64 + amd64), and Windows. Install via: `npx @hashicorp/terraform-mcp-server`. Pairs well with GitHub MCP for full IaC PR review workflows.

Discover, extract, and interact with the web - one interface powering automated access across the public internet.

Use AI agents to provision, configure, and query your Algolia search indices.

The Elasticsearch MCP Server (elastic/mcp-server-elasticsearch) is Elastic's official server for connecting AI agents to Elasticsearch data over the Model Context Protocol, enabling natural-language querying, analysis, and retrieval across your indices without building custom APIs. Once connected, an assistant can list available indices, inspect field mappings, and run searches or aggregations described in plain English — "show me the top error messages from the last 24 hours" — against an Elasticsearch 8.x or 9.x cluster. Important status note: as of version 0.4.0 this standalone server is officially DEPRECATED and receives only critical security updates going forward; Elastic has superseded it with the Elastic Agent Builder MCP endpoint, available in Elastic 9.2.0+ and Elasticsearch Serverless projects, which is the recommended path for new integrations. For existing users, the current server ships as a Docker container image (docker.elastic.co/mcp/elasticsearch) rather than a pip package, and supports both stdio and streamable-HTTP transports (SSE is deprecated). Configure it with the `ES_URL` environment variable pointing at your cluster plus either an `ES_API_KEY` or an `ES_USERNAME`/`ES_PASSWORD` pair for authentication; an optional `ES_SSL_SKIP_VERIFY=true` is available for development-only TLS bypass. Run in stdio mode with `docker run -i --rm -e ES_URL -e ES_API_KEY docker.elastic.co/mcp/elasticsearch stdio` and add the equivalent block to your Claude Desktop, Cursor, or VS Code MCP config.

Interact & query with Meilisearch (Full-text & semantic search API).

Payments MCP is Coinbase's official npm-installed MCP server and companion wallet app that combines wallets, onramps, and payments via the x402 protocol into a single solution for agentic commerce. It lets AI agents autonomously discover and pay for services without requiring API keys, seed phrases, or manual intervention — install with `npx @coinbase/payments-mcp` and the installer walks through client setup (Claude Desktop, Claude Code, Codex, Gemini CLI, or other MCP-compatible tools) with optional automatic configuration. Full docs live at docs.cdp.coinbase.com/payments-mcp. Separately, developers wanting broader onchain/crypto-portfolio tooling should note the Coinbase Developer Platform also published `base-mcp-legacy` (Base network + Coinbase API tools for LLMs), though it has since been archived in favor of the newer AgentKit-based tooling.

Official CoinGecko API MCP Server for Crypto Price & Market Data, across 200+ Blockchain Networks.

Plaid's official AI Coding Toolkit ships a local sandbox MCP server (in `/sandbox`) that speeds up building Plaid integrations with AI coding assistants — it generates mock financial data, searches Plaid documentation, issues sandbox access tokens, and simulates webhooks, so a developer can test an integration end-to-end without touching real bank data. The repo also bundles product-specific `/rules` guides meant to be dropped into CLAUDE.md, AGENTS.md, or Cursor rules so an AI assistant has Plaid integration context automatically. It complements two other first-party Plaid AI tools referenced in the same repo: the Plaid CLI (terminal access to financial data) and the Plaid Dashboard MCP (runtime dashboard access, docs-hosted at plaid.com/docs/resources/mcp). For read-only personal-finance use cases spanning multiple providers, elcukro/bank-mcp is a community alternative that supports Plaid alongside Teller, Enable Banking, and Tink.

The Shopify MCP Server (GeLi2001/shopify-mcp) gives AI assistants full CRUD access to a Shopify store through the GraphQL Admin API, turning natural-language requests into store operations. It exposes tools across five areas: product management (create, update, delete products, variants, and options — 8 tools), customer management (lookups, merges, address management — 8 tools), order management (smart lookup, cancel, close/open, mark as paid, fulfillment, and refunds — 10 tools), metafields (get/set/delete on any resource), and inventory (set absolute quantities per location), plus tagging and cursor-based pagination with Shopify's native query syntax on every list endpoint. Authentication supports two paths: the modern Dev Dashboard flow (required for new apps created after January 2026), which uses OAuth client credentials that the server automatically exchanges and refreshes, or a legacy static shpat_ access token for existing custom apps. Install via `npx shopify-mcp` (package name shopify-mcp, published to npm) with either --clientId/--clientSecret or --accessToken/--domain flags passed in your MCP client config — no separate server process to manage. Typical use: ask Claude to "find all orders over $500 from the last week and tag the customers as VIP," and the server handles the GraphQL queries and mutations directly against the store's Admin API. Shopify itself also publishes an official shopify-dev-mcp for app/theme developers working against Shopify's documentation and APIs, which is a separate, docs-focused tool from this store-data server.

Search Packrift packaging supplies, check product and inventory context, and create ecommerce cart URLs.

The YouTube MCP Server by Zubeid Hendricks connects AI assistants to the full YouTube Data API v3, letting Claude search videos, pull transcripts, manage content, and run analytics without leaving the conversation. It is one of the most complete community YouTube MCP servers, exposing tools across several areas: video management (search by keyword, retrieve metadata, get statistics, and list a channel's uploads), transcript retrieval (fetch full captions for any public video for summarization or Q&A), channel operations (look up channel details, subscriber and view counts, and recent activity), playlist tools (list and inspect playlist contents), Shorts creation workflows, and advanced analytics for creators tracking performance. Authentication uses a single YOUTUBE_API_KEY obtained free from the Google Cloud Console by enabling the YouTube Data API v3 — read-heavy operations fit comfortably inside the daily quota. Install globally with npm as zubeid-youtube-mcp-server, run it directly with npx (no install required), or add it through Smithery for one-click Claude Desktop setup; a Docker image is also provided for HTTP transport. The YouTube MCP Server is ideal for content research, competitive analysis, transcript-based summarization, and automated creator workflows — Claude can, for example, find the top videos on a topic, fetch their transcripts, and synthesize a briefing in a single pass.

Marcel Marais's Spotify MCP Server is a lightweight TypeScript bridge between AI assistants and the Spotify Web API, letting Claude control playback and search a listener's library through natural language. It exposes tools for searching tracks/albums/artists/playlists, controlling playback (play, pause, skip, queue management), reading and modifying the current queue, and browsing a user's playlists and saved library. Authentication uses standard Spotify OAuth (client ID/secret from the Spotify Developer Dashboard) with a one-time login flow to obtain a refresh token, after which the server runs locally via the MCP stdio transport. Typical use: ask Claude to "queue up some upbeat workout music" or "what's currently playing," and it calls the Spotify API directly rather than requiring the user to switch to the Spotify app.

Exposes Cloudinary's media upload, transformation, AI analysis, management, optimization and delivery.

The official ElevenLabs MCP server (elevenlabs/elevenlabs-mcp) connects AI assistants like Claude Desktop, Cursor, Windsurf, and OpenAI Agents directly to ElevenLabs' text-to-speech and audio-processing APIs. Once installed, an AI client can generate natural-sounding speech from text in dozens of voices and languages, clone a voice from a short audio sample, design and save new synthetic voices to a personal voice library, transcribe spoken audio with automatic speaker diarization, isolate vocals from background noise, and compose layered soundscapes (e.g. "a thunderstorm in a dense jungle with animals reacting") from a text prompt. It also exposes ElevenLabs' Conversational AI agent-creation tools, so a client can spin up a voice agent with a defined persona and have it answer questions in character. Install via PyPI/uv with `uvx elevenlabs-mcp` and an `ELEVENLABS_API_KEY` from the ElevenLabs dashboard — the free tier includes 10k credits/month, enough for testing. Optional environment variables (`ELEVENLABS_MCP_BASE_PATH`, `ELEVENLABS_MCP_OUTPUT_MODE`) control whether generated audio is saved to disk, returned as base64-encoded MCP resources for containerized/serverless environments, or both, and `ELEVENLABS_API_RESIDENCY` supports enterprise data-residency requirements. With 1,450+ GitHub stars, it is the most widely adopted way to give an AI coding assistant real audio-generation capabilities without hand-rolling API calls.

The Discord MCP Server (SaseQ/discord-mcp) is a Java-based Model Context Protocol integration built on JDA (Java Discord API) that turns a Discord bot into a set of tools AI assistants can call directly. It lets Claude, Cursor, and other MCP clients read and send channel messages, manage threads, create and moderate channels and categories, manage roles and permissions, look up server (guild) members, and pull message history — enabling AI-driven community moderation, automated announcements, and Discord-native workflows without hand-writing bot code. The recommended install is Docker: set DISCORD_TOKEN (from a bot registered in the Discord Developer Portal) and an optional DISCORD_GUILD_ID as environment variables, then run the saseq/discord-mcp:latest image with SPRING_PROFILES_ACTIVE=http, which exposes the MCP endpoint at http://localhost:8085/mcp for remote/HTTP-transport clients. A Docker Compose path and a stdio-transport mode are also documented for local, per-client setups like Claude Desktop. Because it wraps JDA (Spring Boot underneath), it handles Discord's gateway/rate-limit quirks for you rather than requiring a hand-rolled REST client. This is the most-starred dedicated Discord MCP implementation; other community servers like v-3/discordmcp and hanweg/mcp-discord cover similar ground with lighter Node/Python stacks if a non-JVM runtime is preferred.

A Telegram MCP server that connects Claude, Cursor, and other MCP-compatible clients directly to a Telegram user account via the Telethon library, exposing 80+ tools grouped into accounts, chats/groups, messages, contacts, media, profile/privacy, and folders/drafts. It supports multi-account setups (list accounts and route tool calls by label), full group and channel administration (create/join/leave, invites, bans, admin roles, slow mode, topics), rich messaging (send, schedule, edit, delete, forward, pin, reply, search, polls, reactions, inline button inspection and press), contact management (add/remove/block/import/export), and media handling (files, voice notes, stickers, GIFs, downloads/uploads). All tool results containing Telegram user-controlled content are sanitized before being returned as structured JSON, and a device-identity feature lets the session appear as a distinct, labeled client rather than a generic script. Authentication uses a Telegram API ID/hash from my.telegram.org plus a generated session string — no bot token required, since this operates as a full user account. A `TELEGRAM_EXPOSED_TOOLS=read-only` mode is available to restrict the MCP surface to read-only tools when write access is not needed. The project explicitly warns against installing the unrelated `telegram-mcp` package from PyPI, which is owned by a different, unaffiliated project — always install from source via `uv sync`.

The WhatsApp MCP server connects Claude and other MCP clients directly to your personal WhatsApp account so an AI assistant can search, read, and send messages, contacts, and media through natural language. Unlike hosted bots that require the paid WhatsApp Business API, this community server (lharries/whatsapp-mcp, the most-adopted WhatsApp MCP server on GitHub) links to your regular account via the WhatsApp Web multidevice API using the Go whatsmeow library — you authenticate once by scanning a QR code, then re-authenticate roughly every 20 days. It runs as two components: a Go bridge that maintains the WhatsApp connection and stores your full message history in a local SQLite database, and a Python MCP server that exposes tools to the agent. Messages stay on your machine and are only sent to the LLM when a tool explicitly reads them, so you control what the model sees. Available tools cover searching contacts and chats, reading individual and group conversations (including images, video, documents, and audio), sending text messages to people or groups, and sending media — with optional FFmpeg-based conversion to play audio as native WhatsApp voice notes. Note the "lethal trifecta" caution in the README: because it combines private data, tool access, and external content, prompt injection could risk data exfiltration.

Connect to the Cal.com API to schedule and manage bookings and appointments.

Calendly MCP Server connects an AI assistant to Calendly's scheduling platform — Calendly itself doesn't publish an official MCP server, so the top community implementation is meAmitPatil/calendly-mcp-server, runnable instantly via `npx calendly-mcp-server`. It covers the core Calendly API surface (fetch the current authenticated user, list and retrieve scheduled events, manage invitees, cancel events, list organization memberships) plus the newer Scheduling API, which lets the assistant book meetings programmatically without redirecting the user to a Calendly link: discovering available event types, checking real-time availability for any event type, and completing an end-to-end booking with calendar sync and notifications across Zoom, Google Meet, Teams, physical locations, or custom locations. Authentication supports either a Personal Access Token generated from the Calendly Integrations page (simplest, for single-user/internal use) or full OAuth 2.0 with client ID/secret for multi-user public applications. Setting optional user-context environment variables improves performance by supplying sensible defaults instead of requiring a lookup call on every request. For teams that want an AI assistant to check availability and schedule meetings conversationally instead of copy-pasting Calendly links, this server closes that gap despite the lack of an official vendor-maintained option.

The Obsidian MCP server connects AI assistants to your local Obsidian vault through the Obsidian Local REST API community plugin, enabling read, write, and search operations on your personal knowledge base. With 4,000+ GitHub stars, mcp-obsidian by MarkusPfundstein is the most widely adopted Obsidian MCP integration available. The server exposes seven tools: list_files_in_vault (enumerate all vault files and directories), list_files_in_dir (browse a specific folder), get_file_contents (read any note by path), search (full-text search across all vault notes), patch_content (insert text relative to a heading, block reference, or frontmatter field), append_content (add text to a new or existing note), and delete_file (remove a note or folder). Install via a single uvx command; set OBSIDIAN_API_KEY, OBSIDIAN_HOST, and OBSIDIAN_PORT environment variables (default port 27124). You must first install and enable the Obsidian Local REST API community plugin inside your vault settings — it exposes the HTTP endpoint this server bridges. Works with Claude Desktop, Cursor, Windsurf, Cline, and any MCP-compatible client. Ideal for summarizing meeting notes, searching research across hundreds of Markdown files, drafting new pages from AI output, or building second-brain workflows where Claude reads and writes your full knowledge base.

The Roam Research MCP Server is the official, first-party Model Context Protocol server for Roam Research, published by the Roam Research team itself and covering the full read/write surface of your Roam graph. It connects to Roam's local HTTP API, which runs inside the Roam desktop app (not the web version) — if Roam isn't open when a tool is called, the server automatically launches it via deep link and retries. Setup runs through an interactive `connect` flow (`npx @roam-research/roam-mcp connect`) that walks you through selecting a graph, choosing an access level (full, read-append, or read-only), and approving a local API token inside Roam's Settings > Graph > Local API Tokens screen; a non-interactive flag-based mode is also available for scripted or agent-driven setup. Multiple graphs can be connected simultaneously, each addressable by a short nickname. The tool surface spans six areas: graph management (list_graphs, setup_new_graph), graph guidelines (get_graph_guidelines reads a special `[[roam/agent guidelines]]` page for user-defined AI instructions), content mutation (create/update/delete for pages and blocks, append_to_daily_note, move_block, add_comment/get_comments), read/search (search, roam_query for `{{query:}}` blocks, datalog_query for raw Datomic queries, get_page, get_block, get_backlinks), navigation (get_open_windows, get_selection, open_main_window, open_sidebar), and file handling (file_get/file_upload/file_delete, including encrypted-graph decryption). The README flags this as alpha software and explicitly warns that write operations are difficult or impossible to fully undo since Roam lacks bulk-operation undo history — back up your graph before granting full write access. A companion CLI (`@roam-research/roam-cli`) is available for terminal-driven graph interaction outside an MCP client. Works with Claude Desktop, Claude Code, Cursor, and any MCP-compatible client. Ideal for daily-note capture, backlink-driven knowledge retrieval, and agent-assisted graph restructuring for second-brain / networked-note workflows.

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.

Connects AI agents with the CrowdStrike Falcon platform for intelligent security analysis.

The official Auth0 MCP server lets Claude, Cursor, and Windsurf manage an Auth0 tenant end-to-end through natural language instead of the dashboard — create applications, deploy Actions, debug logs, and manage resource servers just by asking. Its standout feature is the guided onboarding flow: the auth0_onboarding tool detects your project framework, creates a correctly configured Auth0 application, writes credentials straight into a .env file (auto-added to .gitignore), and hands off to auth0_get_quickstart_guide, which resolves callback URLs and returns framework-specific SDK integration code — taking a project from zero to a working Auth0 login in one guided conversation. Beyond onboarding, the tool surface spans Applications (list/get/create/update, plus credential export), Resource Servers/APIs (create and manage scopes, token lifetimes, signing algorithms), Application Grants (authorize M2M apps against specific APIs with defined scopes), Actions (create, update, and deploy post-login/pre-token logic), Logs (search and inspect authentication events, e.g. failed logins from a given IP), and Forms (build and publish branded login/signup/password-reset forms). Installs via npx with a device-authorization OAuth flow that stores credentials in your system keychain, supports Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Gemini CLI, and Codex, and exposes --tools/--read-only flags to scope down which operations an AI agent can perform — important given its Beta status and full read/write tenant access by default.

Retrieval from AWS Knowledge Base using Bedrock Agent Runtime.

Access to key Azure services and tools like Azure Storage, Cosmos DB, the Azure CLI, and more.

Deploy code to Google Cloud Run and interact with GCP services.

Firebase's experimental MCP Server to power your AI Tools.

Interact with the Heroku Platform through LLM-driven tools for managing apps, add-ons, dynos, and databases.

DigitalOcean MCP Server gives Claude, Cursor, and other MCP clients direct access to your DigitalOcean cloud infrastructure. The actively maintained community server lives at digitalocean-labs/mcp-digitalocean, built on the official godo Go SDK and the mark3labs/mcp-go framework — the earlier @digitalocean/mcp npm package under the digitalocean org has been archived in favor of this project. It exposes tools for managing Droplets, Kubernetes clusters, App Platform deployments, Spaces object storage, databases, VPCs, load balancers, and DNS records, letting an AI assistant provision, inspect, and tear down cloud resources through natural-language prompts instead of the doctl CLI or web console. Authentication uses a DigitalOcean Personal Access Token supplied via the DIGITALOCEAN_API_TOKEN environment variable — the README explicitly warns against hardcoding it into client config files, since committing a token to GitHub triggers automatic revocation. Typical workflows include deploying an app from a GitHub repo, redeploying with the latest changes, tailing logs, restarting components, and auditing which regions and droplet sizes are available before provisioning. Because it operates directly against billable cloud infrastructure, DigitalOcean recommends scoping tokens narrowly and reviewing any destructive action (deleting droplets, dropping databases) before confirming it in your MCP client.

Real User Monitoring data from Datadog.

Query and analyze your product analytics data through natural language.

Search, analyze, and query charts, dashboards, experiments, and feature flags.

The PostHog MCP Server is PostHog's official Model Context Protocol integration, giving AI assistants direct access to product analytics, feature flags, session replay, experiments, and error tracking without leaving the chat. It's hosted remotely at mcp.posthog.com (Streamable HTTP) and authenticated with a personal PostHog API key passed as a Bearer token — the quickest setup is `npx @posthog/wizard@latest mcp add`, which auto-configures Cursor, Claude, Claude Code, VS Code, or Zed in one command; manual setup adds an `mcp-remote` proxy entry with the `Authorization` header for clients without native remote-MCP support. Tools cover the full PostHog surface: creating and toggling feature flags with percentage rollouts and targeting rules, running trends/funnel/retention queries via `query-run`, inspecting session recordings, pulling error-tracking issues, and managing experiments — all scoped to the project tied to your API key. Typical use: ask Claude to "create a feature flag for the new checkout flow at 20% rollout" or "how many unique users signed up in the last 7 days, broken down by day?" and the assistant executes the query or mutation against your live PostHog project and returns formatted results. Originally shipped as the standalone PostHog/mcp repo (150+ stars), the server's source has since moved into the main PostHog monorepo under `services/mcp` but documentation and install instructions are unchanged.

Segment (Twilio Segment) does not currently ship a first-party Model Context Protocol server — repos claiming to be an "official Segment MCP" (like segmentio/mcp-server) don't actually exist, and no Twilio-published MCP package has shipped as of this writing. The closest authoritative reference is Segment's own actively-maintained analytics-next SDK (400+ stars), the JavaScript library that powers Segment's client- and server-side tracking calls (track, identify, page, group) across web and Node. In practice, teams that want an AI assistant to read or write Segment data build a thin MCP wrapper around Segment's public HTTP Tracking API using a per-source write key, exposing tools like track_event, identify_user, and group_account so an assistant can execute requests such as "log a purchase event for this user in Segment" or "identify this contact with these traits" without a human touching the dashboard. Segment's Engage and Unify APIs (audience management, profile lookups) are also reachable this way with a workspace access token. Until Twilio ships (or a well-maintained community project emerges for) a dedicated Segment MCP server, this entry points at the SDK repo that actually documents the underlying event schema and auth model any wrapper would need — update this entry if a real one ships.

Zapier MCP is Zapier's official hosted Model Context Protocol server, giving AI assistants natural-language access to the 9,000+ apps in the Zapier ecosystem — Gmail, Slack, HubSpot, Salesforce, Google Sheets, Airtable, and thousands more — without writing custom API integrations for each one. Instead of installing a local binary, you create a server at mcp.zapier.com, pick the tools (Zapier calls them "actions") you want exposed, and connect over Streamable HTTP (SSE is not supported). Setup guides are published for Claude (Web, Desktop, and Code — requires an org owner), ChatGPT (Developer Mode, manual tool refresh required), Cursor, VS Code (via GitHub Copilot Agent mode), Windsurf, and Microsoft Copilot Studio, plus a generic path for any MCP client built with the Python or TypeScript SDK. Authentication is OAuth-based per client; disconnecting a client is a one-click delete of the server in the mcp.zapier.com dashboard, which immediately revokes access. Tool bundles let you group related actions (e.g. "CRM updates" or "team notifications") so the AI only sees relevant tools per context, and usage is billed against your existing Zapier plan's task quota. The official client plugin — which onboards you with guided setup inside Claude Code, Cursor, and GitHub Copilot CLI — lives in the zapier/zapier-mcp repo and ships through the Claude Code, Cursor, and Kiro plugin marketplaces. Typical use: ask Claude to "add this lead to HubSpot and notify #sales on Slack" and Zapier MCP routes both actions through your existing Zap connections.

Turn your Make scenarios into callable tools for AI assistants.

The n8n MCP Server exposes your n8n workflow automation platform as a set of MCP tools, letting AI assistants trigger workflows, pass data to automations, and retrieve execution results — all through natural conversation. n8n is a self-hostable (and cloud-hosted) workflow automation tool with 500+ built-in integrations spanning CRMs, databases, email, Slack, GitHub, and more. The official n8n-mcp server (n8n-io/n8n-mcp) runs alongside your n8n instance and authenticates via your n8n API key. Available operations include: list all workflows in your instance, execute a specific workflow by name with custom input data, retrieve execution history and logs, and create or update workflow definitions. A typical use case: Claude triggers an n8n workflow that sends a Slack notification, creates a Jira ticket, and logs the event to a Google Sheet — all in a single natural-language request. n8n also supports acting as an MCP host itself, so you can configure AI tools within n8n workflow nodes. For cloud users, n8n's remote MCP endpoint is available at your n8n.cloud instance. Install locally with: `npx n8n-mcp` and set `N8N_API_URL` and `N8N_API_KEY` in your environment. Works with Claude Desktop, Cursor, VS Code, and all MCP-compatible clients.

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`.

Snowflake now ships a first-party Snowflake-managed MCP server (Generally Available) that lets AI agents securely query Snowflake accounts over Streamable HTTP without deploying any local infrastructure — you configure it to expose Cortex Analyst, Cortex Search, and Cortex Agents as callable tools, plus custom tools and governed SQL execution, all through Snowflake's existing RBAC. It supports MCP revision 2025-11-25 and is documented under Snowflake AI & ML > Cortex Agents in the official docs. Before this hosted option shipped, Snowflake Labs published a community-maintained local server (Snowflake-Labs/mcp) covering Cortex Search/Analyst/Agents, object management, and SQL orchestration via a YAML service-configuration file and the Snowflake Python Connector for auth (username/password, key pair, OAuth, SSO, MFA) — that repo is now deprecated in favor of the managed server, though its docs remain useful for understanding the tool surface. For teams who want a self-hosted, read/write SQL-focused alternative instead of the managed offering, isaacwasserman/mcp-snowflake-server (community, 183+ stars) exposes read_query/write_query, schema-listing, and table-description tools via uvx, with an --allow-write flag gating destructive operations and a memo://insights resource that accumulates discovered data insights across a session.

Connect to data, AI tools & agents, and the rest of the Databricks platform using turnkey managed MCP servers.

Google's official BigQuery MCP integration ships as part of the MCP Toolbox for Databases (googleapis/mcp-toolbox, 15,800+ stars, formerly published under the genai-toolbox repo name before Google renamed it), a single Go-based server binary that speaks the Model Context Protocol for over a dozen Google Cloud and third-party databases. Rather than a BigQuery-only package, you run the shared toolbox binary with a `--prebuilt=bigquery` flag to instantly load BigQuery-specific tools — schema/table discovery (`list_dataset_ids`, `list_table_ids`, `get_table_info`), running arbitrary SQL via `execute_sql`, and dry-run query validation for cost estimation before executing — over stdio or as an HTTP/SSE server. The quickest install is `npx -y @toolbox-sdk/server --prebuilt=bigquery --stdio` in your MCP client config; it also ships as a downloadable binary and Docker image for teams that prefer not to run via npx. Authentication uses standard Google Cloud credential chains (Application Default Credentials, service account keys, or Workload Identity) rather than embedding a project-specific key. Toolbox also underlies Google's official SDKs for Python, JS/TS, Go, and Java, so the same server config can back both ad hoc AI-assistant queries ("show me the schema for the events table and the row count for last week") and production agent tools built with LangChain, LlamaIndex, or ADK. For teams that want a fully managed remote option instead of self-hosting, Google Cloud also offers managed MCP servers for its databases including BigQuery.

Query and analyze data with MotherDuck and local DuckDB.

The official Pinecone Developer MCP Server (pinecone-io/pinecone-mcp) connects coding assistants like Cursor, Claude Desktop, Windsurf, and the Gemini CLI directly to Pinecone's vector database platform. Once connected, an AI client can search live Pinecone documentation to answer setup and API questions accurately, recommend and configure index settings (dimension, metric, pod vs. serverless type) based on an application's embedding model and scale, generate code for common patterns like batch upserts, hybrid search, and metadata filtering, and — when a `PINECONE_API_KEY` is supplied — directly upsert and query vectors in a live index so a developer can test retrieval quality without leaving their editor. It targets developers building with Pinecone as part of their stack, distinct from Pinecone's separate Assistant MCP, which instead surfaces context from a hosted knowledge base for end-user-facing AI assistants. Install with `npx -y @pinecone-database/mcp` (requires Node.js 18+); without an API key the server still works for documentation search, but index management and querying require one from the Pinecone console. A community alternative, sirmews/mcp-pinecone (150+ stars), offers a lighter Python-based server focused purely on index read/write operations for teams that don't need the documentation-search or code-generation tooling.

Weaviate's Model Context Protocol support has moved from a separate add-on into the core Weaviate database itself: as of v1.37.1, every Weaviate instance ships a built-in MCP server that AI assistants like Claude Desktop, Cursor, and Windsurf can connect to directly, with no standalone process to install or maintain. Enabling it is a single environment variable, `MCP_SERVER_ENABLED=true`, on the Weaviate server; the MCP endpoint then listens on the same port as the existing REST API at `/v1/mcp`, reuses Weaviate's existing API-key authentication, and respects the same RBAC permissions already configured for the cluster — so there is no separate credential or trust boundary to manage. Exposed tools cover the core vector-database workflow an AI agent needs: `weaviate-collections-get-config` inspects collection schemas, `weaviate-tenants-list` enumerates tenants in multi-tenant collections, `weaviate-query-hybrid` runs combined vector-plus-keyword hybrid search, and `weaviate-objects-upsert` creates or updates objects. The earlier standalone Go implementation that used to live in the weaviate/mcp-server-weaviate repository is now deprecated and unmaintained — its git history is kept only for reference — so teams should configure MCP through the main weaviate/weaviate server rather than looking for a separate package to install. Full setup, environment variables, and per-tool RBAC permission mapping are documented at docs.weaviate.io/weaviate/configuration/mcp-server.

The official Qdrant MCP server (qdrant/mcp-server-qdrant) turns the Qdrant vector search engine into a semantic memory layer for AI assistants like Claude Desktop, Cursor, and Windsurf. Built on FastMCP, it exposes two core tools: `qdrant-store`, which embeds and saves a piece of text plus optional JSON metadata into a named Qdrant collection, and `qdrant-find`, which runs a semantic similarity search over a collection and returns the most relevant stored entries. Together they let an AI agent persist facts, code snippets, or past conversation context and recall them later by meaning rather than exact keywords — a lightweight long-term memory that survives across sessions. Configuration is entirely environment-variable driven: point `QDRANT_URL` and `QDRANT_API_KEY` at a Qdrant Cloud cluster or self-hosted instance, or use `QDRANT_LOCAL_PATH` to run against an embedded on-disk database with no server. `COLLECTION_NAME` sets a default collection, `EMBEDDING_MODEL` selects the FastEmbed sentence-transformer used to vectorize text (default sentence-transformers/all-MiniLM-L6-v2), and `QDRANT_READ_ONLY` disables the store tool for query-only deployments. Install with `uvx mcp-server-qdrant` (Python/PyPI) and choose stdio or SSE transport via the `--transport` flag. With 1,450+ GitHub stars it is the reference implementation for giving coding agents durable semantic memory.

Comprehensive tools for managing collections and documents in DataStax Astra DB NoSQL database.

The official PlanetScale MCP server connects AI assistants like Claude, Cursor, and VS Code directly to PlanetScale's serverless MySQL and Postgres database platform. Unlike servers you install as a local package, it is a hosted HTTP server reachable at `https://mcp.pscale.dev/mcp/planetscale`, so any MCP client that supports HTTP-hosted (streamable) transports can connect without a local runtime — in Claude Code, run `claude mcp add --transport http planetscale https://mcp.pscale.dev/mcp/planetscale`, and Cursor and VS Code offer one-click install buttons in the PlanetScale docs. Once connected and authenticated against your PlanetScale organization, an agent can list and inspect databases, branches, and keyspaces, read schema and table structures, run and explain queries, review deploy requests and schema changes, and surface performance insights and query statistics — letting you investigate a production database or plan a migration in natural language from inside your editor. The open-source repo (planetscale/mcp-server) contains the TypeScript tool implementations the team maintains directly; additional production tools are generated from PlanetScale's public API OpenAPI spec and served by the hosted endpoint. Because it targets PlanetScale's Vitess-based horizontal sharding and safe online schema-change workflow (branching and deploy requests), it is especially useful for teams running large MySQL fleets who want AI help without handing an agent raw database credentials.

Turso — the SQLite-compatible edge database built on libSQL — runs a single official hosted MCP server at `mcp.turso.ai`, and tursodatabase/turso-mcp is the repo that packages access to it per-agent and doubles as the plugin marketplace each agent's CLI installs from. Authentication is OAuth 2.1 with PKCE and fully discoverable — a developer runs the install command once, then authenticates in a browser tab where consent (organization, group, and scope) is granted directly on the Turso dashboard, which mints a scoped token; every MCP tool call forwards that token to the real Turso API, so the MCP layer itself holds no standing privilege and all org-binding, roles, and audit logging are enforced server-side, with no API token to generate or paste manually. Because it proxies the full Turso Cloud API, an agent can both manage infrastructure — list organizations and databases, create or delete databases, inspect groups and edge-replica locations — and run SQL directly against a database once it's selected. Claude Code installs it via `/plugin marketplace add tursodatabase/turso-mcp` followed by `/plugin install turso@turso`, then `/mcp` → turso → Authenticate; Codex uses the equivalent `codex plugin` commands; any other MCP-capable client can instead point straight at `https://mcp.turso.ai/mcp` and complete the same OAuth flow. Community alternatives spences10/mcp-turso-cloud and nbbaier/mcp-turso remain options for teams that want a self-hosted server with a manually-supplied API token instead of the hosted OAuth flow.

The official Upstash MCP server (upstash/mcp-server) lets an AI assistant manage and debug your Upstash serverless data infrastructure directly from Claude, Cursor, Windsurf, or any MCP-compatible client. It spans Upstash's product line: serverless Redis databases, the QStash message queue and scheduler, Workflow (durable serverless functions), and Upstash Box. Through it an agent can create and configure Redis databases, run Redis commands and inspect keys, review QStash message logs and scheduled jobs, trace Workflow run logs to debug failures, and read account usage and billing details — turning database provisioning and incident triage into a natural-language conversation inside your editor. Install with `npx -y @upstash/mcp-server@latest --email YOUR_EMAIL --api-key YOUR_API_KEY`, using an email and API key generated at the Upstash Console (Account → API Keys); one-click install configs are provided for Cursor and VS Code. A useful safety feature: when started with a read-only API key, the server automatically disables every state-modifying tool (creating or deleting databases, purging backups, retrying workflows), so an agent can freely read and query your account without any risk of destructive changes. For routine work Upstash also recommends its lighter Skill plus `@upstash/cli` combination, reserving the full MCP server for deeper management and debugging tasks.

Introspect and query your apps deployed to Convex.

PagerDuty MCP Server is PagerDuty's official, actively maintained local MCP server (github.com/PagerDuty/pagerduty-mcp-server) for managing incident response directly from an MCP-enabled client like Claude, Cursor, or VS Code. Beyond the standard tool surface for incidents, services, on-call schedules, and event orchestrations, it ships embedded React 'MCP Apps' that render interactive UIs inside supporting IDEs: an Incident Command Center with a real-time incident feed, timeline/notes/alert inspection, one-click acknowledge/escalate/resolve, and AI-powered similar-incident detection; an On-Call Manager for schedule overrides and escalation-policy edits; an On-Call Compensation Report tracking hours worked, interruption rates, and EU Working Time Directive compliance with CSV export; a Service Dependency Graph visualizing upstream/downstream impact; and an Onboarding Wizard for first-time account setup. The server runs as a single Python process via `uv run pagerduty-mcp`, avoiding a separate HTTP server to manage. Authentication uses a PagerDuty User API Token generated from My Profile → User Settings → API Access (Freemium accounts have role-based limits on who can generate one), used subject to PagerDuty's Developer Agreement. This combination of deep incident-lifecycle tooling and embedded operational dashboards makes it one of the more feature-complete official vendor MCP servers for on-call/DevOps teams.

The OpsGenie MCP Server bridges MCP-capable clients like Claude Desktop and Cursor to OpsGenie's alerting and on-call platform, so an on-call engineer can triage incidents from an AI assistant instead of switching to the OpsGenie web console. Alert tools cover list_alerts (with OpsGenie's powerful filter-query syntax for scoping by status, priority, tag, or team), get_alert for full detail, and acknowledge_alert/unacknowledge_alert for actually working an incident from chat. Team tools (list_teams, get_team) let an agent resolve who owns a given alert, and heartbeat tools (list_heartbeats, get_heartbeat) expose the health of OpsGenie's dead-man's-switch monitors — useful for an agent answering "is our nightly batch heartbeat still healthy?" without a dashboard. The server is written in Go, ships as a single binary installable via `go install`, and supports stdio, SSE, and streamable-HTTP transports plus a built-in self-update command. Authentication uses an OpsGenie API token set via the OPSGENIE_TOKEN environment variable (or a custom var name via --token-env-var). Important context: this is a community project, not an Atlassian first-party release — no official Atlassian OpsGenie MCP server exists, and Atlassian has been folding OpsGenie's alerting/on-call features into Jira Service Management's roadmap, so teams already on JSM should also check the Jira MCP Server entry on this site. The repo itself is now archived (last updated 2026-05) but the built binary remains functional for existing OpsGenie accounts.

Observability and monitoring with New Relic.

Manage and interact with the Dynatrace Platform for real-time observability and monitoring.

Query and analyze data, alerts, dashboards, and cross-reference production behavior with codebase.

Lightstep was a distributed-tracing and observability platform built on OpenTelemetry, acquired by ServiceNow in 2021 and folded into the ServiceNow Cloud Observability product line; its GitHub org still hosts the legacy OpenTelemetry Launcher and tracer SDKs for Go, Java, Python, Node.js, and C++, but none of those repos are MCP servers. Neither ServiceNow nor the community has shipped an MCP server exposing Lightstep/Cloud Observability trace and metric data to AI assistants — repeated GitHub and web searches across review cycles turn up zero results for "lightstep mcp" or "servicenow observability mcp" with any real implementation. If you need AI-agent access to distributed tracing data today, check this directory's Honeycomb or Grafana entries, which do have real, actively maintained MCP servers covering similar observability workflows. This entry is kept as a placeholder so the "lightstep mcp" search term stays discoverable and will be updated the moment ServiceNow or a community project ships a real server.

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.

The Intercom MCP Server is Intercom's official, hosted Model Context Protocol integration, giving AI assistants secure access to conversations and contacts in a company's Intercom workspace (currently US-hosted workspaces only). Rather than a local binary, it runs as a remote server at `mcp.intercom.com`, reachable over Streamable HTTP (`https://mcp.intercom.com/mcp`, recommended) or a legacy SSE endpoint kept for backwards compatibility. It exposes six tools: a universal `search` tool that queries either conversations or contacts via a field-based query DSL (operators like eq, neq, gt, lt, contains, plus free-text `q:` search and pagination), a matching `fetch` tool for pulling full resource detail by ID, and four direct-API tools — `search_conversations`, `get_conversation`, `search_contacts`, and `get_contact` — for more targeted lookups by state, source type, author, custom attributes, or email domain. Authentication supports either an automatic browser-based OAuth flow (recommended) or a static Bearer API token, configured in the client as an `mcp-remote` proxy entry pointing at the hosted URL. Typical use: ask Claude to "find all open conversations mentioning a refund from the last week" or "pull the full history and custom attributes for this contact by email," and the assistant queries live Intercom data instead of requiring a CSV export or manual dashboard search — useful for support triage, customer research, and drafting responses grounded in real conversation history.

This Zendesk MCP Server (by community maintainer reminia, 100+ GitHub stars, Apache 2.0) gives AI assistants full read/write access to Zendesk support tickets, comments, and Help Center articles for triage, response drafting, and knowledge-base search directly from Claude Desktop, Claude Code, or Cursor. It's a Python server installed with `uv` (or run in Docker for isolated deployments) and configured with Zendesk API credentials via a `.env` file — subdomain, agent email, and an API token generated from the Zendesk admin panel. Beyond raw ticket/comment CRUD, the server ships specialized MCP prompts purpose-built for support workflows: ticket analysis (summarizing a thread's history and sentiment) and response drafting (generating a reply grounded in the ticket's comment history and matching Help Center articles), plus full-text access to the Help Center knowledge base so the assistant can cite existing documentation instead of hallucinating an answer. Typical use: ask Claude to "pull ticket #4821, summarize the customer's issue, and draft a reply referencing our refund policy article" — the assistant fetches the ticket and comments, cross-references the Help Center, and returns a ready-to-send draft. A good fit for support teams already living in Claude/Cursor who want ticket context surfaced without tab-switching to the Zendesk agent console.

The Freshdesk MCP Server connects MCP-capable clients like Claude Desktop and Cursor to Freshdesk's help-desk platform, letting an AI assistant handle support operations through natural language instead of the Freshdesk admin UI. Ticket tools cover the full lifecycle: create_ticket (with subject, description, priority, status, custom fields), update_ticket, delete_ticket, get_ticket, get_tickets with pagination, and search_tickets against Freshdesk's query syntax — plus conversation-level tools for get_ticket_conversation, create_ticket_reply, create_ticket_note, and update_ticket_conversation so an agent can both read a customer thread and post a reply or internal note without a human copy-pasting between systems. A ticket-summary tool set (view/update/delete) exposes Freshdesk's AI-generated ticket summaries directly. Beyond tickets, the server covers agent management (get_agents, view_agent, create_agent, update_agent, search_agents), contacts (list/get/search/update), and companies (list/get/search/find_company_by_name/list_company_fields) — enough surface area to let an agent triage an incoming ticket, look up the requester's company and past tickets, and draft or send a reply in one conversational flow. Example prompts from the maintainer include "list previous tickets of customer A101 in last 30 days" and "update the status of ticket #12345 to Resolved." Authentication uses a Freshdesk API key plus your Freshdesk subdomain, set as FRESHDESK_API_KEY and FRESHDESK_DOMAIN environment variables; install via uvx or the Smithery CLI. This is a community project (not published by Freshworks itself), MIT-licensed and the most-starred Freshdesk MCP implementation on GitHub.

The Salesforce DX MCP Server (npm package `@salesforce/mcp`) is Salesforce's official Model Context Protocol integration, built and maintained by the Salesforce CLI (salesforcecli) team to let AI assistants read, manage, and operate Salesforce orgs securely from Claude, Cursor, VS Code, Windsurf, or Cline. Rather than exposing one flat set of tools, it is organized into configurable toolsets you enable with the `--toolsets` flag: `orgs` (list and inspect the orgs you've authenticated), `data` (run SOQL queries and read/create/update records for standard and custom objects), `metadata` (deploy and retrieve source and metadata), and `users` — plus individually-gateable tools such as `run_apex_test`. This makes it useful both for developers automating deploys and Apex test runs and for RevOps teams asking Claude to "pull all open opportunities closing this quarter over $50K" or "update this deal to Negotiation." A key security design point: the server never takes raw usernames and passwords — instead it operates on orgs you have already authenticated through the Salesforce CLI (`sf org login`), which you reference by alias via the `--orgs` flag, so credentials stay in the CLI's secure store and each MCP session is scoped only to the orgs you explicitly allow. Install with `npx -y @salesforce/mcp --orgs DEFAULT_TARGET_ORG --toolsets orgs,metadata,data,users`. Apache-2.0 licensed. Community CRM-focused alternatives such as tsmztech/mcp-server-salesforce and smn2gnt/MCP-Salesforce exist for teams wanting a lighter SOQL-and-records-only server.

Community-built MCP server that connects Claude, Cursor, and other MCP clients to the Pipedrive API v2 for CRM data access. Exposes deals, persons, organizations, and pipelines — including custom fields — as MCP resources, plus predefined prompts for common CRM operations like pulling pipeline status or filtering deals by owner, stage, date range, or value. Read-only by design, so agents can safely query sales data without risking accidental writes to production CRM records. Supports both stdio transport for local desktop clients and SSE transport for networked deployments, with built-in JWT authentication and API rate limiting to stay within Pipedrive's request quotas. Ships as a published npm package and as a multi-stage Docker image with docker-compose support for one-command standalone deployment, health checks included. Authentication uses a Pipedrive API token plus your company's Pipedrive domain, set via environment variables. Useful for sales teams wiring an AI assistant into deal review, pipeline forecasting, or account research workflows without building custom API integration code from scratch.

Close does not publish an official Model Context Protocol server — a `closeio/mcp-server` repo does not exist. The strongest real option is bcharleson/close-crm-cli, a TypeScript CLI-and-MCP-server hybrid that exposes Close's full REST API (160+ commands across 30 resource groups: leads, contacts, opportunities, tasks, calls, notes, emails, SMS, meetings, pipelines, custom fields, webhooks, outreach sequences, smart views, and analytics reports) both as terminal commands and as MCP tools. Run `close mcp` to start the server, or wire it into Claude Desktop / Cursor / Windsurf via `npx close-crm-cli mcp` with a `CLOSE_API_KEY` env var (generated from Close's Settings → API page). HTTP Basic Auth, offset-based pagination, and automatic exponential-backoff retry on 429/5xx are all handled for you, and JSON output is the default so responses pipe cleanly into an agent or `jq`. Typical use: ask Claude to "list my open opportunities in the demo-scheduled stage" or "log a call and create a follow-up task" without leaving the chat. Not an official Close product — early-stage community project, so expect rough edges and verify write operations before relying on them in production pipelines.

The Monday.com MCP server is the official Model Context Protocol integration built by Monday.com, giving AI assistants like Claude and Cursor direct access to your Monday.com workspace. Teams use it to query board data, create and update items, track project status, and automate workflow updates through natural-language interactions — without opening the Monday.com web interface. Key capabilities include: listing workspace boards and their column configurations, reading item statuses and assignees, creating new items with custom field values, updating existing item statuses across groups, and querying sub-items and dependencies within boards. This makes the Monday.com MCP server particularly useful for project managers who want to ask Claude to summarize overdue tasks, update sprint statuses after standups, or generate a status report for a client from board data. Authentication uses a Monday.com API token, which you generate from your account's Developer section (navigate to Admin → Developers → Create App or use personal API tokens). The server communicates with Monday.com's GraphQL API, so all data is live and real-time. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline. For teams running agile workflows, the server enables AI-assisted sprint planning, velocity reporting, and backlog grooming without context-switching between your AI assistant and the Monday.com dashboard.

ClickUp MCP Server connects AI assistants to your ClickUp workspace so you can manage tasks, docs, and time entries with natural language instead of clicking through the app. This community server (by hauptsacheNet) authenticates with a ClickUp API key and team ID and ships three operating modes — read-minimal for lightweight coding-assistant context, read for full workspace exploration, and write (default) for complete task and document management. Its standout feature is rich task context: getTaskById returns full comment history, status changes, and inline images in a single call, so agentic coding tools can pull a ClickUp ticket, its linked screenshots, and prior discussion without chaining multiple requests. It also supports fuzzy multi-language search across tasks and documents, time-entry logging and retrieval, and append-only description updates that never overwrite existing task content — new notes are timestamped and added rather than replacing history, which keeps ClickUp's own audit trail intact. An official OAuth-based ClickUp MCP also exists for chat-app and Connected Search use cases; this API-key server is better suited to CI/CD, automation, and coding-tool integrations.

The Wrike MCP Server gives MCP-capable clients full CRUD access to Wrike's work-management platform, letting an AI assistant discover, read, and modify tasks, folders, and spaces directly from chat. Its standout feature is a discover_account bootstrap tool that identifies the authenticated user, enumerates every space, lists top-level folders with their workflow assignments, and catalogues account-level and space-scoped workflows plus custom fields and item types — this front-loads the account-structure discovery an agent would otherwise need several manual calls to piece together before it can safely create or move anything. Read tools cover task search by title/status, full task detail (including comments and attachments in one combined call via get_task_full), workflow and custom-field listings, folder browsing, and recursive folder-task listing. Write tools cover task creation with assignees/dates/importance/custom fields, updates to any task field, completion, moving tasks between folders, deletion of tasks/folders/spaces, and file attachment uploads. Authentication uses a Wrike Permanent Access Token generated from the Wrike API console, stored either in the system keychain via a bundled wrike-auth CLI or as a WRIKE_ACCESS_TOKEN environment variable. This is an early-stage community project (not an official Wrike release) installed from source with pip — worth noting since Wrike itself has not published a first-party MCP server, so this fills a real gap for teams wanting AI-agent access to their Wrike workspace.

The Basecamp MCP Server connects MCP-capable clients like Claude Desktop, Claude Code, Codex, and Cursor to Basecamp 3 through OAuth-authenticated API calls, letting an AI assistant read and manage a team's projects without leaving the chat. Built on the official mcp.server.fastmcp Python SDK, it exposes 79 tools spanning the full breadth of Basecamp 3: project and to-do list browsing, to-do creation/updates/completion, message board posts (including drafts and categories), Campfire chat reading, card table and card-step management, document reading and drafting, comment creation, inbox forward handling, daily check-in answers, file uploads, event listings, and webhook management. A built-in search tool queries across projects, to-dos, messages, Campfire lines, comments, uploads, and schedules in one call, useful for an agent trying to find "what did the team decide about X" without paging through each tool individually. Setup requires a Basecamp OAuth application registered at launchpad.37signals.com/integrations, then running the bundled oauth_app.py flow once to store a local token; config-generator scripts are included for Codex, Cursor, and Claude Desktop so the MCP entry gets written automatically rather than hand-edited. This is a community project (not published by 37signals/Basecamp itself), MIT-licensed and actively maintained, and is currently the most complete open-source Basecamp MCP integration — competing alternatives top out around 46 tools versus this server's 79.

The Trello MCP server gives AI assistants full read/write access to Trello boards, lists, and cards through the Model Context Protocol. The most widely adopted community implementation is delorenj/mcp-server-trello, a TypeScript server (now Bun-powered for a 2.8-4.4x speed boost over the original Node build) that wraps the Trello REST API with built-in rate limiting, type safety, and dynamic board/workspace switching. Tools cover the full card lifecycle: create, update, move, and archive cards; manage checklists, labels, members, and file attachments pulled in from URLs; add, edit, and delete comments; and export card data as human-readable markdown. Because boardId and workspaceId can be passed per-call instead of hardcoded in the config, one server instance can drive multiple boards and workspaces without a restart, and the active board persists locally between sessions. Setup requires a free Trello API key and token (from trello.com/app-key), configured via TRELLO_API_KEY and TRELLO_TOKEN environment variables, with an optional TRELLO_ALLOWED_WORKSPACES allowlist for restricting agent access in multi-tenant or security-conscious setups. It is commonly paired with agent workflows for sprint planning, kanban automation, and syncing tasks between chat and boards without leaving the AI assistant.

Coda MCP Server (built by TJC L.P., unofficial and not affiliated with Coda) gives AI assistants full read/write access to Coda.io docs through the Coda REST API — install via `uvx coda-mcp-server` with a Coda API token from your account settings, no local Python environment setup required. It covers the whole document model: list, create, read, update, and delete docs; browse and edit pages, including exporting full page content to HTML or Markdown for long-form review; and inspect tables, views, and column formulas. Row operations support querying and filtering table data, upserting rows in bulk, updating single rows, deleting rows, and even pushing button-column actions programmatically — useful for treating a Coda table as a lightweight database an agent can read and write. It also exposes named formulas so an assistant can look up and reason about doc-level calculations. Since v1.1.0 the server uses snake_case field names (e.g. `browser_link`) for cleaner Python-ecosystem compatibility. Best fit for teams that keep specs, trackers, or internal wikis in Coda and want an agent to pull structured data out of docs or automate repetitive table edits without a human opening the app.

Perform queries and entity operations in your Fibery workspace.

A Python-based MCP server that lets Claude, Cursor, and other AI tools interact with X/Twitter through natural-language commands, built on the official Twitter API v2 rather than username/password scraping hacks (which risk account suspension). It exposes tools to fetch user profiles, followers, and following lists; post, delete, and favorite tweets; search tweets and trending topics; manage bookmarks and timelines; and handle rate limits automatically across the v2 endpoint surface. Authentication requires a Twitter Developer Account with API Key, API Secret, Access Token, Access Token Secret, and Bearer Token from the Twitter Developer Portal — there is no keyless or scraping-based mode, so this targets developers who already have (or are willing to apply for) API access rather than casual users. Install options include Smithery (`npx -y @smithery/cli install @rafaljanicki/x-twitter-mcp-server --client claude`) for one-command Claude Desktop setup, PyPI (`pip install x-twitter-mcp`) for a quick manual install, or cloning the source with `uv sync`/`pip install .` for development. The project is a smaller community effort (35 stars) compared to the official Twitter API tooling ecosystem, but is actively maintained and one of the few X/Twitter MCP servers built on the sanctioned API path rather than reverse-engineered browser automation.

X and Twitter automation MCP server for tweet search, profile tweets, follower export, media workflows, webhooks, and confirmation-gated posting.

A clean, LLM-optimized MCP server that lets Claude Desktop and other AI assistants browse Reddit, search posts, and analyze user activity with zero setup and no Reddit API registration required. Core tools include `browse_subreddit` (hot/new/top/rising/controversial sorting across any subreddit, "all", or "popular", with time-range filters), `search_reddit` (query across all of Reddit or a specific subreddit, filterable by author/time/flair, sortable by relevance/hot/top/new/comments), `get_post_details` (fetch a post plus its full comment thread from a Reddit URL in any format — reddit.com, old./new./np./m.reddit.com, or redd.it short links — or from a bare post ID), and `user_analysis` (karma, post/comment history, and active subreddits for any username). A three-tier authentication system scales from 10 requests/minute with zero config up to 100 requests/minute when Reddit API credentials are supplied, so it works instantly out of the box and scales up for heavier use. The project deliberately avoids fabricated "sentiment analysis" or made-up metrics, focusing on clean, structured Reddit data formatted for LLM consumption. Install as a Claude Desktop Extension (.mcpb one-click download), via NPM (`npx -y reddit-mcp-buddy`), or through the official MCP Registry — it is fully TypeScript, actively maintained, and one of the most-starred Reddit MCP integrations available.

The Hacker News MCP server gives Claude, Cursor, and other MCP clients live access to Hacker News so an AI assistant can pull the latest stories, comment threads, and user profiles into a conversation. This community server (paabloLC/mcp-hacker-news, TypeScript) acts as a thin, well-behaved bridge over the official Firebase-backed Hacker News API — it does not scrape the site, so results match what you see on news.ycombinator.com. It exposes standard MCP tools for fetching top, new, best, Ask HN, Show HN, and job stories, retrieving a specific item with its nested comment tree, and looking up a user's karma, bio, and submission history. That makes it useful for tracking what is trending in the developer and startup community, summarizing long comment discussions, monitoring a launch or a topic, or feeding fresh HN context into research and content workflows. Installation is zero-config: point your client at `npx -y mcp-hacker-news` (Node.js 18+ required) and it runs over stdio with no API key or authentication, since the Hacker News API is public and read-only. Note this is a lower-star community project rather than an official Y Combinator release — it is a lightweight, dependency-free option that is easy to audit and self-host if you prefer.

The Product Hunt MCP Server connects Claude, Cursor, and other MCP clients directly to Product Hunt's official GraphQL API, letting an AI assistant look up launches, collections, topics, users, votes, and comments without leaving the conversation. Built with FastMCP for speed, the server exposes tools to fetch detailed post info (tagline, description, vote count, maker list, comments), search and filter launches by topic, date range, or vote threshold, page through paginated comment threads and a user's upvote history, and pull collection and topic metadata. It is a good fit for AI-agent workflows that need to research competitor launches, track a specific topic's daily leaderboard, summarize maker comments, or build a "what shipped today" digest inside an agent pipeline. Authentication uses a personal Product Hunt Developer Token generated from the Product Hunt API Dashboard (any placeholder redirect_uri works, since the MCP server never uses an OAuth redirect flow itself) supplied via the PRODUCT_HUNT_TOKEN environment variable. Install with `pip install product-hunt-mcp` or `uv pip install product-hunt-mcp`; a Docker image and a git+https install path are also documented for teams that prefer container-based MCP deployments. Config for Claude Desktop or Cursor just points the command at the installed `product-hunt-mcp` binary with the token set in the env block.

The arXiv MCP Server bridges AI assistants to arXiv's research repository through the Model Context Protocol, letting Claude, Cursor, VS Code, and other MCP clients search, download, and read academic papers directly inside a conversation. The core workflow is search_papers → download_paper → read_paper: search_papers queries arXiv with boolean, category (cs.AI, cs.LG, cs.CL, cs.CV, stat.ML, quant-ph, and more), and date-range filters while automatically respecting arXiv's 3-second rate limit; download_paper fetches a paper by its arXiv ID (HTML first, PDF fallback) and stores it locally, returning content_length/next_start metadata so clients can safely page through very large papers; read_paper then returns the full text as markdown, with start/max_chars pagination for long documents. list_papers shows everything downloaded locally, and semantic_search searches across that local collection. The server also ships a "deep-paper-analysis" prompt that walks an assistant through executive summary, methodology, results, and future-research-direction analysis for a given paper ID. Install with `uv tool install arxiv-mcp-server` (NOT npm — an unrelated third-party package squats the same name on npm) or via the one-click Claude Desktop .mcpb bundle; a Streamable HTTP transport is available for server deployments. The README explicitly flags that arXiv paper content is untrusted external input and warns about prompt-injection risk (OWASP LLM01/AG01) when feeding raw paper text into agentic pipelines with tool access.

The Semantic Scholar MCP Server is a FastMCP-based Python server that connects Claude, Cursor, VS Code, and other MCP clients to the Semantic Scholar API — the Allen Institute for AI's corpus of 200M+ academic papers — so an assistant can search literature, trace citation networks, and pull author profiles directly inside a conversation instead of guessing from training data. On the paper side it exposes full-text and title-based search with advanced filtering, multi-strategy ranked search, single- and multi-paper recommendations, and efficient batch detail retrieval with customizable field selection. Its citation-analysis tools walk the citation graph in both directions — citations and references — with citation context and influence signals, which is what makes it a strong fit for literature-review and citation-tracing agents rather than one-off lookups. Author tools cover author search, profile details, publication history, and batch author retrieval. It works unauthenticated for light use, but setting a SEMANTIC_SCHOLAR_API_KEY environment variable raises rate limits for heavier workflows; the server handles rate-limit compliance, connection pooling, and graceful shutdown internally. Install with `pip install semantic-scholar-fastmcp` or run it with no install via `uvx semantic-scholar-fastmcp`, then point your client's config at the uvx command. A Smithery one-click install for Claude Desktop and a companion Claude Code skills bundle (expand-references, trace-citations, paper-triage) are also available. Requires Python 3.10+.

This Wolfram Alpha MCP server gives AI assistants a direct line to the Wolfram|Alpha computational knowledge engine, letting them run math, science, unit-conversion, and structured data queries and get back verified answers instead of guessing at arithmetic or facts. It wraps the Wolfram|Alpha API in an MCP-compliant interface with a modular architecture designed to be extended to additional Wolfram APIs and multi-client setups. Beyond the server itself, the project bundles an example MCP client built on Gemini via LangChain, plus an optional Gradio web UI for interacting with both Google AI and the Wolfram Alpha MCP server side by side — useful for testing queries before wiring the server into Claude Desktop, Cursor, or VS Code. Configuration requires a WOLFRAM_API_KEY (a free Wolfram|Alpha AppID) set via a .env file, and an optional GeminiAPI key if using the bundled LangChain client. Install by cloning the repo and running `pip install -r requirements.txt` (or `uv sync`), then point your MCP client at the packaged server.py entry point; a VS Code MCP config template and Docker build files for the client/UI are included in the repo. Because Wolfram|Alpha handles the actual computation server-side, this server is a strong fit for agentic workflows that need reliably correct math or unit conversions rather than LLM-generated approximations.

This Weather MCP Server (the Open-Meteo MCP Server) gives Claude, Cursor, VS Code, and other MCP clients comprehensive access to the free Open-Meteo weather APIs — no API key required — so an assistant can answer forecast, historical, air-quality, and marine questions with live data instead of stale training knowledge. Its core tools cover weather_forecast (7-day forecasts at hourly and daily resolution), weather_archive (historical ERA5 reanalysis data back to 1940), air_quality (PM2.5/PM10, ozone, nitrogen dioxide, pollen, European/US AQI and UV index), marine_weather (wave height/period/direction and sea-surface temperature), elevation, and geocoding to resolve place names or postal codes to coordinates. Beyond the basics it exposes specialized national-model tools — DWD ICON (Europe), NOAA GFS (US/global), Météo-France AROME/ARPEGE, ECMWF, JMA (Asia), MET Norway, and Environment Canada GEM — plus advanced tools for flood forecasting (GloFAS river discharge), seasonal forecasts up to nine months out, CMIP6 climate projections, and ensemble forecasts that surface model uncertainty. The fastest install is zero-config via npx: `npx -y open-meteo-mcp-server` (Node.js 22+), with optional environment variables to point each Open-Meteo sub-API at a self-hosted endpoint; a Docker image and from-source build are also published. If you specifically need a WeatherAPI.com-backed single-tool `current_weather` server instead, ezh0v/weather-mcp-server (Go, ~250 stars) is a lighter API-key-based alternative.

The official Financial Datasets MCP Server gives Claude and other AI assistants direct access to stock market and crypto data through the Financial Datasets API, so an assistant can pull real fundamentals and prices instead of relying on stale training data. It exposes ten tools: get_income_statements, get_balance_sheets, and get_cash_flow_statements for company financial statements; get_current_stock_price and get_historical_stock_prices for equity pricing; get_company_news for recent headlines; and get_available_crypto_tickers, get_current_crypto_price, get_crypto_prices, and get_historical_crypto_prices for crypto markets. It is a Python server built on the official `mcp[cli]` SDK plus httpx, requiring Python 3.10+ and the uv package manager. Setup is clone the repo, run `uv venv && uv add "mcp[cli]" httpx`, then supply a FINANCIAL_DATASETS_API_KEY in a .env file before pointing Claude Desktop's config at `uv run server.py` with the project's absolute path. Once connected, an assistant can answer questions like "what are Apple's recent income statements" or "get historical prices for MSFT from 2024-01-01 to 2024-12-31" using live data rather than guessing.

Connect to 100+ APIs for financial market data from Alpha Vantage.

MiniMax MCP is MiniMax's official, first-party Model Context Protocol server for text-to-image generation, alongside video and audio generation — the highest-starred general-purpose image-generation MCP server on GitHub (1,500+ stars, MIT licensed, actively maintained), a strong signal for the broad "AI image generation MCP" search intent this page targets versus single-model options like Replicate Flux or Stability AI covered in their own dedicated entries elsewhere in this directory. The `text_to_image` tool generates images directly from a prompt; companion tools cover `generate_video` (with the MiniMax-Hailuo-02 model, configurable 6s/10s duration and 768P/1080P resolution), `music_generation` (prompt+lyrics to a full music track via the music-1.5 model), `text_to_audio` plus `voice_clone` and `voice_design` for custom TTS voices, and `query_video_generation` for polling async video jobs. Install via `uvx minimax-mcp -y` (Python/uv-based) with a `MINIMAX_API_KEY` from the MiniMax platform — note the API key and `MINIMAX_API_HOST` must match your account region (Global: api.minimax.io, Mainland China: api.minimaxi.com) or requests fail with an invalid-key error. Supports both stdio (local) and SSE (local or cloud-deployed) transport, with a `MINIMAX_API_RESOURCE_MODE` env var controlling whether generated assets are returned as a URL or downloaded to a local output path. A companion `MiniMax-MCP-JS` package offers an official JavaScript implementation for non-Python environments. Works with Claude Desktop, Cursor, Windsurf, and OpenAI Agents SDK clients — usage incurs MiniMax API costs per generation.

MCP for Replicate Flux Model is a TypeScript server built specifically around Replicate's Flux image-generation models, giving AI assistants a direct tool for generating customized images and SVG assets that match a project's coding vibe or design aesthetic. It streamlines AI-powered visual asset creation for developers — generating illustrations, icons, and mockups on demand from a text prompt without leaving the assistant conversation — using a Replicate API token for auth. Note this server is scoped to Flux image generation rather than Replicate's full model catalog; developers needing broader access to arbitrary Replicate models (video, audio, LLMs, etc.) should look at deepfates/mcp-replicate, a more general-purpose Replicate API server (currently archived but still functional as a reference implementation).

Stability AI has not published a first-party MCP server, but alesurli/mcp-stability-ai is an actively maintained community implementation (npm package `mcp-stability-ai`, MIT licensed, CI-tested) that wires Stability's v2beta image API into Claude Desktop for fully conversational generation and editing — no manual file-path juggling required. On the generation side it exposes three model tiers as separate tools: `generate_image_sd3` (Stable Diffusion 3.5, best overall quality with negative-prompt support, roughly $0.035–$0.065/image), `generate_image_core` (fast generation with built-in style presets, ~$0.03/image), and `generate_image_ultra` (highest photorealistic quality, ~$0.08/image). Editing tools cover the workflows a product or marketing team actually needs: `remove_background` for transparent-PNG cutouts, `replace_background` which swaps and relights a background for product-shot work, `inpaint` for prompt-driven masked-region edits, `search_and_replace` and `search_and_recolor` for maskless object swaps and recoloring by natural-language description, and `outpaint` to extend a canvas in any direction. The author built it specifically as a maintained Stability.ai bridge for people who want the API-based service inside a Claude conversation rather than running a local GPU stack like ComfyUI or Automatic1111 — it is explicitly positioned as a complement to, not a replacement for, those local-first tools. Requires a `STABILITY_API_KEY` from the Stability AI platform; install with `npx -y mcp-stability-ai` and add the key as an environment variable in the Claude Desktop config.

Anthropic does not publish a Model Context Protocol *server* for Claude — a `anthropics/mcp-server` repo does not exist, and Anthropic's own `anthropics/claude-ai-mcp` repo is just an issue tracker for reporting MCP-integration bugs in Claude Desktop and Claude Code, not an installable server. That is because Claude sits on the other side of the protocol: Claude Desktop, Claude Code, and the Claude API are MCP *hosts/clients* that connect OUT to the thousands of servers in this directory (filesystem, databases, GitHub, Slack, and so on) — Anthropic is also the steward of the MCP specification itself, publishing the protocol spec and reference SDKs/servers through the separate `modelcontextprotocol` GitHub org rather than shipping "Claude" as a callable tool server. If you want another AI agent to call Claude as a tool over MCP, no first-party server exists for that today; teams typically wrap the Anthropic Messages API in a small custom MCP server using the official Python/TypeScript SDK. This entry is kept for search/reference purposes — same resolution as the OpenAI, Codeium, and Gitpod entries in this directory, none of which have a first-party MCP server despite the search demand.

Cohere does not ship a dedicated, official Model Context Protocol server — a `cohere-ai/mcp-server` repo does not exist, and the handful of community MCP wrappers found for Cohere's chat/embed/rerank endpoints (e.g. thin single-file projects with zero to a few stars) are early, unmaintained, or unofficial. The closest first-party, actively maintained repo is cohere-ai/cohere-toolkit (3,000+ stars), Cohere's official open-source toolkit for building and deploying RAG and tool-use applications on top of the Cohere platform — it includes reference implementations for connecting retrieval, tool-calling, and agentic workflows to Cohere's Command models, which is the same groundwork any MCP wrapper for Cohere would need. Teams wanting an assistant to call Cohere directly today typically write a small custom MCP server around the Cohere Python or TypeScript SDK, exposing tools like generate_text, embed_documents, or rerank_results authenticated with a `CO_API_KEY`. Typical use once wired up: ask Claude to "embed these 50 support tickets and cluster them by topic" or "rerank these search results by relevance to the user's question," with the assistant calling Cohere's embed/rerank endpoints instead of a generic model. Update this entry if Cohere or a well-adopted community project ships a real dedicated MCP server.

There is no official `mistralai/mcp-server` repo — Mistral AI does not currently publish a first-party MCP server. The most complete real alternative is the community-maintained `mistral-mcp` package (Swih/mistral-mcp, MIT-licensed, published to npm), which exposes the full Mistral API surface as MCP tools, resources, and prompts rather than just chat completions. Unique tools include `mistral_ocr` (Document AI — structured text plus bounding-box annotations from any PDF or image), `voxtral_transcribe` (audio transcription with optional speaker diarization), `codestral_fim` (fill-in-the-middle code completion), and `workflow_execute`/`status`/`interact` for Temporal-backed durable, human-in-the-loop multi-step workflows. It ships four tool-exposure profiles via `MISTRAL_MCP_PROFILE` — `core` (12 tools, default, lean daily use), `admin` (41 tools, full API surface including embeddings, batch, classify, files, agents, TTS), `workflows` (7 tools, pipeline/connector focus), and `metier-docs` (13 tools, document-processing vertical) — plus French-first prompts and skills (meeting minutes, legal summaries, invoice reminders) aimed at European teams evaluating GDPR/DORA-sensitive AI stacks. Install with `npx -y mistral-mcp@latest` (or `claude mcp add mistral -- npx -y mistral-mcp@latest`) and a `MISTRAL_API_KEY`; a Claude Code plugin (`/plugin install mistral-mcp@swih-plugins`) auto-installs and prompts for the key. Typical use: ask Claude to "OCR this invoice PDF and extract the line items" or "transcribe this meeting recording with speaker labels" and the assistant calls straight into Mistral's Document AI and Voxtral models. It is community-built, not an official Mistral integration — nothing here changes Mistral's own data-handling terms.

The Perplexity MCP Server is the official server from Perplexity AI that brings real-time web search, reasoning, and deep research into any MCP-compatible client through the Perplexity Sonar API. Unlike scrapers or search-index wrappers, it taps Perplexity's own answer engine, so Claude gets grounded, citation-backed responses drawn from live web results. The server exposes four purpose-built tools: perplexity_search returns ranked web results with snippets for lightweight lookups; perplexity_ask provides general-purpose conversational answers with real-time search using the sonar-pro model, ideal for quick everyday questions; perplexity_research runs deep, comprehensive investigations with the sonar-deep-research model for thorough analysis and detailed reports; and perplexity_reason handles advanced problem-solving and multi-step analytical tasks with the sonar-reasoning-pro model, with an optional strip_thinking parameter to control chain-of-thought output. Authentication uses a single PERPLEXITY_API_KEY from the Perplexity API dashboard. Installation is a one-line npx command with the official @perplexity-ai/mcp-server package — add it to Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, or Codex, with a Docker image and HTTP transport also supported for server deployments. Because it is Perplexity's first-party implementation (2,300+ GitHub stars), the Perplexity MCP Server is the most reliable way to give an AI agent fresh, sourced answers — perfect for research assistants, fact-checking, and any workflow that needs current information the base model was never trained on.

The Tavily MCP server (tavily-ai/tavily-mcp) is the official, production-ready Model Context Protocol server for Tavily, a search API built specifically for AI agents and RAG pipelines rather than human browsing. It exposes four tools: tavily-search runs real-time web searches tuned for LLM consumption (returning clean, ranked, source-cited results instead of raw HTML), tavily-extract pulls the full clean content out of one or more specific URLs, tavily-map builds a structured map of a site's pages starting from a root URL, and tavily-crawl walks a site to gather content across many pages in a single call. Together these let an assistant answer "search for the latest changelog entries for library X and summarize the breaking changes" or "extract the pricing table from these three competitor pages" with grounded, up-to-date, citation-backed data instead of stale training knowledge. Authentication uses a single `TAVILY_API_KEY` from tavily.com (a generous free tier is available). You can run it locally with `npx -y tavily-mcp@latest` in your Claude Desktop, Cursor, Windsurf, or Cline config, or connect to Tavily's hosted remote server at mcp.tavily.com for a zero-install setup. Typical use: give a coding or research agent live web access so it can verify facts, read documentation it has never seen, and cite real sources — one of the most widely adopted search servers in the MCP ecosystem.

Community-built MCP server that gives AI agents live Google Search and webpage scraping through the Serper API — a fast, low-cost alternative to Google's own Custom Search. Exposes two tools: `google_search`, which returns rich SERP data (organic results, knowledge graph, 'people also ask', related searches) with region and language targeting, pagination, time filters, autocorrection, and full Google advanced-operator support (site:, filetype:, inurl:, intitle:, related:, before:/after: date ranges, exact-phrase, exclusion, and OR alternatives); and `scrape`, which extracts clean plain-text or markdown content from any URL along with JSON-LD structured data and head metadata while preserving document structure. Written in TypeScript and distributed on npm as `serper-search-scrape-mcp-server` (also available via Smithery for one-command Claude Desktop setup). Requires a Serper API key set as the `SERPER_API_KEY` environment variable; Serper's free tier of 2,500 queries makes it popular for prototyping RAG and research agents. Ideal for grounding LLM answers in current web results, competitive research, fact-checking, and building agents that need to both search and read pages without wiring up separate search and scraping providers.

The You.com MCP Server (published as `@youdotcom-oss/mcp`) is a lightweight STDIO bridge that proxies MCP clients to You.com's hosted MCP endpoint at `https://api.you.com/mcp`, rather than running search logic locally — the actual retrieval and ranking happen on You.com's servers. It ships from You.com's own `youdotcom-oss` GitHub organization as part of their dx-toolkit monorepo, not the fabricated `you-com/mcp-server` repo sometimes cited elsewhere. Install by running `npx @youdotcom-oss/mcp` directly in your MCP client config, or add it as a dependency with `bun add @youdotcom-oss/mcp`; authentication requires a `YDC_API_KEY` environment variable, sent as a Bearer token to the hosted endpoint. By default the server exposes three tools: `you-search` for real-time web search grounded in You.com's independent index, `you-research` for deeper multi-step research queries that synthesize across several sources, and `you-contents` for fetching and extracting clean content from specific URLs. A fourth tool, `you-finance`, covers stock/market data but is opt-in only — it must be explicitly added via the `YDC_ALLOWED_TOOLS` environment variable (e.g. `YDC_ALLOWED_TOOLS=you-search,you-finance`) rather than being enabled by default. Typical use: an agent needs current information beyond its training cutoff — "search for the latest news on X" or "research competing products in this space and summarize the differences" — and calls You.com's search/research tools instead of relying on stale internal knowledge or a generic scraping fallback.

Search the web using Kagi's search API.

The Browserless MCP Server is Browserless.io's official Model Context Protocol integration, exposing Browserless's smart-scraper and browser-automation API as tools any MCP-compatible AI assistant can call — Claude Desktop, Cursor, VS Code, and Windsurf among them. The fastest path is the hosted remote server at `https://mcp.browserless.io/mcp`, authenticated with a Browserless API token (a free tier is available), so most users never run anything locally. Core capabilities: a scraping tool that cascades through strategies (plain HTTP fetch, proxy, full headless-browser render, and CAPTCHA solving as needed) and returns content as markdown, HTML, screenshot, PDF, or extracted links; a web-search tool covering web/news/image search with geo-targeting and time-range filters, with optional per-result scraping; a raw Puppeteer-execution tool that runs custom JavaScript against a live page object on Browserless's cloud browsers for cases the built-in tools don't cover; and a stateful agent-loop mode that keeps a persistent browser session alive across multiple tool calls with snapshot/observe/act primitives, instead of forcing one-shot page loads for every step. This makes it a fit for AI research agents that need to click through paginated results, fill and submit forms, or verify a scrape against a live rendered page rather than a static fetch. The github.com/browserless/mcp-server URL sometimes cited for this project does not exist — the real official repo lives at browserless/browserless-mcp; a separate community implementation, Lizzard-Solutions/browserless-mcp, offers a comparable self-hosted alternative for teams that want to run the bridge themselves instead of the hosted endpoint.

The official ScrapingBee MCP Server turns ScrapingBee's managed web-scraping infrastructure into an AI-native data layer, so AI agents register scraping as a formally callable MCP tool instead of guessing at fetch/parse logic inside a prompt. The architecture is a clean pipeline: AI agent → MCP client → ScrapingBee MCP server → ScrapingBee API → target website → structured JSON response injected back into the agent's context. ScrapingBee handles the parts language models cannot reliably do themselves — bypassing anti-bot protection, rotating proxies, rendering JavaScript-heavy pages, and solving CAPTCHA challenges — which makes this a good fit for AI research agents, ecommerce intelligence bots, and market-monitoring pipelines that need live web data rather than stale training data. The fastest path is the hosted remote MCP endpoint: add it to claude_desktop_config.json via `npx mcp-remote https://mcp.scrapingbee.com/mcp?api_key=YOUR_API_KEY` and restart Claude Desktop to get the tools automatically, no local server process required. For self-hosting or custom integrations, clone the repo, run `npm install`, set a SCRAPINGBEE_API_KEY environment variable, and start the server with `npm start`; the repo also documents a custom async Python MCP client for advanced agentic workflows. Requires a ScrapingBee API key (paid service, free trial available).

Web scraping and browser automation library.

Official Oxylabs MCP server that bridges AI models to the open web at scale — letting agents scrape any URL, render JavaScript-heavy pages, bypass CAPTCHAs and anti-bot systems, and reach geo-restricted content across 195+ countries through Oxylabs' proxy and Web Scraper API infrastructure. Exposes two tool sets. The Web Scraper API tools cover `universal_scraper` (general website scraping with automatic content formatting for LLM consumption), `google_search_scraper` (structured Google SERP extraction), `amazon_search_scraper` (Amazon result pages), and `amazon_product_scraper` (individual product detail pages). The Oxylabs AI Studio tools add `ai_scraper` for AI-powered extraction that returns clean JSON or Markdown from any URL without writing selectors. Distributed as the PyPI package `oxylabs-mcp` (installable via uvx) and on Smithery for one-command setup. Authentication uses `OXYLABS_USERNAME`/`OXYLABS_PASSWORD` for the Web Scraper API (1-week free trial) plus an optional `OXYLABS_AI_STUDIO_API_KEY` (1,000 free credits) for the AI extraction tools. Built for agents doing large-scale market research, price monitoring, lead generation, SEO/SERP tracking, and competitive intelligence where residential/datacenter proxies and reliable rendering matter more than a single-page fetch.

Enable AI agents to get structured data from unstructured web.

Next-generation platform empowering AI agents with scalable browser automation.

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.

Translate or rewrite text with DeepL's AI models.

Interact with the Intelligent Content Management platform through Box AI.

Ingest anything from Slack to Gmail to podcast feeds, web crawling, into a searchable project.

Production-ready RAG out of the box to search and retrieve data from your own documents.

RAG Search over your content powered by Inkeep.

Connect 100+ tools with zero setup. Auth built-in. Made for agents.

Integrate your AI agent with 500+ APIs: Auth, custom tools, and observability. Open-source.

The Membrane MCP Server is the official Model Context Protocol integration for Membrane, the agentic integration platform formerly known as Integration.app — the company rebranded to getmembrane.com in 2026, and its GitHub org moved from `integration-app` to `membranehq`, which is why the old `integration-app/mcp-server` repo URL no longer resolves. Membrane connects AI agents, products, and internal tools to 100,000+ third-party SaaS applications through a single unified integration layer, so instead of writing bespoke API clients for every app your customers use, an agent calls one MCP server and Membrane routes the request to the right connected integration. The server exposes "actions for connected integrations on Membrane" as MCP tools: in static mode it returns every available action across all connected apps, while dynamic mode lets a client selectively enable only the tools it needs via an `enable-tools` call, and requests can be scoped to specific apps with an `apps` query parameter. Authentication is a Membrane access token, supplied either as a `?token=` query parameter or an `Authorization: Bearer` header — there is no anonymous/no-account mode. It ships as a self-hosted Node.js (v18+) server: clone the repo, `npm install && npm run build`, then run it locally (`npm run dev` serves on `http://localhost:3000`) or containerize it with the provided Docker setup for your own cloud hosting. It speaks MCP over streamable HTTP at `/mcp` (recommended) and a deprecated SSE endpoint at `/sse`. Typical use: an agent needs to "create a contact in whichever CRM this customer has connected" or "sync this record to their connected apps" without the developer hand-building integrations for every possible SaaS target — Membrane's pre-built connector catalog and unified data model handle the app-specific translation.

Inspect traces, manage prompts, curate datasets, and run experiments with open-source AI observability.

Query and analyze your Opik logs, traces, prompts and telemetry data from your LLMs.

Provides access to OpenTelemetry traces and metrics through Logfire.

Create segments, inspect user profiles, search for customers, and access workspace data.

Build, update, and send multi-channel notifications across email, sms, push, Slack, and Teams.

Send product and customer messaging across email, in-app, push, SMS, Slack, Teams.

Enterprise search and chat using Glean's API.

Descript is a popular video and audio editing platform built around transcript-driven editing (delete a word in the text, it cuts the clip), AI overdub voice cloning, screen recording, and Studio Sound noise removal. As of this writing, Descript has not published an official MCP server, and no community project has produced one with meaningful adoption either — repeated GitHub searches across multiple review cycles turn up only forked demo repos and unrelated tools with a description that happens to mention "descript," none exceeding a handful of stars. If you need to script Descript-style transcript/video workflows from an AI agent today, the closest MCP-native options are general-purpose media servers already listed in this directory (search "video" or "audio" categories) combined with Descript's own REST API and Zapier integrations, which are not MCP but can be wrapped in a custom server. This entry is kept as a placeholder so the term stays discoverable; it will be updated the moment Descript or a credible community project ships a real MCP server — check back or watch the Descript developer docs and GitHub for updates.

Connect to the Cartesia voice platform to perform text-to-speech, voice cloning.

Search, fetch, upload, and interact with Gyazo images, including metadata and OCR data.

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.

The official Burp Suite MCP Server, published by PortSwigger, is a Burp extension that exposes Burp Suite's web-security testing engine to AI clients over the Model Context Protocol, letting Claude and other assistants drive live penetration-testing workflows against a target instead of just reasoning about them abstractly. It ships as a Java extension you load into Burp (built from source with `./gradlew embedProxyJar` to produce `burp-mcp-all.jar`, then added via the Extensions tab), and it bundles a packaged stdio MCP proxy alongside an SSE server so any MCP client can connect — Claude Desktop even gets an automatic installer that writes the client config for you. Once loaded, an MCP tab in the Burp UI controls the server: an Enabled checkbox toggles it, the host/port default to http://127.0.0.1:9876, and a separate opt-in checkbox is required before the assistant is allowed to expose config-editing tools, keeping destructive changes behind an explicit gate. Through these tools an AI client can interrogate and manipulate Burp's state — inspecting proxy history and HTTP traffic, sending and modifying requests, and coordinating scanning — which suits agentic security-testing, triage, and report-drafting workflows. Requires Java (with the `jar` command) on your PATH and a running Burp Suite instance. This is PortSwigger's own first-party server, so it tracks Burp's capabilities directly rather than screen-scraping the UI.

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.

Open Source data labeling platform.

Deploy your project to the cloud seamlessly with the Defang platform.

Navigate your Aiven projects and interact with PostgreSQL, Kafka, ClickHouse, OpenSearch.

MCP Server for Apache Doris, an MPP-based real-time data warehouse.

Provides AI assistants with a secure way to explore and analyze data in GreptimeDB.

An MCP server providing an interface for MCP clients to access data within Harper.

Build robust data workflows, integrations, and analytics on a single intuitive platform.

Momento Cache for improved performance, reduced costs, and handling load at any scale.

Immutable ledger database with live synchronization.

Postgres re-engineered for B2B apps. Manage databases, tenants, users, auth using LLMs.

Official MCP server for version-controlled Dolt databases.

Standard interface for managing and querying MariaDB databases, supporting vector/embedding search.

Interact with the data stored in Couchbase clusters.

FalkorDB graph database server with schema and read/write-cypher.

Query your data in Memgraph graph database.

Enable LLMs to inspect database schemas and execute queries on Kuzu graph database.

Analyze your reliability posture, review recent tests and chaos engineering experiments.

Chat with your builds, CI, and more.

Enable AI access to your CloudBees CI cluster, the Enterprise-grade Jenkins-based solution.

MCP server for DeployHQ API integration, enabling AI to manage deployments.

MCP Server for the JFrog Platform API, enabling repository management and build tracking.

Discovery, exploration, reporting and root cause analysis using all observability data.

Bring real-time production context—logs, metrics, and traces—into your local environment.

Query and interact with kubernetes environments monitored by Metoro.

Official MCP Server to get your behavioral analytics data and insights from Clarity.

Access network of thousands of probes to run ping, traceroute, mtr, http and DNS resolve.

The Home Assistant MCP server lets Claude, ChatGPT, and other MCP clients control and query your smart home in plain language — turning devices on or off, adjusting lights, thermostats, and media players, reading live entity states, calling services, and managing automations and scenes. This community server (homeassistant-ai/ha-mcp), the most-adopted and actively maintained Home Assistant MCP server, is built on FastMCP and exposes 87+ tools spanning device control, state queries, service calls, automation management, and configuration inspection. Its recommended deployment is the HA-MCP Custom Component installed through HACS, which runs the full server in-process inside Home Assistant and works across every install type — Home Assistant OS, Supervised, Container, and Core — with full feature parity and no separate access token to manage. It can also run as a Home Assistant app/add-on on HA OS and Supervised installs (exposing a unique MCP URL with no credential setup), or as a standalone server connecting to your instance via a long-lived access token. Potentially destructive file and YAML-editing tools are gated behind opt-in feature flags and off by default, so a default install is read-and-control only. It integrates with Claude Desktop, Claude.ai, ChatGPT, Cursor, and any MCP client on your local network or configured for remote access. Note: this is a community project, explicitly unofficial and not published by Home Assistant / Nabu Casa.

The Philips Hue MCP Server (mcp-light-control by ykhli) is the highest-starred open-source MCP integration for Philips Hue smart lighting, letting Claude, Cursor, and other MCP clients turn lights on/off and query bridge state directly from a conversation. It talks to your Hue Bridge over the official Philips Hue local API, discovered via a bundled `node build/discover-bridge.js` script that walks you through pressing the bridge link button to mint a bridge username/API key — no cloud account required for local control. A second mode supports the Hue Remote (cloud) API via OAuth2 client credentials and access/refresh tokens, letting an agent control your lights from outside your home network; refresh tokens last roughly 100 days and need periodic renewal. The server exposes three tools: `control_lights` (turn all or specific light IDs on/off), `get_lights_info` (list all bridge-registered lights and their current state), and a novelty `send_morse_code_through_light` tool that blinks a message in Morse code at an adjustable speed — the project's original motivating use case was having a coding agent flash a light when a long-running task finished. No published npm package; install by cloning the repo, running `npm install && npm run build`, and pointing your MCP client config at the generated `build/index.js` with `HUE_USERNAME`/`BRIDGE_IP` env vars (or the remote OAuth env vars for cloud mode). Requires Node.js v14+ and an existing Hue Bridge + lights on your network. A useful "physical status indicator" pattern for home-automation and ambient-notification workflows, though the tool surface is intentionally minimal — no scenes, groups, or color/brightness control beyond on/off.

Control Aqara smart home devices, query status, execute scenes.

Tools for AI agents to interact with Baidu Maps APIs for location-based services.

Official Mapbox server that turns any AI agent into a geospatially-aware system by exposing Mapbox's location intelligence platform as MCP tools. Covers global geocoding (addresses/place names to coordinates and back), points-of-interest search across millions of businesses and landmarks, multi-modal routing for driving, walking, and cycling with real-time traffic, travel-time matrices for accessibility and logistics analysis, and route optimization that solves multi-stop traveling-salesman-style visiting order. Also includes map matching to snap noisy GPS traces onto the road network, isochrone generation to visualize areas reachable within a given time or distance, static map image rendering, and offline geospatial calculations (distance, area, bearing, buffers) that don't require an API call. A Mapbox access token is required; the server can be run locally via npm or accessed through Mapbox's own hosted MCP endpoint at mcp.mapbox.com/mcp for zero-install setup. Fits AI travel assistants, delivery-route optimizers, location-based recommenders, and any agent that needs to reason about 'where' — with documented integration guides for Claude Desktop, Cursor, VS Code, and Goose.

Identify the technology stack behind any website.

Interact with the Hunter API to get B2B data using natural language.

Mercado Libre's official MCP server.

Marketing insights and audience analysis covering demographic, cultural, influencer analysis.

Interact with Atlan services for data cataloging.

Search data assets, traverse lineage, write SQL queries using DataHub metadata.

Unlock the power of enterprise Data Catalog with tools provided by Alation MCP server.

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.

Integrates the LINE Messaging API to connect an AI Agent to LINE Official Account.

Send and receive SMS and RCS messages, interact with WhatsApp and Viber.

Official ClickSend MCP Server for SMS and communication.

Interact with Mailgun API.

Official MCP server for Sinch Mailjet contact, campaign, segmentation, statistics APIs.

Elastic Email MCP Server delivers full-scale email capabilities to AI agents.

Trade stocks and options, analyze market data, and build strategies through Alpaca API.

Interface with CoinEx cryptocurrency exchange for market data, orders, balance queries.

MCP Server for CoinStats API - crypto market data, portfolio tracking and news.

Cashfree Payments official MCP server for payment integration.

Interact with Flutterwave payment solutions API to manage transactions and payments.

MCP Server that connects AI agents to Chargebee platform for subscription billing.

Search, request, and manage e-signature contracts effortlessly.

Contract and template management for drafting, reviewing, and sending binding contracts.

Create, Edit, Sign, Extract Documents using Natural Language.

MCP server for creating Datawrapper charts using AI assistants.

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

AI assistants interact with Anytype - a local and collaborative wiki - through natural language.

Official MCP Server to integrate with GROWI APIs.

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 task, doc, and project data in Dart, an AI-native project management tool.

Official MCP server for Cortex.

Experimental MCP server for real-time compliance intelligence into your AI workflows.

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

Access OpenAI models, manage assistants, threads, and files through MCP. Use GPT-4o and o1 models as tools from other AI clients in a unified workflow.

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.

Send SMS, WhatsApp messages, and make voice calls through Twilio's official MCP server. Automate communication workflows from AI coding and automation tools.

The MySQL MCP Server (mcp-mysql-server) connects AI assistants directly to MySQL databases, enabling natural-language SQL workflows without a GUI client or manual query writing. Built by f4ww4z and popular in the developer community with 500+ GitHub stars, the server exposes MySQL as callable MCP tools: execute arbitrary SQL queries, inspect table schemas and column definitions, list all databases and tables in the server instance, describe indexes and constraints, run stored procedures, and manage transactions with commit and rollback control. Common use cases include asking Claude to "show me the 10 most recent orders from the orders table," "describe the schema of the users table including all indexes," "find all customers who haven't placed an order in 90 days," or "insert a test record into staging and roll it back after verification." Authentication uses standard MySQL connection parameters: set MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD, and MYSQL_DATABASE as environment variables in your MCP client config. Supports both local MySQL instances and remote managed databases including Amazon RDS, PlanetScale, and DigitalOcean Managed MySQL. Install via npm: `npx mcp-mysql-server`. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline. An essential tool for backend developers and data analysts who want AI-assisted data exploration and query generation on MySQL-backed applications.

Query and manage AWS DynamoDB tables using natural language. Supports single-table design patterns, GSIs, and batch operations.

Query time-series data stored in TimescaleDB. Analyze IoT metrics, financial data, and application telemetry with SQL and time-series functions.

Time-series database MCP for InfluxDB. Write and query metrics using Flux or InfluxQL. Ideal for monitoring, IoT, and observability data.

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.

Deploy and manage applications on Fly.io. Scale machines, inspect logs, manage secrets, and orchestrate global deployments via AI.

Railway's official MCP server puts your Railway projects — services, databases, environment variables, deployments, networking, volumes, and templates — inside natural-language reach of Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Factory Droid, and OpenCode. As of the current release, the standalone `@railway/mcp-server` npm package is deprecated in favor of shipping MCP support directly inside the Railway CLI: running `railway mcp` starts a local stdio server, while `railway mcp install` auto-detects installed AI tools and writes the correct client config for you (add `--agent <tool>` to target one, or `--remote` to point clients at Railway's hosted server at mcp.railway.com instead of the local binary). The installer merges Railway's entry into existing MCP configs without clobbering other servers you've already set up. Once connected, you can ask your AI agent to spin up a new environment from a GitHub repo, roll environment variables across services, inspect deploy logs when a build fails, provision a Postgres or Redis instance, or manage networking and volume mounts — all without leaving your editor or touching the Railway dashboard. Because the CLI is the source of truth, keeping `railway` up to date is enough to pick up new MCP tools; there's no separate npm package to track anymore. The legacy `@railway/mcp-server` package still works as a compatibility shim — it detects a missing Railway CLI and prints migration instructions rather than failing silently.

Interact with Amazon S3 buckets and objects. Upload, download, list, and manage files, configure bucket policies, and analyze storage costs.

Manage Azure Blob Storage containers and blobs. Upload and download files, configure access tiers, manage lifecycle policies, and inspect metadata.

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

Query Prometheus metrics using PromQL from AI assistants. Analyze time-series data, set up alerting rules, and monitor infrastructure performance.

Run 200+ open-source AI models via Together AI's inference API. Access Llama, Mistral, Qwen, and other top models with high throughput and low latency.

Ultra-fast LLM inference using Groq's LPU hardware. Access Llama 4, Mixtral, and other models at speeds up to 500 tokens/second via MCP.

Run large language models locally with Ollama. Pull models like Llama 3, Phi-3, and Gemma, execute prompts, and manage model library from AI assistants.

Universal LLM proxy and load balancer. Route requests across 100+ LLM providers (OpenAI, Anthropic, Gemini, Mistral) with a unified API and cost tracking.

Data framework for LLM applications. Index documents, build RAG pipelines, query knowledge bases, and create multi-step agents over structured and unstructured data.

Multi-agent AI orchestration framework. Define crews of AI agents with specialized roles, tools, and tasks. Automate complex multi-step workflows.

Access DeepSeek's reasoning and code models via MCP. Use DeepSeek-R1 for complex mathematical and coding problems with extended chain-of-thought reasoning.

Run Python functions in the cloud with Modal. Deploy serverless GPU workloads, schedule jobs, build ML pipelines, and access data lakes without infrastructure setup.

Send messages, manage channels, schedule meetings, and read notifications in Microsoft Teams. Automate team collaboration from AI coding and productivity tools.

The Gmail MCP Server is the official Google Workspace Model Context Protocol integration, giving AI assistants like Claude, Cursor, and Windsurf direct access to your Gmail account. Built and maintained by the Google Workspace team, the server exposes Gmail as callable MCP tools: search the inbox with Gmail query syntax (from:, subject:, has:attachment, after:), read full email threads including message bodies and metadata, send new messages or reply-to threads, create draft emails for review, manage labels (apply, remove, list), and mark messages read or unread. This makes the Gmail MCP server essential for productivity workflows like "summarize today's unread emails from my team," "find every invoice email from Stripe last quarter," "draft a reply to this thread and label it Follow-Up," or "list all emails with attachments from this client." Authentication requires a Google Cloud project with the Gmail API enabled and OAuth 2.0 credentials configured — download credentials.json from the Google Cloud Console and follow the server's auth setup to generate an access token. Works with Claude Desktop, Cursor, VS Code, and Windsurf. With 1,200+ GitHub stars, it is the most popular official Google productivity integration in the MCP ecosystem.

Access and manage secrets stored in 1Password vaults. Retrieve credentials, SSH keys, API tokens, and secure notes directly in AI coding environments.

Comprehensive vulnerability scanner MCP. Scan container images, filesystems, and git repos for CVEs, misconfigurations, and secrets with Aqua's Trivy.

Query Google Analytics 4 data via MCP. Analyze traffic, user behavior, conversions, and audience segments using GA4's reporting API.

Search and download high-quality free stock photos from Unsplash. Find images by keyword, collection, or photographer. Get proper attribution and download links.

Long-term memory layer for AI applications. Store and retrieve user preferences, conversation history, and entity facts with temporal reasoning and semantic search.

Personalized memory layer for AI. Automatically extract and store key information from conversations, enabling truly personalized AI assistant experiences.

Fully managed RAG-as-a-service MCP. Index documents, PDFs, and data sources. Query knowledge bases with semantic search and structured extraction.

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

Transform data in your warehouse with dbt. Run models, test assertions, generate docs, inspect lineage, and manage dbt Cloud jobs via MCP.

Query OpenStreetMap geographic data via Overpass API. Find points of interest, analyze geographic features, and build location-aware applications.

Collect and query distributed traces, metrics, and logs using OpenTelemetry standards. Analyze application performance and correlate signals across services.

Serverless analytical database MCP for MotherDuck (cloud DuckDB). Run OLAP queries on large datasets, query Parquet and CSV files, and share data workspaces.

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.

AI-native browser automation MCP from Browserbase. Extract structured data, automate complex web interactions, and test websites with natural language instructions.

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

Log aggregation MCP for Grafana Loki. Query log streams with LogQL, inspect labels, analyze error patterns, and correlate logs with metrics and traces.

Parse and monitor RSS and Atom feeds from any URL. Aggregate news, blog posts, and podcast feeds. Filter by keyword and track content changes over time.

Extract text, tables, and metadata from PDF documents via MCP. Parse multi-page documents, handle encrypted PDFs, and extract structured data for AI processing.

Excel MCP Server (by haris-musa, nearly 4,000 GitHub stars) lets AI agents create, read, and edit Excel workbooks without Microsoft Excel installed anywhere in the pipeline. It's a Python-based server exposing tools across the full spreadsheet lifecycle: creating and modifying workbooks and worksheets, writing formulas, building and styling Excel Tables, generating charts (line, bar, pie, scatter, and more), constructing dynamic pivot tables for analysis, and applying rich formatting — fonts, colors, borders, alignment, and conditional formatting rules. Built-in data validation keeps ranges, formulas, and cell contents consistent as an agent edits a file. The server supports three transports: stdio for local single-user setups (the default for Claude Desktop and Claude Code), plus SSE and streamable HTTP for remote deployments — when running remotely, set the EXCEL_FILES_PATH environment variable so the server knows where to read and write files, and FASTMCP_PORT to control the listening port. This makes it equally useful for a solo analyst automating a weekly report locally and for a team running a shared Excel-manipulation service that multiple agents call into. Because it operates on the raw XLSX format directly, there's no licensing dependency on Excel itself, and workflows like "pull this CSV into a formatted table with a pivot summary and a bar chart" become a single natural-language request instead of a manual multi-step process.

Google Sheets MCP Server (mcp-google-sheets by xing5, 900+ GitHub stars) is a Python-based bridge between MCP clients like Claude Desktop and the Google Sheets and Drive APIs, offering 19 tools covering the full spreadsheet workflow — creating and listing spreadsheets, reading and writing cell ranges, batch-updating multiple ranges at once, managing individual sheets within a workbook, applying cell formatting, and sharing files via Drive permissions. Authentication supports both Service Accounts (the recommended path for automated or headless agent workflows, configured with SERVICE_ACCOUNT_PATH and DRIVE_FOLDER_ID) and standard OAuth 2.0 for interactive per-user setups. The server runs via uvx with zero manual installation — uvx mcp-google-sheets@latest downloads and launches the latest version on demand, and using the @latest tag is recommended so bug fixes and new tools arrive automatically rather than running a stale cached build. Tool filtering via --include-tools or the ENABLED_TOOLS environment variable lets you expose only the operations a given agent needs, trimming context usage from the full ~13K-token toolset. This is the go-to integration for turning "pull last week's numbers into a new tab and format it as a table" or "update row 42 in the budget sheet" into a single conversational request instead of manual spreadsheet editing, and pairs naturally with Google Drive MCP for agents that need to locate a spreadsheet before editing it.

Create and edit Google Docs documents via MCP. Read document content, insert text, apply formatting, manage comments, and export to various formats.

Universal document converter MCP using Pandoc. Convert between Markdown, HTML, PDF, DOCX, LaTeX, and 40+ other formats with full pandoc options.

Search and retrieve Wikipedia articles via MCP. Fetch article summaries, full content, infoboxes, and categories. Access multilingual Wikipedia content.

Manage Google Calendar events and schedules via MCP. Create, update, and delete events, check availability, manage calendars, and set reminders via AI.

Access NASA's open APIs via MCP. Retrieve Astronomy Picture of the Day, Mars Rover photos, near-Earth object data, exoplanet archive, and earth observation imagery.

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.

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.

Subscribe to real-time database changes in Supabase via MCP. Listen to row-level changes, broadcast messages, and build live collaborative features.

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

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.

Serverless PostgreSQL with branching MCP for Neon. Create database branches for dev/test, auto-scale compute, and manage connection pooling for modern apps.

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.

Direct integration with OpenAI API for accessing GPT-4o, o1, DALL-E, Whisper, and Embeddings. Useful for multi-model workflows, image generation, and text embedding pipelines.

Token-efficient MCP server for the entire Cloudflare API — 2,500+ endpoints in ~1K tokens via dynamic OpenAPI-driven tool generation. Covers DNS, Workers, R2, Zero Trust, Firewall, Images, Stream, Vectorize, Access, and every other Cloudflare product through two unified tools: search() and execute().

Cloudflare Workers development MCP server for on-the-fly application building with D1 databases, R2 object storage, KV stores, and other Workers bindings. Create tables, query data, upload objects, and manage Workers primitives directly from AI tools as you build Cloudflare applications.

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.

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

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.

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

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

DocuSign eSignature API — send envelopes, track signing status, retrieve signed documents, and manage templates from AI assistants.

Cloudinary media asset management — upload images/videos, apply transformations, manage CDN delivery, and search digital assets via the Cloudinary API.

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.

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.