┌─ MCP Server Registry ────────────────────────────────────────────┐ │ │ │ Discover and integrate Model Context Protocol servers │ │ to enhance your AI development workflow │ │ │ └──────────────────────────────────────────────────────────────────┘
┌─────┐ │ CO │ │ SRV │ └─────┘
Context7 MCP Server – serves fresh, version-specific code documentation to Model-Context-Protocol (MCP) clients such as Cursor, Claude Code or Opencode.
┌─────┐ │ PR │ │ OSS │ └─────┘
Next-generation ORM for Node.js & TypeScript supporting PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, MongoDB and CockroachDB.
┌─────┐ │ MI │ │ OSS │ └─────┘
AI’s query-engine & MCP server for building agents that answer questions over large-scale, federated data sources.
┌─────┐ │ CO │ │ SRV │ └─────┘
Composio equips AI agents & LLMs with 100+ ready-made integrations via function calling (official TypeScript & Python SDKs + Rube MCP server).
┌─────┐ │ TA │ │ OSS │ └─────┘
Taskmaster is an AI-powered task-management system for AI-driven development that runs as an MCP server (for editors like Cursor, Windsurf, VS Code, Amazon Q CLI) and also as a CLI. Install via MCP using `npx -y task-master-ai` (or `npm i -g task-master-ai`) and provide at least one model/provider credential (e.g., Anthropic/OpenAI/Google/Perplexity/xAI/OpenRouter/etc.) or use Claude Code/Codex CLI. Supports selective MCP tool loading via `TASK_MASTER_TOOLS` (all/standard/core or custom list) and provides tools for project initialization, PRD parsing, task planning/expansion, task status updates, and research workflows.
┌─────┐ │ FA │ │ OSS │ └─────┘
🚀 The fast, Pythonic way to build MCP (Model Context Protocol) servers and clients. FastMCP is a Python framework that lets you expose Python functions as MCP tools (with automatic schema/validation/docs), connect to MCP servers as a client (URL-based connection with transport negotiation/auth/protocol lifecycle), and build interactive "Apps" (UIs rendered in-conversation). Installation (recommended): `uv pip install fastmcp`. Docs: https://gofastmcp.com. Maintained by Prefect (PrefectHQ).
┌─────┐ │ GI │ │ SRV │ └─────┘
GitHub’s official Model Context Protocol (MCP) server that exposes rich, tool-oriented access to GitHub’s REST & GraphQL APIs. Supports remote (hosted) or local (Docker / native Go binary) deployment and fine-grained toolset configuration.
┌─────┐ │ BL │ │ OSS │ └─────┘
Blender Model Context Protocol (MCP) server that lets Claude AI (and other MCP-aware IDEs such as Cursor, VS Code, and Claude Desktop) drive a live Blender session for prompt-assisted 3D modelling, scene inspection, and code execution inside Blender.
┌─────┐ │ SC │ │ OSS │ └─────┘
AI app-store platform that continuously records a user’s desktop (screen + mic) locally, indexes it, and exposes an API so developers can build context-aware AI desktop apps (“pipes”) in Next.js, publish them and monetise through the built-in store.
┌─────┐ │ PL │ │ OSS │ └─────┘
Playwright MCP server
┌─────┐ │ FA │ │ OSS │ └─────┘
Expose FastAPI endpoints as Model Context Protocol (MCP) tools with built-in authentication/authorization via native FastAPI dependencies (Depends). FastAPI-first (not just OpenAPI conversion), preserves request/response schemas and endpoint docs, and uses ASGI transport for efficient in-process communication. Typical usage: `mcp = FastApiMCP(app)` then `mcp.mount()` to serve an auto-generated MCP server at `/mcp`. Install via `uv add fastapi-mcp` or `pip install fastapi-mcp`. Docs: https://fastapi-mcp.tadata.com/ (examples in `examples/`).
┌─────┐ │ E2 │ │ SRV │ └─────┘
Open-source infrastructure/SDK for running AI-generated code in secure isolated cloud sandboxes (core SDK used by E2B Code Interpreter). Requires an E2B API key to create and control sandboxes.
┌─────┐ │ RE │ │ SRV │ └─────┘
Jina AI’s Reader service/codebase behind https://r.jina.ai and https://s.jina.ai. Provides (1) URL-to-LLM-friendly conversion by prefixing any URL with https://r.jina.ai/ and (2) web search grounding via https://s.jina.ai/<query> which returns top results already fetched and converted. Supports request-header controls (markdown/html/text/screenshot output, image auto-captioning via x-with-generated-alt, cache controls, proxies, cookies forwarding, CSS target selectors, SPA support via Puppeteer, streaming via SSE, and optional JSON output via Accept: application/json). Repo is TypeScript/Node (>=18) with build/start scripts; primary runtime entrypoints appear to be build/stand-alone/crawl.js (serve) and build/stand-alone/search.js (dry-run).
┌─────┐ │ FI │ │ OSS │ └─────┘
MCP server to provide Figma layout information to AI coding agents like Augment Code
┌─────┐ │ MC │ │ SRV │ └─────┘
Developer tool for testing and debugging Model Context Protocol (MCP) servers. Provides a React web UI (Inspector Client) plus a Node.js proxy server (Inspector Proxy) that can connect to MCP servers over stdio, SSE, or streamable HTTP. Also includes a CLI mode for scripting MCP interactions.
┌─────┐ │ AR │ │ SRV │ └─────┘
MCP server implementation for Arize Phoenix (open-source AI observability & evaluation platform). Connects coding agents (e.g., Cursor/Claude Code) to a Phoenix deployment to access Phoenix capabilities (tracing, datasets/experiments, evals, prompt/playground workflows) through a unified MCP interface. Install/run via Node (npx) and configure with Phoenix baseUrl and an API key; Phoenix itself can be installed via pip/conda or deployed via Docker/Kubernetes/cloud.
┌─────┐ │ GE │ │ OSS │ └─────┘
MCP Toolbox for Databases – an open-source MCP server that sits between Gen-AI agents and relational data sources, providing connection pooling, auth, observability, and a YAML-driven tool definition system.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Go implementation/SDK for the Model Context Protocol (MCP) to build MCP servers that expose Resources, Tools (including task-augmented async tools), and Prompts to LLM applications. Supports stdio, SSE, and streamable-HTTP transports; session management (per-client state, per-session tools, tool filtering, notifications); request hooks and tool-handler middleware (including recovery); optional auto-completions for prompt and resource-template arguments. Implements MCP spec 2025-11-25 with backward compatibility for 2025-06-18, 2025-03-26, and 2024-11-05. Install via `go get github.com/mark3labs/mcp-go`.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Python framework/SDK for building AI agents on the Model Context Protocol (MCP). Provides full MCP client support (tools/resources/prompts/notifications + advanced features like OAuth, sampling, elicitation, roots), composable “Building Effective Agents” workflow patterns (map-reduce/parallel, router, intent classifier, orchestrator-workers, deep research, evaluator-optimizer, swarm), and optional durable execution via Temporal. Includes a CLI (run via `uvx mcp-agent`) to scaffold projects, manage secrets, inspect workflows, and deploy apps as MCP servers (stdio/HTTPS via cloud). Installation: `uv add "mcp-agent"` or `pip install mcp-agent`; optional LLM extras like `mcp-agent[openai,anthropic,google,azure,bedrock]`. Example MCP server dependencies commonly used: `mcp-server-fetch` (via `uvx`) and `@modelcontextprotocol/server-filesystem` (via `npx`).
┌─────┐ │ BR │ │ OSS │ └─────┘
An MCP (Model Context Protocol) server that lets MCP-compatible clients (e.g., Cursor, Claude Desktop, Cline, Zed) monitor and interact with a Chrome browser via a companion Chrome extension and a local Node.js middleware server—capturing console/network logs, screenshots, selected DOM elements, and running Lighthouse-based audits (accessibility, performance, SEO, best practices, NextJS).
┌─────┐ │ MC │ │ SRV │ └─────┘
A community driven registry service for Model Context Protocol (MCP) servers—an “app store” API that lists MCP servers and supports publishing with namespace ownership verification.
┌─────┐ │ TA │ │ OSS │ └─────┘
Model Context Protocol (MCP) server + Figma plugin + WebSocket bridge that lets AI agents (Cursor, Claude Code) read Figma designs and modify them programmatically (annotations, layout, styling, components, text, connectors, export, etc.).
┌─────┐ │ BR │ │ SPL │ └─────┘
Browser MCP is an MCP server + Chrome extension that lets AI clients (VS Code, Claude, Cursor, Windsurf) automate your existing Chrome profile locally (fast, private, logged-in, stealthy). This package publishes an MCP server CLI (`mcp-server-browsermcp`) that runs from `dist/index.js` and communicates over WebSocket. Note: the repo README states it currently cannot be built standalone due to missing monorepo `utils`/`types`/shared workspace packages; for usage and setup see https://docs.browsermcp.io and the website https://browsermcp.io. License: Apache-2.0.
┌─────┐ │ FI │ │ SRV │ └─────┘
Official Model Context Protocol (MCP) server for Firecrawl, providing web scraping, crawling, URL discovery (map), web search, batch scraping, structured extraction, an autonomous research agent, and cloud browser sessions for interactive automation. Supports Firecrawl Cloud (via API key) and self-hosted Firecrawl (via custom API URL), with retries, rate limiting/backoff, credit monitoring, and optional SSE/HTTP streamable mode.
┌─────┐ │ KL │ │ SRV │ └─────┘
Klavis AI (YC X25) MCP integration platform for running and managing MCP servers at scale. Offers (1) Strata: intelligent connectors optimized for context window, (2) 100+ prebuilt MCP integrations with OAuth support, and (3) MCP Sandbox: scalable MCP environments for LLM training/RL. Quick start options: cloud-hosted via klavis.ai; self-host MCP servers via Docker images (e.g., ghcr.io/klavis-ai/github-mcp-server:latest); install the open-source Strata CLI locally via `pipx install strata-mcp` and add servers via `strata add --type stdio ...`; or provision server instances via Python/TypeScript SDKs or REST API (api.klavis.ai).
┌─────┐ │ CL │ │ OSS │ └─────┘
Claude Context is an MCP server/plugin that adds semantic (hybrid BM25 + dense vector) code search to Claude Code and other MCP-compatible coding agents, enabling “entire codebase as context” via on-demand retrieval from a vector database instead of loading whole folders. Key capabilities: - Hybrid semantic code search over large repos (millions of LOC) - Incremental indexing (Merkle-tree based), AST-aware chunking with fallback - Supports multiple embedding providers (OpenAI, VoyageAI, Ollama, Gemini) - Uses Milvus/Zilliz Cloud as the vector database System requirements: - Node.js >=20 and <24 (Node 24 is not supported) Quick install (Claude Code): - `claude mcp add claude-context -e OPENAI_API_KEY=... -e MILVUS_TOKEN=... -- npx @zilliz/claude-context-mcp@latest` MCP tools exposed: - `index_codebase`, `search_code`, `clear_index`, `get_indexing_status`
┌─────┐ │ GH │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server and Ghidra plugin that lets LLM clients de-compile and analyse binaries through Ghidra autonomously.
┌─────┐ │ XC │ │ SPL │ └─────┘
A Model Context Protocol (MCP) server and CLI that provides tools for agent use when working on iOS and macOS projects (Xcode project management, simulator management, and app utilities).
┌─────┐ │ AC │ │ OSS │ └─────┘
ACI.dev is an open-source tool-calling platform for connecting AI agents/agentic IDEs to 600+ integrations via unified, intent-aware function calling. It provides multi-tenant OAuth/auth, secrets management, granular natural-language permissions, dynamic tool discovery, and tool-use logging. It can expose tools either through SDK-style direct function calls or via a Unified Model Context Protocol (MCP) server.
┌─────┐ │ KI │ │ OSS │ └─────┘
Kiln is a local-first desktop app and open-source Python library for building, evaluating, and optimizing AI systems. It supports evals, agents, RAG, fine-tuning, synthetic data generation, dataset management, and tool integrations including MCP. Developer entrypoint: the Python package `kiln-ai` (install via `pip install kiln-ai`). The repo also contains an MIT-licensed core library and server (REST API), plus a source-available desktop app.
┌─────┐ │ AW │ │ OSS │ └─────┘
Suite of AWS-focused Model Context Protocol (MCP) servers – lightweight Python services that expose AWS tooling, documentation, pricing, IaC and other capabilities to MCP-compatible AI clients (Augment Code, Claude Code, etc.).
┌─────┐ │ WH │ │ SPL │ └─────┘
Model-Context-Protocol (MCP) server that lets Claude / Augment Code read, search and send WhatsApp messages (text & media) through your personal account.
┌─────┐ │ MC │ │ OSS │ └─────┘
Playwright Model Context Protocol Server – expose Playwright-based browser automation, screenshotting, code-gen and JS execution as MCP tools.
┌─────┐ │ 21 │ │ SRV │ └─────┘
21st.dev “Magic AI Agent” MCP server that generates modern UI components from natural-language prompts inside IDE agents (Cursor, Windsurf, VS Code/Cline, Claude). Works like “v0 in your IDE”: you type `/ui …`, the server generates and writes UI component files into your project following your code style.
┌─────┐ │ WO │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets Claude Desktop run terminal commands, manage processes and edit/search local files via AI-driven tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
mcpo is a simple, secure proxy that exposes any Model Context Protocol (MCP) server/tool as an OpenAPI-compatible HTTP server. It runs an MCP server command (typically stdio-based) or connects to MCP servers over SSE / Streamable HTTP, and publishes REST endpoints plus auto-generated interactive docs (Swagger UI). Key capabilities include: per-tool routing (e.g., /memory, /time), OpenAPI schema generation, API-key protection, serving behind a reverse-proxy subpath via --root-path, multi-server config (Claude Desktop config format) with optional hot reload, and OAuth 2.1 support (dynamic client registration, token storage under ~/.mcpo/tokens/).
┌─────┐ │ GI │ │ OSS │ └─────┘
GitMCP is a free, open-source Model Context Protocol (MCP) server that turns any GitHub repository or GitHub-Pages site into an AI-readable documentation hub, eliminating code-hallucinations in tools such as VSCode, Claude Desktop, etc.
┌─────┐ │ OP │ │ OSS │ └─────┘
A TypeScript-based framework for building AI-native IDE products (web, Electron, cloud). Includes MCP client support (Model Context Protocol) and indicates support for MCP tools via MCP servers. This repository is not an MCP server itself; it is an IDE framework/client that can connect to MCP servers and use their tools.
┌─────┐ │ CO │ │ OSS │ └─────┘
Open-source MCP server + CLI that provides containerized, isolated development environments for coding agents (Claude Code, Cursor, other MCP clients). Powered by Dagger; runs as an MCP stdio server to let multiple agents work in parallel containers/branches with logs, terminal attach, and git-based review.
┌─────┐ │ MC │ │ OSS │ └─────┘
Browser MCP – a Model Context Provider (MCP) server + Chrome extension enabling local, private AI-driven browser automation.
┌─────┐ │ AI │ │ SPL │ └─────┘
AI-Infra-Guard (A.I.G) is a full-stack AI red teaming / security scanning platform by Tencent Zhuque Lab. It provides a web UI and APIs to assess security risks across the AI agent ecosystem and AI infrastructure. Key capabilities (from README): - OpenClaw Security Scan (ClawScan): insecure configuration detection, Skill risk detection, CVE vulnerability checks, privacy leakage detection. - Agent-Scan: multi-agent automated scanning framework for agent workflows (e.g., Dify, Coze). - MCP Server & Agent Skills scan: scans MCP servers and agent skills across 14 categories; supports scanning from source code or remote URLs. - AI infra vulnerability scan: identifies 43+ AI framework components; covers 589+ known CVEs (examples: Ollama, ComfyUI, vLLM, n8n, Triton). - Jailbreak Evaluation: dataset-driven prompt robustness evaluation and cross-model comparison.
┌─────┐ │ ME │ │ SRV │ └─────┘
Open-source integration platform powered by MCP (Model Context Protocol) to connect AI models to many external APIs/tools with a unified interface. Provides hosted and self-hosted options, SDKs (TypeScript/JavaScript + Python), OAuth session management for tool auth, and an ecosystem of MCP server deployments/containers.
┌─────┐ │ ID │ │ SPL │ └─────┘
MCP (Model Context Protocol) server and IDA Pro plugin that exposes IDA functionality (decompile, disassemble, xrefs, rename, debugging, …) through JSON-RPC so LLM-based clients (Claude, VS Code agent mode, etc.) can automate reverse-engineering tasks.
┌─────┐ │ MC │ │ SRV │ └─────┘
Monorepo that hosts Cloudflare-maintained Model Context Protocol (MCP) servers. Each app exposes Cloudflare services (Workers bindings, observability, browser rendering, etc.) to any MCP-compatible client so developers can programmatically inspect or modify their Cloudflare account via natural-language tool calls.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that adds Confluence & Jira Cloud/Server support, exposing rich read/write tools for AI assistants.
┌─────┐ │ SU │ │ OSS │ └─────┘
CLI gateway that bridges MCP stdio-based servers to network transports (SSE, WebSockets, Streamable HTTP) and can also connect to remote SSE/Streamable HTTP MCP servers and expose them locally over stdio. Useful for remote access, debugging, and using stdio-only MCP servers with web/remote clients.
┌─────┐ │ MA │ │ OSS │ └─────┘
An MCP (Model Context Protocol) server that converts many file types and web content into Markdown (PDF, images/OCR, audio transcription, DOCX/XLSX/PPTX, webpages, YouTube transcripts, Bing search results) and can retrieve existing .md/.markdown files. Typical setup: pnpm install → pnpm run build → pnpm start (Bun is used to run dist/index.js). Optional env: UV_PATH for uv location; MD_SHARE_DIR to restrict markdown file retrieval directory.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Python CLI proxy/bridge for Model Context Protocol (MCP) servers that lets you switch transports between (1) stdio SSE/StreamableHTTP (connect Claude Desktop/stdio clients to remote SSE/StreamableHTTP servers) and (2) SSE stdio (expose a local stdio MCP server over an SSE endpoint). Supports optional auth headers, OAuth2 client credentials, SSL verify controls, CORS, named backend servers via CLI or JSON config, and a published container image.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that lets LLMs control cloud browsers through Browserbase & Stagehand (web automation, screenshots, data-extraction, multi-session).
┌─────┐ │ AB │ │ SPL │ └─────┘
MCP (Model Context Protocol) server + Ableton Live Remote Script that lets MCP clients (Claude Desktop / Cursor) control Ableton Live via a JSON-over-TCP socket bridge. Enables session/track inspection, track and clip creation/editing, device (instruments/effects) loading from Ableton’s browser, transport/playback control, tempo changes, and MIDI note insertion.
┌─────┐ │ MC │ │ OSS │ └─────┘
TypeScript-based Model Context Protocol (MCP) server that exposes 25+ chart-generation tools powered by AntV. Usable over stdio, SSE or streamable HTTP transport and easily integrable into Desktop AI clients or any MCP-compatible platform.
┌─────┐ │ UN │ │ OSS │ └─────┘
A lightweight, highly available MCP gateway that can (1) proxy existing MCP servers and (2) transform existing REST APIs into MCP-compliant endpoints via YAML configuration (zero code changes). Includes a built-in management web UI, supports MCP SSE and Streamable HTTP transports, session persistence, multi-tenant operation, config hot-reload/sync, OAuth-based pre-auth, and Docker/Kubernetes/Helm deployment.
┌─────┐ │ DE │ │ OSS │ └─────┘
DevDocs is a free, self-hosted documentation crawling + indexing platform that exposes crawled docs through an MCP server for LLM/agent tooling (Claude Desktop, Cursor, Windsurf, Cline/Roo Code). It includes a UI frontend, a backend API, an MCP service, and a Crawl4AI-based crawler.
┌─────┐ │ EX │ │ SRV │ └─────┘
Model Context Protocol (MCP) server that lets AI assistants (e.g., Claude Desktop) access Exa AI’s web-search API with optional tools for company research, crawling, LinkedIn search and deep research automation.
┌─────┐ │ SN │ │ SRV │ └─────┘
Security scanner CLI for AI agents, MCP servers, and agent skills. Auto-discovers local agent configurations (e.g., Claude, Cursor, Windsurf, Gemini CLI), connects to MCP servers to fetch tool descriptions, and scans for 15+ risks such as prompt injection, tool poisoning/shadowing, toxic flows, malware payloads, untrusted content, credential handling, and hardcoded secrets. Requires a Snyk account/API token (SNYK_TOKEN).
┌─────┐ │ EX │ │ OSS │ └─────┘
Model Context Protocol server that lets AI agents create, read and modify Excel workbooks without a local Excel install.
┌─────┐ │ SU │ │ OSS │ └─────┘
Node-based Model Context Protocol server that exposes Supabase projects (tables, docs, functions, etc.) to AI assistants such as Augment Code, Claude and other AI coding agents.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that interacts with Obsidian via the Local REST API community plugin, exposing tools for listing, reading, searching and modifying notes inside an Obsidian vault.
┌─────┐ │ CO │ │ OSS │ └─────┘
Coding assistant MCP server for Claude (Claude Desktop / claude-mcp web extension) that can edit files, run pre-declared project commands, and Git-version LLM edits (commit-per-chat, auto-accept oriented). NOTE: README states the project is considered obsolete due to Claude Code availability, though it contains useful design ideas.
┌─────┐ │ MC │ │ OSS │ └─────┘
Python-based command-line interface for interacting with Model Context Protocol (MCP) servers; offers chat, interactive shell, and automation modes with built-in LLM provider & tool management.
┌─────┐ │ MO │ │ SPL │ └─────┘
Experimental MCP integration that lets AI assistant clients (Claude Desktop, Cursor, Windsurf) control Unreal Engine via natural language. Uses a UE C++ plugin exposing editor/engine actions over TCP and a Python MCP server (FastMCP) that registers tools for actor management, Blueprint creation/editing, Blueprint graph manipulation, and editor viewport control.
┌─────┐ │ MO │ │ OSS │ └─────┘
Model Context Protocol Server for Mobile Automation and Scraping (iOS, Android, Emulators, Simulators and Real Devices)
┌─────┐ │ MC │ │ OSS │ └─────┘
Swiss Army Knife CLI for interacting with MCP (Model Context Protocol) servers: discover/list tools/resources/prompts, call them, run interactive shell and web UI, plus mock/proxy/guard server modes. Supports stdio and HTTP (streamable HTTP + legacy SSE) transports and multiple output formats.
┌─────┐ │ AR │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets AI assistants search, download and analyse arXiv papers through a simple tool interface.
┌─────┐ │ MC │ │ OSS │ └─────┘
Shrimp Task Manager – an MCP server that turns natural-language requests into structured development tasks with dependency tracking, reflection and web/GUI support for AI agents.
┌─────┐ │ NX │ │ SPL │ └─────┘
Nx Console is the UI for Nx & Lerna (VS Code + JetBrains). It also ships an MCP server (for VS Code/Copilot and Cursor) to enrich AI chats with Nx workspace context (architecture, generators, up-to-date docs). The MCP server can be installed separately via the `nx-mcp` npm package (see `apps/nx-mcp/README.md`).
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that installs other MCP servers (via npm or PyPI) so Claude can use them.
┌─────┐ │ GR │ │ OSS │ └─────┘
Go implementation of a Model-Context-Protocol (MCP) server that exposes Grafana, Prometheus, Loki and related APIs as structured MCP tools.
┌─────┐ │ DA │ │ SPL │ └─────┘
A deliberately vulnerable Python MCP server/lab for educational purposes, containing 10 security challenges (easy/medium/hard) demonstrating common MCP/LLM integration vulnerabilities (e.g., prompt injection, tool poisoning, excessive permissions, rug pulls, tool shadowing, indirect prompt injection, token theft, malicious code execution, remote access control, multi-vector chains). Intended for learning and research; not for production use. Docker run exposes challenge servers on ports 9001–9010; Linux/Docker recommended (Windows noted as unstable).
┌─────┐ │ EL │ │ SPL │ └─────┘
Official ElevenLabs Model Context Protocol (MCP) server for interacting with ElevenLabs Text-to-Speech and audio processing APIs from MCP clients (Claude Desktop, Cursor, Windsurf, OpenAI Agents, etc.). Capabilities called out in the README include: generating speech (TTS), cloning/designing voices, transcribing audio (speech-to-text), voice conversion, audio isolation, and soundscape generation. Runtime configuration uses env vars like ELEVENLABS_API_KEY, optional ELEVENLABS_MCP_BASE_PATH, ELEVENLABS_MCP_OUTPUT_MODE (files|resources|both), and ELEVENLABS_API_RESIDENCY.
┌─────┐ │ OP │ │ SRV │ └─────┘
An MCP server that autonomously evaluates and debugs web applications by driving a browser agent, capturing screenshots, console logs, and filtered network traffic, then returning a UX/debug report to your IDE (e.g., Cursor). Requires an Operative API key. NOTE: README indicates the project has been sunset/discontinued and the team is building something new at https://withrefresh.com.
┌─────┐ │ MC │ │ OSS │ └─────┘
Unofficial Go implementation of the Model Context Protocol (MCP) for building MCP servers and clients with type-safe tool argument structs, automatic schema generation, and multiple transports (stdio, HTTP, Gin, SSE). Docs: https://mcpgolang.com
┌─────┐ │ AG │ │ OSS │ └─────┘
Multi-Agent Collaboration Protocol (MCP) framework for coordinated AI software development. Provides an MCP server that exposes multi-agent orchestration (agent lifecycle, task assignment, shared knowledge graph/RAG, messaging) plus an optional real-time web dashboard for visualization.
┌─────┐ │ SA │ │ OSS │ └─────┘
Sail (by LakeSail) is an open-source, Rust-native distributed compute engine compatible with the Spark Connect protocol (Spark SQL + DataFrame API). It provides a server that PySpark can connect to via `sc://host:port` with no code rewrites, and targets unified batch, streaming, and AI/compute-intensive workloads.
┌─────┐ │ AP │ │ SPL │ └─────┘
MCP (Model Context Protocol) server that provides AI assistants (Claude Desktop/Claude Code, Cursor, VS Code, Windsurf, Zed, Cline, Amazon Q Developer CLI) access to Apple Developer Documentation and bundled WWDC (2014–2025) data. Supports smart search and deep doc retrieval (Apple JSON APIs) across Swift/Objective‑C frameworks (SwiftUI, UIKit, Foundation, etc.), technology catalogs/overviews, framework symbol search, related/similar API discovery, batch reference resolution, platform compatibility analysis, documentation updates tracking, sample code browsing, and WWDC video search/details (transcripts/resources).
┌─────┐ │ AN │ │ OSS │ └─────┘
Query anything (files, databases, +40 app integrations) with SQL, expose results to LLMs over the Model-Context-Protocol (MCP) and act as a MySQL-compatible server.
┌─────┐ │ AP │ │ SRV │ └─────┘
Production-ready RAG (Retrieval-Augmented Generation) platform with Graph RAG + hybrid retrieval (vector/full-text/graph/summary/vision), AI agents, and built-in MCP (Model Context Protocol) server support so assistants can browse collections, run hybrid searches, and ask natural-language questions over your knowledge base. Includes Docker Compose quick-start, optional advanced document parsing via MinerU (doc-ray), and Kubernetes/Helm deployment for production (with KubeBlocks scripts to provision PostgreSQL/Redis/Qdrant/Elasticsearch). Hosted demo + MCP endpoint example: https://rag.apecloud.com/mcp/ using Authorization: Bearer <api-key> (fallback env var APERAG_API_KEY).
┌─────┐ │ CH │ │ SPL │ └─────┘
An MCP (Model Context Protocol) server for querying and summarizing your saved chat messages from a local SQLite database. Requires a companion setup in the ./chatbot directory to collect/store chat logs. Configured via CHAT_DB_PATH env var and typically run via Node/Claude Desktop stdio integration. Provides the tool `query_chat_messages` to query chat messages with parameters and generate summaries based on a prompt.
┌─────┐ │ DB │ │ OSS │ └─────┘
Universal database gateway implementing the Model Context Protocol (MCP) server interface. Lets MCP-compatible clients (Augment Code, Claude, etc.) explore and query MySQL, PostgreSQL, MariaDB, SQL Server and SQLite databases.
┌─────┐ │ BR │ │ SRV │ └─────┘
A powerful Model Context Protocol (MCP) server that provides an all-in-one solution for real-time web access, scraping and browser automation for LLM/agent integrations.
┌─────┐ │ MC │ │ OSS │ └─────┘
A TypeScript bridge that connects local LLMs running via Ollama to Model Context Protocol (MCP) servers, translating LLM tool-call output into MCP JSON-RPC so local/open models can use Claude-like tools (filesystem, web search, GitHub, Gmail/Drive, memory, image generation).
┌─────┐ │ ME │ │ OSS │ └─────┘
MetaMCP – an all-in-one MCP (Model Context Protocol) aggregator/orchestrator/middleware & gateway packaged for Docker. It groups multiple MCP servers into namespaces, exposes unified endpoints (SSE, Streamable HTTP, OpenAPI) and lets you plug in middlewares, auth (API-Key & OIDC) and inspection tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that exposes high-level Kubernetes and Helm management tools through the MCP interface. It auto-detects kubeconfig, supports non-destructive mode, and bundles many kubectl/helm operations for chat-based automation.
┌─────┐ │ MC │ │ OSS │ └─────┘
Middleware/bridge that exposes OpenAI-compatible REST endpoints and connects them to MCP (Model Context Protocol) tools/servers. It injects MCP tool definitions into OpenAI-style requests, executes tool calls against configured MCP servers, and feeds tool results back to the inference engine. Also provides an SSE endpoint so MCP-native clients can use it like an MCP server. Note: README states the project is 'soft deprecated' because Open WebUI supports MCP natively as of v0.6.31, and the project is seeking additional maintainers.
┌─────┐ │ MC │ │ OSS │ └─────┘
TypeScript-first framework (built on the official MCP SDK) for building Model Context Protocol (MCP) servers with automatic directory-based discovery of tools/resources/prompts, a CLI to scaffold and manage servers, built-in Zod schema validation & documentation enforcement, multiple transports (stdio, SSE, HTTP Stream), and optional auth for network transports (OAuth 2.1/PKCE, JWT, API key, or custom). Core capabilities: - Tool input schemas with Zod + required `.describe()` on fields; type inference via `McpInput<this>` - Server transports: stdio (default), SSE, HTTP Stream (batch/stream response modes) - SSE/HTTP Stream auth: OAuth 2.1 (spec-aligned), JWT, API key; supports JWKS + introspection strategies; exposes `/.well-known/oauth-protected-resource` for OAuth discovery. Docs: https://mcp-framework.com/
┌─────┐ │ NU │ │ OSS │ └─────┘
Experimental MCP (Model Context Protocol) server tooling to help AI models understand a local Vite or Nuxt app during development. Monorepo provides (1) `nuxt-mcp-dev` Nuxt module that adds MCP support to the Nuxt dev server, and (2) `vite-plugin-mcp` Vite plugin that adds MCP support to a Vite app. Includes an MCP inspector workflow (`npx @modelcontextprotocol/inspector`). Maintainer/provider: Anthony Fu (antfu). Install via npm/pnpm as packages `nuxt-mcp-dev` and/or `vite-plugin-mcp` (typically as dev dependencies) and enable in your Nuxt/Vite dev setup.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol proxy server that forwards MCP requests from external clients (e.g., VS Code, Claude Desktop, Docker containers) to a running JetBrains IDE (IntelliJ IDEA, PyCharm, WebStorm, Android Studio, etc.).
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) plugin that bridges Unity Editor with a Node.js-based MCP server, letting AI assistants (Claude, Augment Code, Copilot, etc.) programmatically manipulate scenes, assets and tests inside Unity.
┌─────┐ │ IO │ │ SPL │ └─────┘
MCP server for interacting with the iOS simulator (iOS Simulator MCP Server).
┌─────┐ │ PO │ │ OSS │ └─────┘
Postgres MCP Pro – a Python-based Model Context Protocol (MCP) server that adds Postgres health checks, index tuning, explain-plan analysis and safe SQL execution for AI agents.
┌─────┐ │ MC │ │ OSS │ └─────┘
Official Model Context Protocol (MCP) server that uses Qdrant as a semantic-memory backend (vector store). It exposes two MCP tools – qdrant-store and qdrant-find – for persisting and retrieving embeddings.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP Server that lets LLMs interact with Notion workspaces. Includes optional Markdown-conversion to minimise token usage.
┌─────┐ │ FE │ │ OSS │ └─────┘
MCP server that fetches web-page content via a Playwright headless browser, with Readability extraction and HTTP/SSE transports.
┌─────┐ │ SU │ │ OSS │ └─────┘
Node-based MCP server that lets LLMs read/write Notion workspaces via the Notion API; supports optional Markdown conversion to shrink token usage.
┌─────┐ │ SU │ │ OSS │ └─────┘
Query MCP enables end-to-end management of Supabase via chat interface (SQL execution, Management API, Auth Admin SDK, automatic migrations, safety layer, etc.).
┌─────┐ │ RU │ │ OSS │ └─────┘
Runno is a TypeScript/JavaScript monorepo of packages for running multi-language code (via WASI/WebAssembly) in a sandbox across browser and Node, including an MCP server package (@runno/mcp) built on @runno/sandbox. MCP usage (from README): configure your MCP client to run `npx @runno/mcp`. Capabilities (high level): execute sandboxed code using WASI-based runtimes (e.g., python, ruby, quickjs, sqlite, clang, clangpp, php-cgi) with STDIN/STDOUT-style interaction; virtual filesystem support via the sandbox layer; no network/real filesystem by default (virtualized WASI preview1 environment).
┌─────┐ │ OP │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets Claude/Augment Code search & explore any OpenAPI spec via openapisearch.com, summarising APIs in plain language.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that proxies any stdio-based Language Server (LSP) and exposes semantic code-navigation tools (definition, references, hover, rename, diagnostics, edit) to MCP-capable LLM clients.
┌─────┐ │ CL │ │ SPL │ └─────┘
ClojureMCP is an MCP (Model Context Protocol) server for Clojure that connects LLM clients (Claude Code/Claude Desktop/Codex/Gemini CLI) to a Clojure project via nREPL. It provides REPL evaluation plus Clojure-aware read/edit tooling (delimiter repair + structural edits) and optional agent-style tools that can call external LLM APIs. Core capabilities/tools exposed over MCP include: file tree listing (LS), smart file reading (read_file), grep/glob search (grep/glob_files), REPL evaluation (clojure_eval) and REPL discovery (list_nrepl_ports), shell command execution (bash), structure-aware Clojure edits (clojure_edit/clojure_edit_replace_sexp) plus generic edits/writes (file_edit/file_write). Optional/experimental: scratch_pad persistence, code_critique, dispatch_agent, architect. Agent tools may incur API charges if ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY are set.
┌─────┐ │ MY │ │ OSS │ └─────┘
Python implementation of a Model Context Protocol (MCP) server that safely exposes MySQL databases to AI clients.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that lets LLMs inspect MySQL schemas and execute SQL queries (read-only by default, writable when enabled). Built with Node.js.
┌─────┐ │ GO │ │ SPL │ └─────┘
MCP server for interfacing with Godot – lets AI assistants launch/run Godot projects, capture debug output, manipulate scenes, etc.
┌─────┐ │ KU │ │ OSS │ └─────┘
A Model Context Protocol server that lets AI assistants (Claude, Augment Code, etc.) issue natural-language Kubernetes commands through kubectl/Helm.
┌─────┐ │ BR │ │ OSS │ └─────┘
MCP server that lets AI agents control a Chromium-based browser through the browser-use Playwright wrapper. Offers SSE and stdio transports, optional VNC streaming, and Docker support.
┌─────┐ │ WC │ │ OSS │ └─────┘
An MCP server that gives Claude (and other MCP clients) a tightly integrated, fully interactive local shell plus safe file read/write/edit tools—supporting interactive keystrokes, background commands, large-file incremental edits, syntax checking, workspace initialization with smart repo-structure context, and task checkpointing/knowledge-transfer via a single saved context file. Supports modes (wcgw / architect / code_writer) and optional terminal multiplexing/attachment via GNU screen and a VS Code companion extension. Typical setup uses uv/uvx: configure Claude Desktop to run `uvx wcgw@latest` (optionally `--shell /bin/bash`). Windows is supported via WSL only; Docker invocation is also documented.
┌─────┐ │ K8 │ │ OSS │ └─────┘
AI-driven mini Kubernetes dashboard (MCP-enabled). Single-binary server with built-in LLMs, multi-cluster management, Kom-based k8s client, AMIS front-end and 49+ MCP tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) servers and clients for Neo4j – natural-language Cypher, knowledge-graph memory, Aura Cloud management, and graph data-modeling.
┌─────┐ │ QG │ │ SPL │ └─────┘
Model Context Protocol (MCP) server + QGIS plugin that lets LLMs (e.g. Claude) control a local QGIS Desktop session
┌─────┐ │ JU │ │ OSS │ └─────┘
🪐 ✨ Model Context Protocol (MCP) Server for real-time interaction with Jupyter notebooks (edit, execute, document) over the MCP standard.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that lets you manage Docker containers, images, networks and volumes through natural-language prompts. Ships CLI + Docker image, supports local or remote (SSH) Docker daemons, and exposes a rich tool set for compose/inspect/debug workflows.
┌─────┐ │ FE │ │ OSS │ └─────┘
A flexible HTTP fetching Model Context Protocol (MCP) server that retrieves web content and returns it as HTML, JSON, plain-text or Markdown.
┌─────┐ │ MC │ │ OSS │ └─────┘
Convert Any OpenAPI V3 API to MCP Server
┌─────┐ │ WE │ │ SPL │ └─────┘
MCP server that formats Markdown with Wenyan themes and publishes the result to WeChat Official Account drafts.
┌─────┐ │ MC │ │ OSS │ └─────┘
Go server implementing the Model Context Protocol (MCP) to expose secure filesystem operations (read, write, copy, move, delete, search, etc.) as resources/tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
Connect ClickHouse to your AI assistants via an MCP (Model Context Protocol) server that exposes ClickHouse and chDB query tools plus a built-in health-check endpoint.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP Server that equips Claude Desktop with an “explore-data” prompt template plus two tools (load-csv and run-script) for fully-automated, conversational data exploration.
┌─────┐ │ MA │ │ SPL │ └─────┘
MCP server that executes Manim animation scripts and returns rendered videos.
┌─────┐ │ CE │ │ OSS │ └─────┘
Universal MCP-Server that automatically generates LLM-optimised REST & MCP APIs for relational databases (Postgres, MySQL, ClickHouse, Snowflake, etc.).
┌─────┐ │ DE │ │ SRV │ └─────┘
Shopify.dev Model Context Protocol (MCP) server and CLI that exposes tools for Shopify Admin GraphQL, Functions and optional Polaris docs.
┌─────┐ │ LI │ │ SPL │ └─────┘
MCP server that integrates the LINE Messaging API to connect an AI Agent to the LINE Official Account.
┌─────┐ │ SH │ │ SRV │ └─────┘
Model Context Protocol (MCP) server for interacting with Shopify APIs (Admin GraphQL, Functions, optional Polaris).
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP (Model-Context-Protocol) server that exposes Gmail and Google Calendar tooling – query mail, draft/reply messages, manage events, and handle multiple Google accounts via OAuth2.
┌─────┐ │ ME │ │ SPL │ └─────┘
MCP Server that integrates with mem0.ai to store, retrieve and semantically-search coding preferences via an SSE endpoint.
┌─────┐ │ IT │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that lets an AI model read from and write to the active iTerm2 terminal tab, enabling natural-language REPL/CLI interactions.
┌─────┐ │ MC │ │ SPL │ └─────┘
A Model-Context Protocol server that uses yt-dlp to fetch YouTube subtitles and expose them to Claude/other MCP-compatible LLMs.
┌─────┐ │ JA │ │ OSS │ └─────┘
JADX-AI-MCP is a Java plugin for the JADX decompiler plus a companion Python MCP server that lets LLMs (e.g. Claude) inspect and analyse Android APKs in real-time. It exposes rich reverse-engineering tools (fetch_current_class, get_android_manifest, etc.) over Model Context Protocol so an LLM can locate vulnerabilities, review code and decompile resources on-demand.
┌─────┐ │ SL │ │ OSS │ └─────┘
Feature-rich Model Context Protocol (MCP) server that lets LLM agents read/search/post Slack messages in both OAuth and totally permission-less stealth modes. Supports Stdio & SSE transports, DM/Group-DM, smart history pagination, proxy routing, built-in caching and a rich tool set.
┌─────┐ │ WR │ │ SRV │ └─────┘
The Semantic Engine for Model Context Protocol (MCP) clients and AI agents. Provides a semantic layer that lets LLM-powered agents query enterprise data sources with context, governance and security.
┌─────┐ │ CL │ │ OSS │ └─────┘
VS Code extension + MCP server that lets Claude (or any LLM) drive the VS Code debugger through the Model Context Protocol, enabling interactive, language-agnostic debugging sessions.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets developers interact with Neon Postgres projects & databases via natural-language requests.
┌─────┐ │ HO │ │ OSS │ └─────┘
Model Context Protocol server that exposes your Home Assistant instance to LLM-based applications through a secure, real-time HTTP/SSE/WebSocket API.
┌─────┐ │ KU │ │ OSS │ └─────┘
Model Context Protocol (MCP) server for Kubernetes and OpenShift. Native Go binary that offers CRUD, pod-level, namespace, event, Helm and generic resource management operations with no kubectl/helm dependency.
┌─────┐ │ DO │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that lets Claude interact with Docker – create single containers, deploy compose stacks, inspect logs and list containers.
┌─────┐ │ GR │ │ SRV │ └─────┘
Model Context Protocol (MCP) Server that connects MCP-compatible IDE/agent clients with the Graphlit knowledge-graph platform for ingestion, search, RAG and publishing workflows.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that wraps Pandoc to convert documents between Markdown, HTML, PDF, DOCX, LaTeX, reStructuredText, EPUB, ODT, IPYNB and TXT formats.
┌─────┐ │ DU │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that adds DuckDuckGo web-search and content-fetching tools with rate-limiting and LLM-ready formatting.
┌─────┐ │ MC │ │ OSS │ └─────┘
Node-based MCP Server that lets you expose one or more Hugging Face Spaces as Model Context Protocol (MCP) endpoints, with special integration for Claude Desktop (file handling, desktop-mode, tool discovery, etc.).
┌─────┐ │ MC │ │ OSS │ └─────┘
Golang-based Model-Context-Protocol (MCP) server that exposes Kubernetes clusters as a set of chat-accessible resources and tools (list/get/create/modify resources, fetch logs, exec, etc.).
┌─────┐ │ TF │ │ OSS │ └─────┘
Terraform Model Context Protocol (MCP) CLI/server that lets AI assistants analyse, plan and apply Terraform with enterprise-grade security.
┌─────┐ │ DB │ │ OSS │ └─────┘
An MCP (Model Context Protocol) server that exposes dbt Core/Cloud functionality – CLI commands, Semantic Layer, model discovery and SQL execution – to any MCP-capable client.
┌─────┐ │ UN │ │ SPL │ └─────┘
Bridge between Large-Language-Model (LLM) clients (Claude, Augment Code, etc) and the Unity Editor. Ships as a Unity-package that spins up an MCP server inside the editor and exposes a catalogue of AI-driven “tools” so an external client can query or manipulate the open Unity project.
┌─────┐ │ EV │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes unified blockchain tools/resources for 30+ EVM chains, enabling AI agents to read state, transfer assets and interact with smart-contracts (ENS aware).
┌─────┐ │ XC │ │ OSS │ └─────┘
An MCP (Model Context Protocol) server that offers rich Xcode, Simulator, CocoaPods and Swift-PM tooling so AI assistants can inspect, build and test Apple-platform projects.
┌─────┐ │ AC │ │ SRV │ └─────┘
Model Context Protocol (MCP) Server that lets AI assistants run any Apify Actor for web-scraping, data-extraction and automation tasks.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that lets Claude Desktop explore, query and analyse SQL-Alchemy compatible databases (SQLite, PostgreSQL, MySQL/MariaDB, Oracle, MS-SQL, CrateDB, Vertica …).
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes Azure DevOps resources (projects, repos, work-items, pipelines, etc.) to AI assistants through a standardised tool interface.
┌─────┐ │ MC │ │ SPL │ └─────┘
Python implementation of an MCP (Model Context Protocol) server that connects to Microsoft Teams to read, create and reply to channel messages, mentions users and lists members.
┌─────┐ │ IN │ │ OSS │ └─────┘
Node/TypeScript implementation of a local, cross-platform Model Context Protocol (MCP) server that lets LLM agents interact with end-users (prompts, notifications, terminal chat, etc.).
┌─────┐ │ MC │ │ OSS │ └─────┘
Python MCP server that exposes a rich set of tools for manipulating Google Sheets/Drive via Google APIs so any MCP-compatible client (e.g. Claude Desktop) can read, write, share and manage spreadsheets through natural-language commands.
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that fetches YouTube video transcripts/captions through a get_transcript tool.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP web research server (gives Claude real-time web research with Google search, page extraction, screenshots and session tracking)
┌─────┐ │ DA │ │ SPL │ └─────┘
Model-Context-Protocol server that lets AI assistants (Augment Code, Copilot, Claude Desktop) query and control DaVinci Resolve through natural-language requests.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that reads GitHub repository structure and important files.
┌─────┐ │ BA │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that supplies on-chain tools (wallet ops, contract deploy/call, NFTs, on-ramp, etc.) for AI agents such as Claude Desktop and Augment Code to work with the Base network and Coinbase APIs.
┌─────┐ │ CH │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server implementation that provides Chroma-powered vector & text search capabilities to LLM applications.
┌─────┐ │ TE │ │ OSS │ └─────┘
Full-featured Telegram MCP server that exposes nearly the entire Telegram/Telethon API as MCP tools for Claude, Augment Code or any MCP-compatible client.
┌─────┐ │ DB │ │ OSS │ └─────┘
Powerful multi-database Model Context Protocol (MCP) server that exposes structured tools (query, schema, performance, etc.) for MySQL, PostgreSQL and TimescaleDB.
┌─────┐ │ MC │ │ OSS │ └─────┘
Desktop application (Electron + React) that lets you install and manage Model Context Protocol (MCP) servers for the Claude Desktop app on macOS.
┌─────┐ │ LL │ │ OSS │ └─────┘
CLI & MCP server that lets you stream relevant code/text snippets from a project into an LLM session. Provides rule-based file selection (gitignore aware), smart code outlining and clipboard helpers.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets LLMs inspect schemas and run queries/aggregations on MongoDB, with optional read-only mode and smart ObjectId conversion.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol server that lets LLMs discover, introspect and query arbitrary GraphQL APIs.
┌─────┐ │ OP │ │ SPL │ └─────┘
Node-based MCP server packaged as a Desktop Extension (DXT) that enables advanced Airbnb search and listing-detail retrieval.
┌─────┐ │ WE │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that enables free web searching using Google search results, with no API keys required.
┌─────┐ │ MY │ │ OSS │ └─────┘
Python-based Model Context Protocol (MCP) server for secure, role-based interaction with MySQL. Adds SQL execution, health / lock / index analysis tooling and is easily extensible.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that allows LLMs to perform real-browser automation via Playwright (navigation, clicks, screenshots, JS execution etc.)
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP implementation of Claude-Code capabilities (code reading, editing, search, command execution, multi-agent dispatch, notebook editing, etc.) that can be used as a drop-in MCP server.
┌─────┐ │ BI │ │ OSS │ └─────┘
BioMCP: Biomedical Model Context Protocol – an MCP server that exposes biomedical search/fetch tools for literature, clinical trials and genomic variants.
┌─────┐ │ ED │ │ SRV │ └─────┘
MCP server that deploys HTML / folder / zip assets to Tencent EdgeOne Pages and returns a public URL.
┌─────┐ │ MC │ │ OSS │ └─────┘
An MCP server that provides fast, cross-platform file searching (Windows via Everything SDK, macOS via mdfind, Linux via locate/plocate).
┌─────┐ │ IN │ │ OSS │ └─────┘
A Financial Analysis MCP server providing ticker, options, historical data, statements, ownership, sentiment, and technical-analysis endpoints for LLMs.
┌─────┐ │ OP │ │ OSS │ └─────┘
OpenMCP provides (1) a standard for turning arbitrary web-APIs into MCP servers, and (2) an open-source registry of compliant servers so LLM clients can access many services in a token-efficient way.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that lets AI assistants (e.g., Claude) list and execute Apple Shortcuts on macOS through the Model Context Protocol.
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that lets LLMs control iOS simulators through natural-language commands (built on Facebook idb).
┌─────┐ │ HA │ │ OSS │ └─────┘
MCP server that performs RAG-style documentation retrieval via vector search (Qdrant) to enrich LLM responses.
┌─────┐ │ AI │ │ OSS │ └─────┘
Model Context Protocol server that lets LLMs read/write Airtable bases (schema discovery, CRUD operations, etc.)
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that gives A-I assistants real-time data about NixOS packages, options, Home-Manager, nix-darwin and NixHub version history.
┌─────┐ │ FI │ │ OSS │ └─────┘
TypeScript MCP server that scans a project, ranks files by dependency-based importance, stores metadata in JSON, and serves it to AI tools (Augment Code) with optional Mermaid diagram generation.
┌─────┐ │ DR │ │ OSS │ └─────┘
Control Android devices with AI through the Model Context Protocol (MCP). Provides an MCP-compliant server that proxies ADB so AI assistants can manage, debug and automate Android devices via natural-language requests.
┌─────┐ │ MC │ │ SPL │ └─────┘
A Model Context Protocol (MCP) server for interacting with Twitter.
┌─────┐ │ NO │ │ SPL │ └─────┘
A simple Model Context Protocol (MCP) server that lets Claude read and manage a minimalist Notion todo list.
┌─────┐ │ XI │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that turns natural-language questions into SQL through the XiYanSQL model and executes them on MySQL/PostgreSQL databases.
┌─────┐ │ AR │ │ SPL │ └─────┘
The MCP server for AI-agent access to the crypto ecosystem – wallet management, swaps, DCA/limit/stop-loss orders, staking and cross-chain operations (currently Solana in alpha).
┌─────┐ │ ME │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that lets AI agents query and manage Facebook / Instagram (Meta) advertising accounts, campaigns, ad-sets, creatives and insights via Meta’s Marketing API.
┌─────┐ │ VI │ │ SPL │ └─────┘
MCP (Model-Context Protocol) server that integrates the Video Jungle API to upload, analyze, search, and auto-generate video edits.
┌─────┐ │ G- │ │ OSS │ └─────┘
MCP server for Google search using Playwright that supports parallel, multi-keyword searching and returns structured JSON results.
┌─────┐ │ MS │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes Microsoft 365 / Office functionality over the Graph API with authentication, read-only mode, tool filtering and HTTP or stdio transport.
┌─────┐ │ FI │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that lets AI assistants directly use Firebase services (Firestore, Storage, Authentication).
┌─────┐ │ EL │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes Elasticsearch / OpenSearch operations (indices, documents, cluster, aliases) through CLI and HTTP/SSE transports.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol server that exposes a single run_command tool allowing LLMs to execute arbitrary shell commands via STDIO transport.
┌─────┐ │ VS │ │ OSS │ └─────┘
VS Code extension that turns your local VS Code instance into a Model Context Protocol (MCP) server, exposing file, edit, diagnostics, symbol-search and shell tools to LLM clients such as Claude.
┌─────┐ │ MC │ │ SPL │ └─────┘
Local stdio-based MCP server that lets AI agents (e.g., Claude Desktop) call the Apify RAG Web Browser Actor to perform Google search, scrape pages and return cleaned content in Markdown/HTML/Text.
┌─────┐ │ MO │ │ OSS │ └─────┘
MongoDB Lens – full-featured Model Context Protocol (MCP) server that enables natural-language access to MongoDB databases (querying, aggregation, schema analysis, admin ops, etc.).
┌─────┐ │ RE │ │ OSS │ └─────┘
Official Redis Model-Context-Protocol (MCP) server that lets LLM/agent applications store, search and manage data in Redis through natural-language instructions.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP (Model Context Protocol) server that wraps the Maigret OSINT username-search/URL-analysis tool so it can be invoked from MCP-compatible clients such as Claude Desktop.
┌─────┐ │ PR │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that enables AI assistants to query and analyze Prometheus metrics through standardized interfaces.
┌─────┐ │ MI │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that converts Markdown into interactive markmap mind-maps and returns either raw HTML or a file path.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes Milvus vector-database operations to LLM applications via stdio or Server-Sent Events.
┌─────┐ │ AP │ │ SPL │ └─────┘
MCP (Model Context Protocol) server that wraps Apktool to let LLMs like Claude perform real-time reverse-engineering, manifest parsing and vulnerability discovery on Android APKs.
┌─────┐ │ MO │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets LLMs query and manage MongoDB databases through natural-language prompts.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP Server for Deep Research – a Python-based MCP server that turns a research question into a multi-step workflow (question elaboration → sub-question generation → web search → content analysis → report generation) and returns a fully cited research report.
┌─────┐ │ MA │ │ SPL │ └─────┘
Python-based MCP server that lets LLMs read and send iMessage / SMS through the macOS Messages database with smart iMessage/SMS fallback, fuzzy search, contact filtering and a simple CLI.
┌─────┐ │ RU │ │ OSS │ └─────┘
MCP (Model-Context-Protocol) server that turns any Rust crate’s current documentation into an LLM-queryable knowledge base. It downloads the crate docs, embeds them with OpenAI, caches the result, and exposes a `query_rust_docs` tool over stdio.
┌─────┐ │ VO │ │ OSS │ └─────┘
Natural voice conversation MCP server enabling real-time STT/TTS talking to Claude Code and other AI coding assistants.
┌─────┐ │ RO │ │ OSS │ └─────┘
ROS/ROS2 Model-Context-Protocol (MCP) server that converts natural-language commands from an LLM into ROS/ROS2 messages via rosbridge WebSocket.
┌─────┐ │ SE │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that provides web search, news search, crawling, sitemap, reasoning and trending-topic tools powered by Search1API.
┌─────┐ │ KA │ │ SRV │ └─────┘
Official Model Context Protocol (MCP) server that exposes Kagi web-search, summarizer and related tools to MCP-compatible clients (Claude Desktop/Code, etc.).
┌─────┐ │ UN │ │ SPL │ └─────┘
A minimal MCP server that exposes Unsplash image-search as an MCP tool.
┌─────┐ │ AW │ │ OSS │ └─────┘
Light-weight Model Context Protocol (MCP) server that lets AI assistants safely request AWS-CLI documentation and execute AWS commands (with Unix-pipe support) inside an isolated Docker container.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that enables Snowflake database interaction (read/write queries, schema discovery, insights memo).
┌─────┐ │ OP │ │ OSS │ └─────┘
Model Context Protocol (MCP) implementation for Opik enabling seamless IDE integration and unified access to prompts, projects, traces, and metrics.
┌─────┐ │ AL │ │ SRV │ └─────┘
Sample MCP (Model Context Protocol) server implementations for Alibaba Cloud Tablestore, with Java and Python quick-start projects plus a Java RAG (knowledge-base QA) solution.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol server that exposes a single SQL ‘query’ tool backed by a DuckDB database. Supports read-only mode, reusable connections and easy Claude Desktop / Smithery integration.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server offering safe, line-oriented text-file editing with token-efficient partial-file access, designed for integration with LLM tools.
┌─────┐ │ AN │ │ OSS │ └─────┘
TypeScript-based MCP server that forwards chat-completion requests to any OpenAI-compatible provider (OpenAI, Perplexity, Groq, xAI, PyroPrompts, etc.).
┌─────┐ │ GI │ │ OSS │ └─────┘
An MCP server that lets you browse, create, edit and organize GitHub Gists (notes, daily journals, reusable prompts, etc.) from any MCP-compatible client.
┌─────┐ │ PL │ │ OSS │ └─────┘
MCP server that exposes a set of Playwright-based browser-automation tools (navigate, click, fill, screenshot, evaluate, etc.) and a simple note:// storage resource, plus a summarisation prompt.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP (Model Context Protocol) server for Weaviate
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that lets Claude Desktop (or any MCP client) read from and write to a Pinecone vector index. Provides basic RAG-style tools such as semantic-search, read-document, list-documents, pinecone-stats and process-document.
┌─────┐ │ CL │ │ OSS │ └─────┘
A secure Model Context Protocol (MCP) server that allows controlled execution of command-line operations with extensive security controls (whitelisting, path validation, timeouts, etc.).
┌─────┐ │ WE │ │ OSS │ └─────┘
Deep Research for crypto - free & fully local
┌─────┐ │ BA │ │ SPL │ └─────┘
MCP server that provides accurate Chinese Bazi (八字) calculations and related calendar utilities.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that lets LLM clients search and fetch metadata/abstracts for arXiv papers.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that lets Claude (or any MCP-compatible client) query your Zotero cloud library – list collections, fetch item details, run searches, etc.
┌─────┐ │ OP │ │ OSS │ └─────┘
Connect any Open Data to any LLM with Model Context Protocol (MCP); includes CLI to install/use MCP servers and a framework to build & publish new open-data providers.
┌─────┐ │ SE │ │ OSS │ └─────┘
All-in-one security-operations (MCP) platform that wraps popular offensive-security tools behind a unified Python interface and Docker image.
┌─────┐ │ WE │ │ OSS │ └─────┘
SDK-level toolkit and MCP server for operating Kubernetes (CRUD, logs, SQL-like querying, CRD handling, multi-cluster, 58 built-in tools, stdio & SSE modes).
┌─────┐ │ MA │ │ OSS │ └─────┘
Legacy Model Context Protocol server that lets AI assistants invoke "On-Demand" Make scenarios and receive structured JSON results.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) Server that exposes Langfuse prompt management via the MCP Prompts specification and fallback tools.
┌─────┐ │ WE │ │ OSS │ └─────┘
MCP server that leverages wget to download entire websites, preserve structure, and convert links for offline use.
┌─────┐ │ PO │ │ OSS │ └─────┘
TypeScript-based MCP server that exposes the full Postman API (collections, environments, APIs, webhooks, etc.) over the Model Context Protocol.
┌─────┐ │ MC │ │ OSS │ └─────┘
Secure shell command execution server implementing the Model Context Protocol (MCP); executes only whitelisted commands, supports stdin, timeout and returns stdout/stderr/status/time.
┌─────┐ │ VI │ │ OSS │ └─────┘
Metacognitive MCP server that injects Critical Path Interrupts (CPI) to keep autonomous LLM agents aligned, reflective and safe.
┌─────┐ │ OP │ │ OSS │ └─────┘
Dockerized MCP server that converts any Swagger/OpenAPI spec (local file or remote URL) into a ready-to-use Model Context Protocol (MCP) toolset so AI agents can call the underlying API without extra coding.
┌─────┐ │ BI │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that enables Bilibili (B站) video search through a standardized HTTP API; includes LangChain demo, test script and inspector.
┌─────┐ │ AP │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes your local Apple Notes database to Claude Desktop. Offers tools for listing, reading and searching notes.
┌─────┐ │ MC │ │ SPL │ └─────┘
A Model Context Protocol (MCP) server that lets LLMs inspect BigQuery schemas and run SQL queries.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that lets AIs search PubMed, fetch abstracts and, when available, full-text XML using NCBI Entrez.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Kubernetes MCP (Model Control Protocol) server that enables interaction with Kubernetes clusters through MCP tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that lets LLMs query the latest stable versions of packages/images/models across npm, PyPI, Maven, Go Proxy, SwiftPM, Docker Hub, GHCR, AWS Bedrock, and GitHub Actions.
┌─────┐ │ FA │ │ SPL │ └─────┘
MCP (Model Context Protocol) server that exposes Meta/Facebook Ads data & management APIs through a local Python service.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that uses Google Gemini 1.5 Pro to generate multi-format content summaries (text, URL, PDF, EPUB, HTML).
┌─────┐ │ MC │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that provides secure, read-only access to Google BigQuery so LLMs can run natural-language queries against your data.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that exposes a single "calculate" tool for precise numerical expression evaluation by LLMs.
┌─────┐ │ MC │ │ OSS │ └─────┘
Turn a web server into an MCP server in one click without making any code changes. Provides an HTTP⇆MCP protocol-conversion gateway, built on Cloudflare’s Pingora.
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that connects AI assistants to Linear’s GraphQL API, enabling creation, retrieval and management of issues, projects and teams via natural-language prompts.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that provides native integration with Apple Reminders on macOS.
┌─────┐ │ ST │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that bridges LLMs with the Strava V3 API, exposing Strava data as easily callable "tools".
┌─────┐ │ AG │ │ SRV │ └─────┘
Model Context Protocol server that plugs AgentQL’s web-data extraction tool into any MCP-compatible client.
┌─────┐ │ @F │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that exposes MySQL database operations through a standard tool interface.
┌─────┐ │ LO │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that lets LLMs query Pydantic Logfire (OpenTelemetry) traces/metrics via ready-made tools or arbitrary SQL.
┌─────┐ │ MC │ │ SPL │ └─────┘
High-performance CCXT MCP server for cryptocurrency exchange integration (bridges LLMs to 20+ exchanges via Model Context Protocol).
┌─────┐ │ AP │ │ SPL │ └─────┘
Model Context Protocol server that exposes Apple App Store Connect operations (apps, beta testing, analytics, devices, bundle IDs, etc.) through conversational AI endpoints.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server implementation that exposes Asana’s REST API as MCP tools, resources and prompts. Lets Claude Desktop / Code and other MCP clients interact with Asana workspaces, projects, tasks, comments, etc.
┌─────┐ │ SP │ │ OSS │ └─────┘
Light-weight Model Context Protocol (MCP) server that lets AI assistants (Augment Code, Claude, etc.) control Spotify playback and manage playlists.
┌─────┐ │ BR │ │ OSS │ └─────┘
MCP server (Node/TypeScript) plus Firefox extension that lets AI agents manage browser tabs, history and read page content via a secure local channel.
┌─────┐ │ ES │ │ SPL │ └─────┘
Centralize ESP32-/ESP-IDF-related build & flash commands behind an MCP (Model Context Protocol) server so LLM-based agents can drive embedded workflows via a single endpoint.
┌─────┐ │ CH │ │ SRV │ └─────┘
MCP Server for Chronulus AI Forecasting and Prediction Agents
┌─────┐ │ OP │ │ OSS │ └─────┘
An OpenStreetMap MCP server implementation that enhances LLM capabilities with location-based services and geospatial data.
┌─────┐ │ JU │ │ OSS │ └─────┘
A Model Context Protocol (MCP) server that lets Claude AI remotely read, edit and execute Jupyter Notebook (6.x) sessions via a WebSocket bridge.
┌─────┐ │ MC │ │ SPL │ └─────┘
Rust-based Model Context Protocol (MCP) server that exposes Wazuh SIEM data—alerts, vulnerabilities, agent status, etc.—to LLM clients via stdio or optional HTTP.
┌─────┐ │ MC │ │ SRV │ └─────┘
Node/TypeScript implementation of a Model-Context-Protocol (MCP) server that lets AI assistants manage Confluent Cloud resources (Kafka, Connect, Flink, Tableflow, Schema Registry) through natural-language tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that exposes a SearXNG web-search tool to MCP/agentic clients.
┌─────┐ │ AL │ │ OSS │ └─────┘
All-in-one Model Context Protocol (MCP) server written in Go that bundles AI search/RAG, Google Workspace, GitLab, Jira, Confluence, YouTube and other tooling for developer workflows.
┌─────┐ │ IM │ │ OSS │ └─────┘
🪄 ImageSorcery MCP – an MCP server that equips AI assistants with local image-processing tools (crop, resize, detect objects, OCR, drawing, etc.) built on OpenCV, Ultralytics and EasyOCR.
┌─────┐ │ NO │ │ OSS │ └─────┘
Node.js Model Context Protocol (MCP) server that launches disposable Docker containers to run arbitrary JavaScript with on-the-fly npm dependency installation.
┌─────┐ │ TI │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that brings TikTok video access and analysis (subtitles, post details, search) to Claude AI and other MCP-compatible apps via TikNeuron.
┌─────┐ │ CO │ │ OSS │ └─────┘
MCP (Model-Context Protocol) server that exposes CoinCap public-API data (crypto prices, market cap, asset list) for Claude Desktop without needing API keys.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol server that lets an LLM save tabular data and return Vega-Lite visualizations (text or PNG).
┌─────┐ │ MA │ │ OSS │ └─────┘
MCP server for converting Markdown to interactive mind maps with export support (PNG/JPG/SVG)
┌─────┐ │ ME │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that lets AI LLMs execute trades through the MetaTrader 5 terminal.
┌─────┐ │ SQ │ │ OSS │ └─────┘
An MCP server that provides safe, read-only access to SQLite databases through Model Context Protocol (MCP).
┌─────┐ │ WA │ │ OSS │ └─────┘
Wanaku – a Java-based MCP (Model Context Protocol) router that lets AI-enabled applications connect and route context to LLMs.
┌─────┐ │ MC │ │ SPL │ └─────┘
Python-based MCP (Model Context Protocol) server that exposes Perplexity AI’s chat-completion API as an MCP tool (ask_perplexity).
┌─────┐ │ MC │ │ SPL │ └─────┘
A Model Context Protocol (MCP) server that connects Claude Desktop to the MIRO Whiteboard API, enabling board reads, sticky/shape creation and bulk operations.
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes VirusTotal querying tools (URL, file, IP, domain reports & relationship APIs) for easy integration with MCP-compatible clients such as Claude Desktop.
┌─────┐ │ SO │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes SonarQube / SonarCloud data—metrics, issues, hotspots, quality-gate status, etc.—to AI assistants via stdio or HTTP transports.
┌─────┐ │ AZ │ │ OSS │ └─────┘
Java-based MCP server that wraps the Azure CLI, adds prompt-enhancements and exposes it through the Model Context Protocol (stio transport).
┌─────┐ │ BI │ │ SPL │ └─────┘
Binary Ninja plugin that spins up an MCP (Model Context Protocol) HTTP server and an optional bridge so LLM-based MCP clients (e.g. Claude Desktop) can drive Binary Ninja for AI-assisted reverse-engineering.
┌─────┐ │ GO │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that serves Go package documentation to LLMs in a highly-token-efficient format.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that wraps the Apache Airflow REST API so MCP-compatible clients can manage DAGs, runs, tasks, variables, connections, pools, etc. through a unified interface.
┌─────┐ │ PL │ │ SPL │ └─────┘
Unified MCP proxy server that aggregates multiple MCP (STDIO, SSE, Streamable-HTTP) servers into one interface, adds built-in RAG search, notifications and playground.
┌─────┐ │ SE │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes Google News search (powered by SerpAPI) with automatic topic categorization and multi-language/region support.
┌─────┐ │ AS │ │ OSS │ └─────┘
Python MCP server enabling programmatic control of Aseprite through its API.
┌─────┐ │ GT │ │ OSS │ └─────┘
A Model-Context-Protocol (MCP) server that exposes Google Tasks as list/search/create/update/delete/clear tools for Claude or any MCP-compatible client.
┌─────┐ │ IS │ │ OSS │ └─────┘
Isaac Simulation MCP Extension and Server – adds an MCP-compatible natural-language control layer to NVIDIA Isaac Sim.
┌─────┐ │ MC │ │ OSS │ └─────┘
Query OpenAI models directly from Claude using the MCP protocol.
┌─────┐ │ MC │ │ SPL │ └─────┘
MCP server that lets any MCP client query, push and analyse data in a Tinybird workspace.
┌─────┐ │ ZE │ │ SPL │ └─────┘
Model-Context-Protocol server implementing the Zettelkasten knowledge-management method; provides CLI tools and HTTP interface to create, link and query atomic Markdown notes backed by SQLite.
┌─────┐ │ KE │ │ OSS │ └─────┘
Model Context Protocol (MCP) Server that exposes Keboola project data, SQL transformations and job controls as callable tools for AI agents (Claude, Augment Code, LangChain, etc.).
┌─────┐ │ LA │ │ OSS │ └─────┘
Middleware MCP server that lets you run many isolated copies of the same MCP server side-by-side (each with its own namespace, env vars, fs root, etc.).
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes Shodan API & CVEDB capabilities (IP recon, DNS, vulnerability and device search) as structured MCP tools.
┌─────┐ │ LA │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that exposes Lara Translate’s language-detection, translation and translation-memory APIs via HTTP or STDIO so any MCP-compatible LLM client can call them.
┌─────┐ │ JV │ │ OSS │ └─────┘
JVM monitoring MCP server built on Arthas; exposes a Python-based interface for local/remote JVM observability, de-compilation and AI driven performance analysis.
┌─────┐ │ AL │ │ SRV │ └─────┘
Alibaba Cloud Ops MCP Server – a Model Context Protocol (MCP) server that exposes Alibaba Cloud OpenAPI/OOS/CloudMonitor operations so AI-agents can manage cloud resources.
┌─────┐ │ IM │ │ SPL │ └─────┘
An MCP server that exposes read-only, validated access to the macOS iMessage (chat.db) database via FastMCP so LLMs can query chat transcripts safely.
┌─────┐ │ MC │ │ OSS │ └─────┘
CLI/Docker proxy that aggregates and load-balances multiple Model Context Protocol (MCP) servers behind one endpoint, acting like Nginx for Gen-AI back-ends.
┌─────┐ │ FR │ │ SPL │ └─────┘
An MCP server that integrates with the Freqtrade cryptocurrency trading bot.
┌─────┐ │ AL │ │ OSS │ └─────┘
MCP server exposing Alpha Vantage real-time & historical market data (stocks, crypto, options) via a standardized Model Context Protocol interface.
┌─────┐ │ CO │ │ OSS │ └─────┘
MCP (Model Context Protocol) server that exposes Contentful’s Content-Management API as MCP tools (entries, assets, comments, spaces, bulk ops, etc.) with both stdio and HTTP transports.
┌─────┐ │ CR │ │ SPL │ └─────┘
An MCP server that exposes 50+ cryptocurrency technical-analysis indicators and related trading strategies over the Model Context Protocol (MCP).
┌─────┐ │ MC │ │ OSS │ └─────┘
Model-Context-Protocol (MCP) server that exposes CircleCI operations (e.g. get_build_failure_logs, run_pipeline) to AI/IDE clients.
┌─────┐ │ MU │ │ OSS │ └─────┘
MCP server that orchestrates a "council" of local Ollama models, merges their answers and returns a synthesized response (designed to work with Claude Desktop).
┌─────┐ │ PU │ │ OSS │ └─────┘
Node/TypeScript implementation of an MCP server that wraps Pulumi Automation & Cloud APIs. Exposes Pulumi preview/up/stack-output and helper tooling over stdio or SSE for AI agents such as Claude Code/Desktop.
┌─────┐ │ MC │ │ SPL │ └─────┘
A Model Context Protocol Server that connects to a Home Assistant instance via Web-Socket and exposes it through the Model Context Protocol.
┌─────┐ │ OC │ │ SPL │ └─────┘
A Model Context Protocol (MCP) server that exposes Octagon’s AI-powered market-intelligence agents (SEC filings, earnings transcripts, stock & crypto data, private-market transactions, deep research) to Claude Desktop, Augment Code, and any other MCP-compliant client.
┌─────┐ │ RA │ │ OSS │ └─────┘
Ragie Model Context Protocol Server – exposes Ragie knowledge-base retrieval through the Model Context Protocol (MCP) with a single "retrieve" tool.
┌─────┐ │ DI │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that lets LLM agents query, read and move data on DICOM servers (PACS / VNA).
┌─────┐ │ LE │ │ OSS │ └─────┘
A Python MCP server that exposes multi-database querying capabilities through Legion Query Runner and the Model Context Protocol.
┌─────┐ │ MC │ │ OSS │ └─────┘
Implementation of a Model Context Protocol (MCP) server that exposes VictoriaMetrics APIs, documentation search and troubleshooting tools to AI-assistants and other MCP clients.
┌─────┐ │ OP │ │ OSS │ └─────┘
MCP tool-server for OpenAI GPT-4o / gpt-image-1 image generation & editing.
┌─────┐ │ RE │ │ OSS │ └─────┘
MCP server that scans a directory of OpenAPI 3.x specs, builds a searchable catalog (operations & schemas) and exposes it through the Model Context Protocol for LLM-powered IDEs such as Augment Code.
┌─────┐ │ AL │ │ SRV │ └─────┘
Alchemy's official MCP Server enabling AI agents to access Alchemy blockchain APIs via the Model Context Protocol.
┌─────┐ │ BR │ │ OSS │ └─────┘
MCP server that exposes Brave Search (web, images, news, video, POI) through the Model-Context Protocol.
┌─────┐ │ BI │ │ SPL │ └─────┘
Model Context Protocol server that lets AI agents interact with the Bitcoin & Lightning networks (key-gen, address validation, tx/block queries, invoice decode, LNBits payments, etc.).
┌─────┐ │ K8 │ │ OSS │ └─────┘
A Go-based Model Context Protocol (MCP) server that exposes Kubernetes and Helm operations through stdio, SSE or streamable-HTTP transports.
┌─────┐ │ MC │ │ OSS │ └─────┘
An MCP server-side tool that lets MCP agents list and invoke multiple custom Dify workflows through simple API/CLI calls.
┌─────┐ │ MC │ │ OSS │ └─────┘
A Go-based MCP server that exposes real-time CPU, memory, disk, network, host and process metrics to LLMs through a set of MCP tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
Chat with OpenAI models from Claude Desktop – an MCP server that proxies Claude requests to OpenAI’s Chat Completion API.
┌─────┐ │ PI │ │ OSS │ └─────┘
TypeScript implementation of a Model Context Protocol (MCP) server that connects Claude/Augment Code (or any MCP-compatible client) to the PiAPI media-generation API.
┌─────┐ │ RI │ │ SPL │ └─────┘
Rijksmuseum MCP integration for artwork exploration and analysis
┌─────┐ │ BI │ │ OSS │ └─────┘
MCP Server for integrating Microsoft Bing Web / News / Image Search into AI assistants.
┌─────┐ │ HE │ │ OSS │ └─────┘
Python MCP (Model Context Protocol) server that connects to Heurist Mesh APIs, exposing a suite of blockchain & web3-focused agent tools (CoinGecko, DexScreener, Exa, GoPlus, Firecrawl, Twitter intelligence, etc.) via SSE or stdio transport.
┌─────┐ │ MC │ │ OSS │ └─────┘
MCP server that lets any MCP-compatible chat client query the Wolfram Alpha Computational Knowledge API.
┌─────┐ │ ZA │ │ OSS │ └─────┘
AI-assisted data-analytics server & web notebook that lets you chat with multiple SQL databases or flat-file datasets and auto-generates queries, summaries and visualisations.
┌─────┐ │ KO │ │ OSS │ └─────┘
Kokoro Text-to-Speech MCP server that converts text to MP3 locally and/or uploads the result to S3.
┌─────┐ │ LL │ │ SPL │ └─────┘
LLDB MCP server – exposes LLDB debugging through Claude’s Model Context Protocol.
┌─────┐ │ OM │ │ OSS │ └─────┘
Python-based MCP server that uses Microsoft OmniParser to visually parse the active screen and then drives the GUI automatically (mouse / keyboard). Primarily targeted at Windows but can run cross-platform.
┌─────┐ │ SS │ │ OSS │ └─────┘
Local MCP server that lets LLMs/other MCP clients run shell commands over SSH on Linux or Windows targets with configurable time-outs.
┌─────┐ │ TY │ │ OSS │ └─────┘
MCP server that lets LLMs work with Typst: converts LaTeX⇄Typst, validates Typst code and renders it, plus exposes Typst docs through MCP tools.
┌─────┐ │ TH │ │ OSS │ └─────┘
MCP Server that adds a “think” tool (and optional criticize / plan / search) for structured reasoning in agentic AI workflows.
┌─────┐ │ MC │ │ SPL │ └─────┘
Model Context Protocol (MCP) server that exposes Hacker News tooling (get_stories, get_story_info, search_stories, get_user_info) for use from clients such as Claude Desktop via Smithery.
┌─────┐ │ CR │ │ SPL │ └─────┘
Provide latest cryptocurrency news to AI agents via a single MCP tool that proxies the CryptoPanic API.
┌─────┐ │ GI │ │ OSS │ └─────┘
Interact seamlessly with GitLab repositories to manage merge requests and issues. Fetch details, add comments, and streamline your code review process with ease.
┌─────┐ │ MC │ │ OSS │ └─────┘
High-performance Model Context Protocol (MCP) server that exposes Trino’s distributed SQL engine through STDIO and HTTP/StreamableHTTP transports with optional OAuth/JWT authentication.
┌─────┐ │ PO │ │ OSS │ └─────┘
Go-based Model Context Protocol (MCP) server that lets AI agents manage and query Portainer (Docker/Kubernetes) environments via a standardised tool interface.
┌─────┐ │ RE │ │ SRV │ └─────┘
Official Model Context Protocol (MCP) server that lets Claude create Rember flashcards from chat notes or PDFs.
┌─────┐ │ GO │ │ OSS │ └─────┘
Google Calendar MCP server that lets Claude Desktop read, create, update and delete Google Calendar events via an MCP interface. Implements OAuth2 (PKCE) authentication, token encryption and full event-management tooling.
┌─────┐ │ JI │ │ SPL │ └─────┘
Go-based Model Context Protocol (MCP) server that lets AI assistants perform rich Jira operations (issue, sprint, workflow, etc.) through 20+ purpose-built tools.
┌─────┐ │ MC │ │ OSS │ └─────┘
Model Context Protocol (MCP) server that provides comprehensive SQLite database interaction capabilities
┌─────┐ │ VE │ │ OSS │ └─────┘
MCP server that lets AI assistants (e.g., Claude Desktop, Augment Code) semantically search and query the Vercel AI SDK documentation using Google Gemini, FAISS and LangChain.
┌─────┐ │ AW │ │ OSS │ └─────┘
MCP server exposing AWS EC2 real-time pricing data, queryable by CPU, RAM, family, purchase option, etc.