# MyMCPTools MCP server

Find MCP servers and check whether they actually respond, via live handshake probes.

## Links
- Registry page: https://www.getdrio.com/mcp/io-github-shibley-mymcptools
- Repository: https://github.com/shibley/mymcptools-mcp-server
- Website: https://mymcptools.com

## Install
- Endpoint: https://mymcptools.com/api/mcp
- Auth: Not captured

## Setup notes
- Remote endpoint: https://mymcptools.com/api/mcp

## Tools
- search_mcp_servers (Search MCP servers) - Search the MyMCPTools catalog of Model Context Protocol servers. Filter by free-text query, category slug, integration slug (claude-desktop, cursor, vs-code, ...), install type, or official status. Set only_verified to restrict to servers that answered a live MCP handshake on the most recent probe. Results carry the live verdict for each server. Endpoint: https://mymcptools.com/api/mcp
- get_mcp_server (Get one MCP server) - Full catalog entry for one MCP server by slug: description, author, install command, repo, supported clients, current probe verdict, static repo-freshness signal for local servers, and related servers in the same categories. Endpoint: https://mymcptools.com/api/mcp
- get_server_status (Get live MCP server status) - Current live-probe status for one server: verdict (GOOD / WARN / AUTH_REQUIRED / DOWN / UNPROBEABLE), exposed tool count, handshake latency, negotiated protocol version, remote endpoint, and when it was last seen healthy. Omit the slug to get the catalog-wide verdict summary instead. Endpoint: https://mymcptools.com/api/mcp
- get_server_history (Get MCP server uptime history) - Trailing probe history for one server plus a daily uptime sparkline — the reliability signal behind the badge on mymcptools.com. Returns per-day uptime buckets and the raw probe points (timestamp, verdict, latency). Endpoint: https://mymcptools.com/api/mcp
- list_server_incidents (List MCP server outage incidents) - Reconstructed outage incidents (contiguous runs of failed probes) across the catalog, newest first. Each incident has a start, an end (or ongoing), a duration and the failure reason. Filter to one server with slug, or to open outages with status='ongoing'. Endpoint: https://mymcptools.com/api/mcp
- list_schema_drift (List MCP tool-schema drift) - Tool-schema and protocol-version drift events detected between successive probes — which servers added, removed or changed tools, and when. Use this to spot breaking changes in a server you depend on. Newest first. Endpoint: https://mymcptools.com/api/mcp
- list_categories (List catalog categories) - Every category and client integration in the MyMCPTools catalog, with the number of servers in each. The slugs returned here are the valid values for the category and integration filters on search_mcp_servers. Endpoint: https://mymcptools.com/api/mcp
- get_catalog_stats (Get catalog-wide health stats) - Aggregate health of the whole MCP population: verdict breakdown, share of probeable servers actually serving, transport mix, handshake latency percentiles, tool counts and probe freshness. This is the 'how healthy is MCP right now?' headline number. Endpoint: https://mymcptools.com/api/mcp

## Resources
- mymcptools://catalog/categories - MCP catalog categories All catalog categories and client integrations with server counts. MIME type: application/json
- mymcptools://catalog/stats - MCP catalog health stats Catalog-wide live-probe health aggregates, regenerated each probe run. MIME type: application/json
- mymcptools://server/everything - MCP server entry Reference/test server with prompts, resources, and tools. Perfect for testing MCP implementations. MIME type: application/json
- mymcptools://server/fetch - MCP server entry Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL. MIME type: application/json
- mymcptools://server/filesystem - MCP server entry sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch. MIME type: application/json
- mymcptools://server/git - MCP server entry Tools to read, search, and manipulate Git repositories. Full Git operations support. MIME type: application/json
- mymcptools://server/memory - MCP server entry Knowledge graph-based persistent memory system. Store and retrieve contextual information. MIME type: application/json
- mymcptools://server/apify - MCP server entry 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. MIME type: application/json
- mymcptools://server/github - MCP server entry authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header. MIME type: application/json
- mymcptools://server/gitlab - MCP server entry a first-party MCP endpoint built into the GitLab instance itself — there is no package to install, because the server ships inside GitLab and answers at https://<your-gitlab>/api/v4/mcp (gitlab.com exposes the same path, so https://gitlab.com/api/v4/mcp works for SaaS projects). It landed as an experiment in GitLab 18.3 and moved to beta in 18.6. Authentication is the part that makes it different from every community GitLab server: it uses OAuth 2.0 Dynamic Client Registration, so the first time a client connects it registers itself as an OAuth application on your instance and is issued an access token — no personal access token pasted into a config file. Administrators who do not want one OAuth application per tool can pre-create a shared application instead. Three prerequisites are what actually block most first connections: GitLab Duo must be set to Always on or On by default, beta and experimental features must be enabled, and MCP access must be switched on at the group or instance level. The tool surface covers issues and merge requests (create_issue, get_issue, create_merge_request, get_merge_request, list_merge_requests, get_merge_request_commits, get_merge_request_diffs, get_merge_request_pipelines, create_merge_request_note, get_merge_request_notes), CI/CD (manage_pipeline for list/create/delete/retry/cancel, get_pipeline_jobs, get_job_log), work items (create_workitem_note, get_workitem_notes, link_work_items, get_saved_view_work_items), search (search across the instance, search_labels, semantic_code_search), list_wiki_pages, and attach_scan_profile. HTTP is the recommended transport — claude mcp add --transport http GitLab https://gitlab.com/api/v4/mcp — and clients that only speak stdio can wrap it with npx mcp-remote <url> on Node 20+. Send the X-Gitlab-Mcp-Server-Tool-Name-Prefix header if generic names like search collide with another connected server. If your instance predates 18.3 or Duo is not available to you, the community alternative most teams land on is zereight/gitlab-mcp (1,860+ stars, npm @zereight/mcp-gitlab), which authenticates with a plain personal access token and adds read-only and modify permission modes plus toolset filtering. MIME type: application/json
- mymcptools://server/aws - MCP server entry 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. MIME type: application/json
- mymcptools://server/cloudflare - MCP server entry 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. MIME type: application/json
- mymcptools://server/browserbase - MCP server entry Automate browser interactions in the cloud (web navigation, data extraction, form filling, and more). MIME type: application/json
- mymcptools://server/firecrawl - MCP server entry 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. MIME type: application/json
- mymcptools://server/exa - MCP server entry 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. MIME type: application/json
- mymcptools://server/brave-search - MCP server entry 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. MIME type: application/json
- mymcptools://server/notion - MCP server entry 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. MIME type: application/json
- mymcptools://server/linear - MCP server entry 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. MIME type: application/json
- mymcptools://server/slack - MCP server entry 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. MIME type: application/json
- mymcptools://server/stripe - MCP server entry 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. MIME type: application/json
- mymcptools://server/mongodb - MCP server entry Conversational access to both MongoDB Community Server and MongoDB Atlas cloud databases, as the official Model Context Protocol integration maintained by MongoDB itself. Searchers find it as the MongoDB MCP server or simply the Mongo MCP server; both names refer to this one official server, `mongodb-js/mongodb-mcp-server`, and there is no separate short-form project. 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. MIME type: application/json
- mymcptools://server/supabase - MCP server entry Supabase MCP Server connects Cursor, Claude Code, Claude Desktop, Windsurf and other MCP clients to a Supabase project, and the first thing to know is that the personal access token setup most guides still describe is gone. Supabase now runs a hosted server at https://mcp.supabase.com/mcp using OAuth 2.1 with dynamic client registration — you add the URL, your client opens a browser, you pick the organization, and there is no PAT to mint or rotate. For Claude Code that is `claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"` followed by `/mcp` in a plain terminal (not the IDE extension) to run the auth flow. Three URL query parameters do the real configuration work: `read_only=true` runs every statement as a read-only Postgres role, `project_ref=<id>` scopes the server to one project and drops the account-management tools entirely, and `features=` selects the tool groups. Those groups are database (list_tables, list_extensions, list_migrations, apply_migration, execute_sql), debugging (get_logs across API/Postgres/Edge Functions/Auth/Storage/Realtime, plus get_advisors for security and performance findings), development (get_project_url, get_publishable_keys, generate_typescript_types), Edge Functions (list, get, deploy), account management, docs search, experimental branching on paid plans, and storage — storage is the one group disabled by default. Running Supabase locally with the CLI exposes a reduced server at http://localhost:54321/mcp with no OAuth; self-hosted installs are similar. The npm package `@supabase/mcp-server-supabase` still exists for stdio clients and also exports `createToolSchemas()` so Vercel AI SDK users get typed tool inputs and outputs. Read Supabase's security best-practices page before pointing this at anything with production data — the mutating tools are real. MIME type: application/json
- mymcptools://server/chroma - MCP server entry Embeddings, vector search, document storage, and full-text search with the open-source AI application database. MIME type: application/json
- mymcptools://server/vercel - MCP server entry 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. MIME type: application/json
- mymcptools://server/docker - MCP server entry 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. MIME type: application/json
- mymcptools://server/playwright - MCP server entry 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. MIME type: application/json
- mymcptools://server/huggingface - MCP server entry The official Hugging Face MCP Server connects any MCP client to the Hugging Face Hub and thousands of Gradio AI Spaces. It is a hosted, remote server — there is no local install to run day to day, just a one-click connector at huggingface.co/mcp. Built-in tools cover hub_search, model_search, dataset_search, space_search, and paper_search, plus dynamic Gradio proxy tools that let you call individual Hugging Face Spaces as first-class MCP tools once you enable them from your account settings at huggingface.co/settings/mcp. Requests are authenticated with a Hugging Face access token passed as an Authorization: Bearer header (or via the OAuth login flow at /mcp?login), so tool access respects your account permissions and any gated-model/dataset agreements you have already accepted. One-click install is supported for Claude Desktop and claude.ai (via the Connectors gallery), Claude Code (claude mcp add hf-mcp-server -t http https://huggingface.co/mcp?login), Gemini CLI, VS Code, and Cursor, and the server also ships a companion Gemini CLI extension bundling a context file and custom commands. For self-hosting or local development, the underlying open-source implementation (huggingface/hf-mcp-server) can be run via npx @llmindset/hf-mcp-server in STDIO mode or as a Streamable HTTP / Streamable HTTP JSON-RPC service, and supports a HF_SKILLS_DIR option that exposes a shared skills catalog as skill:// MCP resources. Add ?no_image_content=true to the hosted URL to strip ImageContent blocks from Gradio-backed tool results. MIME type: application/json
- mymcptools://server/e2b - MCP server entry The E2B MCP Server connects Claude Desktop and other MCP clients to E2B's cloud-hosted code sandboxes, giving an AI assistant a safe, isolated place to actually execute code instead of only reasoning about it. Each sandbox is a full Firecracker microVM with a real filesystem, package manager, and network access, so an agent can install dependencies, run scripts in Python, JavaScript, or other languages, read back stdout/stderr/exceptions, and iterate on failures the same way a human developer would in a REPL — a strong fit for data-analysis agents, coding assistants that need to verify generated code actually runs, and any workflow where letting the LLM execute arbitrary shell commands directly on the host would be unsafe. The server ships in two editions in the same repo: a JavaScript/Node package and a Python package, both wrapping the underlying E2B SDK and code-interpreter API. Install via `npx -y @e2b/mcp-server` (Node 18+) or the equivalent Python entry point, then set an E2B_API_KEY environment variable from the E2B dashboard; a Smithery one-click installer (`npx @smithery/cli install e2b --client claude`) is also documented. IMPORTANT: this repository is explicitly marked deprecated/no-longer-actively-maintained by E2B (last meaningful update several months ago) — it still installs and runs, and remains the highest-starred E2B-authored MCP entry point, but teams building new integrations should check E2B's current docs for whether a newer first-party server or their Code Interpreter SDK directly is now the recommended path before committing to long-term production use. MIME type: application/json
- mymcptools://server/figma - MCP server entry 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. MIME type: application/json
- mymcptools://server/jira - MCP server entry 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. MIME type: application/json
- mymcptools://server/kubernetes - MCP server entry 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. MIME type: application/json
- mymcptools://server/composio - MCP server entry Composio exposes its toolkit platform — 1,000+ toolkits with managed authentication, tool search, context management and a sandboxed workbench — over MCP, which makes it a hosted multi-tool endpoint rather than a single-purpose server you run locally. A correction worth stating plainly, because this catalog carried the wrong link: the project is `ComposioHQ/composio` (29,000+ stars, actively pushed), not `ComposioHQ/composio-mcp-plugin`, which is a small three-star side repo for MCP registry plugins. The working model is create-then-generate. You define a server config against one or more toolkits — in Python, `composio.mcp.create(name="my-gmail-server", toolkits=[{"toolkit": "gmail", "auth_config": "ac_xyz123"}], allowed_tools=["GMAIL_FETCH_EMAILS", "GMAIL_SEND_EMAIL"])` — and then mint a per-user URL from it with `composio.mcp.generate(user_id="user-123", mcp_config_id=server.id)`. The URL that comes back has the shape `https://backend.composio.dev/v3/mcp/<SERVER_ID>?user_id=<USER_ID>`, and connections must send an `x-api-key` header carrying your Composio API key — that is required whenever `require_mcp_api_key` is enabled, which is the default for newly created organisations. Two prerequisites trip people up: an auth config for the toolkit has to exist before `create()` will accept it, and the end user has to have authenticated with that toolkit before their generated URL returns anything useful, because handling that OAuth is the point of the platform. Server management is symmetrical and scriptable — `composio.mcp.list()` (filterable by toolkit, with a `limit`), `.get()`, `.update()` to rename or narrow `allowed_tools`, and `.delete()` — and the same configs are editable from the Composio dashboard. SDKs install with `uv add composio` for Python or `@composio/core` for TypeScript, and `@composio/mcp` (v1.0.9 on npm) is a separate small MCP CLI that exposes an `mcp` binary for wiring clients like Claude, Cursor and Windsurf from the command line. Because the endpoint is a plain remote MCP URL with headers, it drops straight into provider-native MCP support — the OpenAI Responses API, for example, takes it as a `{"type": "mcp", "server_url": …, "headers": {"x-api-key": …}}` tool. One caveat from Composio's own documentation: single-toolkit MCP servers are the older path, and for most use cases they now steer you to sessions instead, which give dynamic tool access and let Composio handle context management rather than pinning a fixed tool list per server. MIME type: application/json
- mymcptools://server/ollama - MCP server entry 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. MIME type: application/json
- mymcptools://server/litellm - MCP server entry LiteLLM is not a single MCP server so much as an MCP Gateway: the MCP layer inside the LiteLLM AI Gateway (proxy), which puts one fixed `/mcp` endpoint in front of every MCP server your organisation uses and controls access to them by key, team and organisation. Start with the install trap, because it is the reason most people land here. There is no separate `litellm-mcp-server` package — that name is not published on PyPI, so any guide telling you to `pip install litellm-mcp-server` is wrong and the command will fail. The gateway ships inside LiteLLM itself, so the correct install is `pip install 'litellm[proxy]'` (litellm 1.95.0 on PyPI), from the BerriAI/litellm repository. Backing servers are registered either in `config.yaml` under `mcp_servers:` or from the LiteLLM UI under MCP Servers → Add New MCP Server; persisting them to the database needs `STORE_MODEL_IN_DB=True` (or `general_settings.store_model_in_db: true`, optionally narrowed with `supported_db_objects: ["mcp"]` so only MCP objects are stored). All three transports are supported for the servers behind it — streamable HTTP, SSE and stdio — so a stdio entry with `command`, `args` and `env` (say `npx -y @circleci/mcp-server-circleci`) sits behind the same gateway endpoint as a hosted URL. Auth per backing server is declarative: `auth_type` accepts `none`, `api_key` (sends `X-API-Key`), `bearer_token`, `basic`, `authorization` (verbatim, no prefix), `token` (GitHub style), `oauth2` — which must declare an `oauth2_flow` of `authorization_code` for interactive PKCE sign-in or `client_credentials` for machine-to-machine — `oauth2_token_exchange` for RFC 8693 on-behalf-of, and `aws_sigv4` for MCP servers hosted on Bedrock AgentCore. `static_headers` covers servers that just want fixed headers on every request, `extra_headers` names headers to forward from the client, and `${VAR_NAME}` server variables can be scoped Instance (shared) or Per-user. On the client side you connect to `http://<your-proxy>:4000/mcp/` with an `x-litellm-api-key` header, choose a server group with `x-mcp-servers`, and pass per-server credentials as `x-mcp-{server_alias}-{header_name}` — `x-mcp-github-authorization: Bearer gho_…` alongside `x-mcp-zapier-x-api-key: sk-…` — so a single connection carries different auth for each backing server instead of sharing one token across all of them. Tool names are namespaced by server, and `litellm_settings.mcp_aliases` maps a short alias onto a server name so tools read `github_create_issue` rather than `github_mcp_server_create_issue`. A direct REST path, `/mcp-rest/tools/list` and `/mcp-rest/tools/call`, lets you list and call tools with curl and no LLM in the loop. One version note: from LiteLLM v1.80.18 the gateway speaks MCP protocol 2025-11-25 and rejects new server names that do not comply with SEP-986; existing non-compliant names only warn for now. MIME type: application/json
- mymcptools://server/gmail - MCP server entry 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. MIME type: application/json
- mymcptools://server/1password - MCP server entry Access and manage secrets stored in 1Password vaults. Retrieve credentials, SSH keys, API tokens, and secure notes directly in AI coding environments. MIME type: application/json
- mymcptools://server/google-analytics - MCP server entry Query Google Analytics 4 data via MCP. Analyze traffic, user behavior, conversions, and audience segments using GA4's reporting API. MIME type: application/json
- mymcptools://server/zep - MCP server entry Long-term memory layer for AI applications. Store and retrieve user preferences, conversation history, and entity facts with temporal reasoning and semantic search. MIME type: application/json
- mymcptools://server/mem0 - MCP server entry Personalized memory layer for AI. Automatically extract and store key information from conversations, enabling truly personalized AI assistant experiences. MIME type: application/json
- mymcptools://server/postman - MCP server entry API development platform MCP for Postman. Run collections, manage environments, inspect API definitions, generate code snippets, and test API endpoints. MIME type: application/json
- mymcptools://server/stagehand - MCP server entry cloud browser automation driven by natural-language instructions rather than CSS selectors, running on Browserbase's hosted browsers via the Stagehand framework. The package name has changed and the old one is gone: `@browserbasehq/mcp-stagehand` is not on the npm registry, and the server that replaced it is published as @browserbasehq/mcp-server-browserbase (v2.4.3). Browserbase's own recommendation is to skip the local install entirely and use the hosted server at https://mcp.browserbase.com/mcp over streamable HTTP — they run it and cover the Gemini inference costs that Stagehand's instruction-following needs. Clients without HTTP transport can reach the same endpoint through `npx mcp-remote https://mcp.browserbase.com/mcp`. Six tools are exposed, and they map onto Stagehand's model rather than a raw browser API: start and end open and close a Browserbase session, navigate takes a URL, act performs an action described in plain language, observe returns the actionable elements on the current page so an agent can plan before it clicks, and extract pulls structured data out according to an instruction. The observe-then-act split is the reason this holds up better than selector-based automation on pages that change layout between runs. Worth knowing before you self-host: the browserbase/mcp-server-browserbase repository was archived on 2026-07-20 and its README now states it is retained for historical purposes and should not be treated as representative of Browserbase's current production service. The npm package still installs, but the hosted endpoint is the maintained path. MIME type: application/json
- mymcptools://server/google-search-console - MCP server entry Query Search Console data via MCP. Analyze keyword rankings, click-through rates, crawl errors, and index coverage. Monitor SEO performance across your sites. MIME type: application/json
- mymcptools://server/google-sheets - MCP server entry 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. MIME type: application/json
- mymcptools://server/cal-mcp - MCP server entry Manage Google Calendar events and schedules via MCP. Create, update, and delete events, check availability, manage calendars, and set reminders via AI. MIME type: application/json
- mymcptools://server/openapi-spec - MCP server entry Parse and interact with OpenAPI/Swagger specifications via MCP. Explore API endpoints, generate client code, validate request/response schemas, and test APIs. MIME type: application/json
- mymcptools://server/blender-mcp - MCP server entry The Blender MCP server by ahujasid bridges Claude and the Blender 3D creation suite, letting AI assistants generate, modify, and render 3D scenes through natural language commands — no manual Blender UI required. With 2,800+ GitHub stars, it is one of the most popular creative-category MCP servers available. The integration consists of two components: a Blender Python addon that runs a local socket server inside Blender, and an MCP server layer that translates Claude's tool calls into Blender Python API (bpy) commands. Together they expose tools to create primitive objects (mesh cubes, spheres, cylinders, planes), apply materials with custom colors and PBR shader properties, position and scale objects in 3D space, set up lights and cameras, run arbitrary Python in Blender's scripting context, and trigger renders to PNG files. Compatible with Blender 3.0 and newer. Setup: install the Blender addon ZIP from the GitHub releases page (Edit > Preferences > Add-ons > Install), enable it, and start the socket server from the addon panel. On the MCP side, install blender-mcp with pip or uvx and point your MCP client to it. Works with Claude Desktop and any client supporting stdio MCP servers. Install with: uvx blender-mcp. The Blender MCP server is the go-to tool for product visualization, game asset prototyping, scene generation, and rapid 3D concept iteration using AI. MIME type: application/json
- mymcptools://server/qdrant-mcp - MCP server entry High-performance vector database MCP server for AI applications. Store and query vector embeddings for semantic search, RAG pipelines, and similarity matching. Connect your AI assistant directly to your Qdrant collections. MIME type: application/json
- mymcptools://server/home-assistant-mcp - MCP server entry Home Assistant MCP Server (ha-mcp) gives an AI assistant natural-language control of a Home Assistant instance — querying entity states, calling services, driving lights, climate, locks, media and covers, and managing automations and scenes across roughly 87 tools. Two install-command warnings first, because both are easy to hit: the package is `ha-mcp` on PyPI, not `ha-mcp-server`, and the name `ha-mcp-server` does exist on npm but belongs to an unrelated lights-only project, so `uvx ha-mcp-server` fails while `npx ha-mcp-server` silently installs something much narrower. The correct local command is `uvx ha-mcp@latest`. That said, the maintainers no longer recommend the uvx path as the default. The preferred install is the HA-MCP Custom Component, added through HACS as a custom repository, which runs the full server in-process inside Home Assistant with feature parity across every install type — OS, Supervised, Container and Core — and needs no long-lived access token at all. After restarting and adding the integration, its Configure screen prints a connect URL: a Home Assistant webhook URL (`https://<your-ha-domain>/api/webhook/<webhook-id>`) that works through Nabu Casa or any existing reverse proxy, plus a direct `http://<ha-ip>:9584/...` address for same-network clients. Webhook remote access can be switched off entirely, or set to `ha_auth` so a Home Assistant sign-in is required instead of treating the secret URL as the credential. Home Assistant OS and Supervised users can instead install it as an add-on from the App Store. Docker (`ghcr.io/homeassistant-ai/ha-mcp`) and the uvx package both run as streamable-HTTP servers for Container/Core installs or a separate host. Critically, configure exactly one install method per client — keeping a stdio entry alongside an add-on or component URL is a documented cause of connection hangs, and the maintainers flag stdio as having transport issues that HTTP does not, recommending it only for demo use. OIDC mode gates remote access behind Authentik, Keycloak, Auth0 or Google. This is a community project, not a Home Assistant Foundation one; Home Assistant core also ships its own smaller built-in MCP Server integration. MIME type: application/json
- mymcptools://server/firecrawl-mcp - MCP server entry Firecrawl web scraping and crawling MCP server. Scrape any URL to clean markdown, crawl entire websites, extract structured data with LLM-powered schemas, and monitor web content changes via Firecrawl API. MIME type: application/json
- mymcptools://server/e2b-mcp - MCP server entry E2B secure cloud sandbox MCP server. Execute Python, JavaScript, and R code in isolated sandbox environments, run data analysis scripts, generate matplotlib visualizations, and install packages dynamically via E2B SDK. MIME type: application/json
- mymcptools://server/ha-mcp-community - MCP server entry Unofficial Home Assistant MCP server with 2,000+ stars — control lights, switches, climate, locks, media players, and automations via natural language. Runs as HA add-on or standalone. Full entity state read/write, service calls, and history queries. MIME type: application/json
- mymcptools://server/google-mcp-toolbox - MCP server entry Google's open-source MCP Toolbox for Databases — multi-database MCP server supporting AlloyDB, Cloud SQL, Spanner, BigQuery, PostgreSQL, MySQL, and more. Enterprise-grade connection pooling, auth, and query tools for production AI database access. MIME type: application/json
- mymcptools://server/elevenlabs-mcp - MCP server entry This is the same official elevenlabs/elevenlabs-mcp server viewed through its Conversational AI and agent-building toolset. Beyond one-off text-to-speech calls, the server lets an MCP client define a voice agent's persona, voice, and knowledge sources, then deploy it for interactive back-and-forth conversation rather than single audio clips — useful for building phone-style support bots, in-app voice assistants, or narrated demos entirely from natural-language prompts. It shares the same underlying tool surface as the core ElevenLabs server (text-to-speech, voice cloning, speech-to-text with speaker diarization, sound-effect and soundscape generation, vocal isolation) but is discovered separately by users searching specifically for agent/assistant workflows rather than raw audio generation. Requires Python's `uv` tool: install with `uvx elevenlabs-mcp` and set `ELEVENLABS_API_KEY` (free tier: 10k credits/month) in your MCP client config — there is no npm package, despite some third-party listings suggesting otherwise. Output handling is configurable via `ELEVENLABS_MCP_OUTPUT_MODE` (files, base64 MCP resources, or both), making it usable in both local desktop clients and containerized/serverless agent deployments. 1,450+ GitHub stars, actively maintained by ElevenLabs. MIME type: application/json
- mymcptools://server/cloudflare-api-mcp - MCP server entry 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(). MIME type: application/json
- mymcptools://server/microsoft-playwright-mcp - MCP server entry 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. MIME type: application/json
- mymcptools://server/markitdown-mcp - MCP server entry Microsoft MarkItDown document conversion MCP server. Converts 29+ formats to clean Markdown including PDFs, Word documents, PowerPoint presentations, Excel spreadsheets, HTML, images (with OCR), and audio files (via transcription). Perfect for feeding rich document content to AI workflows. MIME type: application/json
- mymcptools://server/adobe-creative-cloud-mcp - MCP server entry Official Anthropic Claude connector for Adobe Creative Cloud with 50+ tools across Photoshop, Premiere Pro, After Effects, Illustrator, Express, and more. Generate and edit images, cut video sequences, apply effects, manage layers, export assets, and automate repetitive production tasks across Creative Cloud apps — all from Claude. MIME type: application/json

## Prompts
Not captured

## Metadata
- Owner: io.github.shibley
- Version: 0.1.1
- Runtime: Streamable Http
- Transports: HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Jul 30, 2026
- Source: https://registry.modelcontextprotocol.io