MCP Tools | Model Context Protocol Server Directory

KD-Scout is a lightweight MCP server that brings keyword difficulty scoring, opportunity analysis, and structured content briefs directly into your development workflow. It exposes these SEO insights through a standardized protocol, so you can integrate keyword research data into static site generators, content management tools, or custom dashboards without relying on external APIs or heavy SDKs. The server runs with zero runtime dependencies, making it easy to deploy in CI pipelines or local environments. For developers building content-heavy applications, KD-Scout provides a programmable interface to evaluate search visibility and content gaps early in the development cycle. Unlike traditional SEO tools that require manual data export, KD-Scout lets you query metrics programmatically and embed them into your own tooling. It's particularly useful for teams automating content strategy, generating data-driven briefs, or building SEO-aware applications. Integration is straightforward via the MCP protocol, which is supported by various editors and agents, allowing seamless context passing between your code and SEO insights.

The mcp-kubernetes server bridges the gap between LLMs and your container orchestration layer. Instead of manually switching contexts or running repetitive kubectl commands, you can provide your AI assistant with direct, governed access to your clusters. This tool enables high-level reasoning over infrastructure, allowing developers to perform complex troubleshooting, such as analyzing pod logs across namespaces or diagnosing deployment failures, through natural language. Beyond simple observation, it supports operational tasks like scaling replicas, restarting deployments, or applying manifest updates. Crucially for production environments, it isn't a 'blank check' tool; it includes essential security primitives like namespace allowlists, context restrictions, and safety flags to prevent accidental cluster-wide mutations. It transforms your LLM from a code generator into a sophisticated DevOps co-pilot that understands your live runtime state.

Normi bridges the gap between LLM reasoning and granular French real estate intelligence. While standard models often struggle with hyper-local property data or outdated market trends, this MCP tool provides direct, structured access to over 17 million geocoded transactions from the DVF dataset. For developers building fintech agents or real estate analytics platforms, Normi moves beyond simple text generation by allowing models to query real-time price trends, energy performance (DPE) ratings, and building specifications via a standardized protocol. Unlike traditional REST-only integrations that require manual data orchestration, the MCP implementation allows your AI agent to autonomously fetch comparables and market statistics to perform complex valuation tasks. Whether you are building a mortgage assistant or a property investment scout, Normi transforms an LLM from a generalist into a specialized real estate expert with deep, localized data grounding.

MCP server for Azure (Resource Manager) — inventory, tags, VM power, and lifecycle — with governance controls (subscription/resource-group scoping, protected groups, location allowlist, delete gating, typed confirmation, dry-run, audit).

Coldrig is an MCP-based cold email infrastructure kit aimed at developers and growth teams who need to programmatically manage outreach campaigns. It bundles domain and mailbox provisioning, warmup flows, campaign orchestration, reply handling, and compliance guardrails into a single hosted MCP server accessible via a bearer token. The project exposes around 28 tools over MCP and HTTP, plus an npm CLI, so you can spin up and control inboxes, run warmup sequences, send templated campaigns, and process replies directly from your own code or agent workflows. A free sandbox is available for testing, and the server-enforced guardrails are designed to reduce the risk of getting flagged by providers. Compared to stitching together separate email APIs, SMTP providers, and warmup services, Coldrig offers a more opinionated, integrated path that prioritizes deliverability safety and developer ergonomics. It's best suited for teams already comfortable with MCP or building agentic growth tooling who want to offload the plumbing of cold outreach while keeping control over messaging and targeting logic.

LVL LTD Skill Market is a decentralized marketplace for AI agent skills built on the x402 protocol. Developers can publish, discover, and integrate reusable agent capabilities as sealed skill packs priced in USDC on Base. Each transaction is recorded on a public proof ledger, giving buyers verifiable usage rights and creators transparent monetization. The platform exposes a Model Context Protocol (MCP) and Agent-to-Agent (A2A) interface, so skills can be wired directly into existing agent frameworks without custom glue code. Instead of building every tool from scratch, you grab a skill that fits, pay per use, and compose more capable agents faster. Think of it as a package registry but for live, billable AI functions with cryptographic proof of execution. Integration is straightforward: import the MCP client, query the ledger for available skills, and call them like local functions. It competes with centralized API marketplaces by removing platform take-rates and giving you on-chain ownership of your skill IP. If you're building autonomous agents and tired of rebuilding common utilities, this lets you focus on novel logic while still getting paid when others reuse your work.

mcp-oci is an MCP server that connects your development environment directly to Oracle Cloud Infrastructure (OCI). It enables live discovery of resources, visualizes dependencies between services, and can generate Terraform configurations from existing setups. By default it operates in read-only mode, which makes it safe to explore production environments without risk of unintended changes. Sensitive data like credentials and secrets are automatically redacted during discovery. For developers managing OCI deployments, it streamlines auditing, compliance checks, and migration planning by providing a clear, programmatic view of cloud resources. It integrates smoothly with MCP-compatible clients, including Claude Code and other agent-based tools, allowing you to query your infrastructure using natural language. Compared to manual console navigation or scripting with the OCI CLI, mcp-oci reduces context switching and speeds up workflows like impact analysis, cost estimation, and infrastructure documentation. It's particularly useful for teams adopting Infrastructure as Code (IaC) practices who want to bootstrap Terraform modules from existing OCI environments.

The mcp-debezium MCP server bridges Model Context Protocol clients with Debezium and Kafka Connect, letting you monitor and manage Change Data Capture (CDC) connectors programmatically. It exposes connector lifecycle operations—status checks, configuration reads, restarts, and deletes—through a standardized MCP interface, so you can integrate CDC observability into agents, IDEs, or automation pipelines without writing custom Debezium API glue. The server supports access modes, connector allowlists, delete gating, and credential redaction to keep production environments safe while giving developers self-service control. Whether you're building a troubleshooting assistant, automating connector deployments, or embedding CDC insights into internal tools, mcp-debezium removes the friction of direct REST calls and lets you focus on higher-level logic. It's a community-maintained server, so expect a pragmatic fit for real-world Kafka Connect workflows rather than enterprise bells and whistles.

mcp-clickhouse is a Model Context Protocol server that connects ClickHouse to your MCP-compatible tools and agents. It lets you explore schemas, run SQL queries, and manage tables directly from an MCP client while enforcing safety controls: read/write/destructive classification, database allowlists, row caps, dry-run, and audit logging. Ideal for data analysts, ML engineers, and backend devs who want to query ClickHouse through AI assistants without exposing raw credentials or running risky statements. Integrates easily with any MCP host (Claude Desktop, custom agents) via standard MCP transport. Compared to ad-hoc DB clients, it adds structured governance for LLM-driven workflows—preventing accidental deletes, capping result sizes, and logging every action. Setup is straightforward: configure the server with your ClickHouse connection, define allowlists and limits, and start querying securely through your AI toolchain.

M00N Report brings lightweight test management directly into your MCP-compatible environment. Instead of juggling a separate QA tool, you can author test cases, execute them manually with per-case pass/fail tracking, and cut releases from the same workflow where you already work. It's designed for small to mid-sized teams who want structured testing without the overhead of enterprise suites. The server exposes actions to create cases, record results, tag versions, and link automated test scripts to specific cases, so your manual and automated coverage stays in sync. Integration is straightforward: spin up the server via the MCP host of your choice, point it at a local or Git-backed store, and start calling tools from your agent or editor. Compared to full-stack ALM platforms, M00N Report is opinionated and minimal — it won't replaceJira or TestRail for large orgs, but it covers the core needs of teams that want test visibility without leaving their dev loop.

For developers managing complex identity and access management, the mcp-keycloak server bridges the gap between LLM reasoning and administrative execution. Instead of manually navigating the Keycloak UI or writing boilerplate REST calls, you can now use an MCP-enabled agent to orchestrate multi-realm configurations directly through natural language. The tool provides deep coverage for managing users, clients, roles, and groups, but it is built with enterprise-grade safety in mind. It includes critical guardrails like dry-run modes to preview changes, delete gating to prevent accidental data loss, and comprehensive audit logging for compliance. Whether you are automating user onboarding workflows or auditing client permissions across multiple realms, this integration turns your AI assistant into a controlled, high-precision identity administrator. It moves beyond simple API wrappers by offering structured access modes and allowlists, ensuring that your LLM interactions remain within defined security boundaries.

Swarm Tips is a specialized MCP server designed for developers building agentic workflows that require verifiable task execution and reputation tracking. Unlike standard utility tools, this server integrates on-chain verification with an escrowed content-task marketplace, allowing your AI agents to interact with a decentralized economy. It enables agents to participate in deduction-based games, fulfill marketplace tasks with cryptographic attestations, and query real-time reputation scores for other agents. For engineers, this means you can move beyond simple LLM prompting and start building autonomous agents that possess verifiable identities and economic agency. Integration is straightforward via the remote endpoint at mcp.swarm.tips, providing a non-custodial way to bridge your local development environment with on-chain task verification and agent-to-agent economic interactions.

Agency AI is an MCP implementation designed to bridge the gap between LLMs and programmatic ad management. Instead of manually navigating complex dashboards, developers can leverage this tool to grant Claude or ChatGPT direct, structured access to Meta and Google Ads APIs. This allows for high-level reasoning to be converted into immediate execution—such as adjusting campaign budgets, auditing performance metrics, or scaling winning creative sets based on real-time data. For engineers building marketing automation workflows, this eliminates the need to write custom boilerplate for every API call. It shifts the developer's role from writing CRUD operations to designing sophisticated, agentic workflows that can autonomously manage cross-platform advertising spend with human-in-the-loop oversight.

The mcp-kafka server bridges the gap between LLM-based reasoning and real-time data streaming infrastructure. For developers managing complex event-driven architectures, this tool moves beyond simple read-only queries. It provides a standardized interface for an AI agent to inspect cluster health, analyze consumer group lag, and manage topic lifecycles directly through a chat interface or automated workflow. Unlike standard CLI tools that require manual context switching, this MCP implementation integrates Kafka's operational metadata directly into your development environment. It includes critical production-grade safeguards such as topic allowlists, delete gating, and dry-run modes to prevent accidental data loss. Whether you are debugging pipeline bottlenecks or automating topic provisioning, this server turns your LLM into a context-aware Kafka operator that understands your specific cluster topology and access constraints.

The mcp-azure-devops server bridges the gap between LLM reasoning and your Azure DevOps ecosystem. Instead of manually context-switching between your IDE and the web portal, this tool allows your AI assistant to programmatically interface with boards, repositories, pipelines, and project metadata. It transforms your chat interface into a functional command center where you can query work item statuses, inspect pull requests, or trigger build pipelines using natural language. Unlike basic API wrappers, this implementation prioritizes enterprise-grade safety. It includes sophisticated governance features like project allowlists, protected project designations, and 'dry-run' modes to prevent accidental mutations. For developers working in regulated environments, the addition of typed confirmations and audit logging ensures that AI-driven actions remain transparent and controlled. It is an essential integration for teams looking to automate DevOps workflows without sacrificing security or oversight.

The NotFair Google Ads MCP is a specialized interface designed to bridge the gap between LLMs and live advertising management. Instead of manually exporting CSVs or navigating complex dashboards, developers and growth engineers can integrate this protocol directly into AI-native IDEs like Cursor or chat interfaces like Claude to perform programmatic campaign operations. The toolset is extensive, featuring 117 distinct functions that cover the entire lifecycle of an ad account—from deep auditing and performance analysis to real-time budget adjustments and structural optimizations. Unlike generic API wrappers, this MCP is built for high-context reasoning, allowing your AI agent to interpret performance metrics and suggest or execute changes within a single workflow. It transforms your AI client from a passive advisor into an active operational layer for Google Ads, making it highly effective for automated monitoring or rapid scaling experiments.

HireMe MCP bridges the gap between autonomous AI agents and human professional services by providing a standardized interface for talent acquisition. Unlike traditional job boards designed for human browsing, this MCP server allows LLM-based agents to programmatically query a real engineer's technical profile, review shipped product repositories, and evaluate pricing structures. For developers building agentic workflows, this tool enables a seamless transition from 'planning' to 'execution' by letting agents outsource complex tasks to verified human experts. Instead of a developer manually copy-pasting briefs, an agent can use HireMe to submit project requirements and negotiate terms directly through the protocol. It effectively treats human expertise as a discoverable, callable resource within an agent's toolset, turning the concept of 'AI hiring humans' into a functional technical implementation.

For developers working with LLM orchestration, the fragmentation of MCP server registries is a major friction point. mcp-anything solves this by acting as a unified gateway to over 75,000 public MCP servers. Instead of manually configuring individual connections for every new tool, this meta-gateway allows you to search, discover, and invoke tools on the fly through a single interface. It follows a local-first architecture, ensuring your data stays within your controlled environment rather than relying on centralized cloud proxies. Crucially, it addresses the security concerns inherent in dynamic tool calling by implementing SSRF guards and a strict stdio allowlist. Whether you are building autonomous agents or complex RAG pipelines, this tool provides a scalable way to expand your model's capabilities without the overhead of managing dozens of separate server configurations.

...

Pocket Drives is a community-built MCP server that exposes the Pocket Drives marketplace as a searchable, queryable interface for developers. It lets you search the inventory of independent hosts who list luxury, exotic, and EV rentals on a peer-to-peer basis. You can retrieve vehicle details, get real-time quotes for rental periods, and browse host profiles and availability. Because it's an MCP server, it plugs directly into any MCP-compatible client or agent framework, so you can integrate rental data into your own apps, chatbots, or automation flows without building a scraper or dealing with the Pocket Drives API directly. Compared to other marketplace integrations, Pocket Drives focuses specifically on high-end and electric vehicles, and it offloads the actual booking flow to its iOS app, keeping the MCP surface focused on discovery and quoting. This makes it a lightweight but powerful way to surface unique local inventory in travel, lifestyle, or fleet-management tools. The server is open source and maintained by the community, so contributions and feedback are welcome on GitHub.

The Wildberries MCP Server exposes the full Wildberries Seller API through the Model Context Protocol, giving agents direct access to 202 endpoints across product management, pricing, orders, supplies, advertising, reviews, finance, and analytics. Instead of juggling multiple REST calls or building a custom wrapper, developers can integrate once via MCP and let their agents query or update seller data conversationally. It supports multi-account workflows, so you can manage several Wildberries seller accounts from a single session, which is useful for agencies or large merchants. The server is community-maintained, written for easy deployment alongside existing MCP hosts, and maps cleanly onto Wildberries' official API structure without hiding the underlying semantics. Compared to hitting the REST API directly, you trade a bit of raw control for simpler authentication handling, automatic schema discovery, and reusable tool calls that agents can chain together. It's most valuable when you're building agentic workflows like auto-repricing based on analytics, order-to-supply automation, or review monitoring, where reducing boilerplate and keeping context in conversation matters more than micro-optimizing HTTP requests.

...

One is a community-built MCP server that lets your agent talk to over 700 SaaS apps—think Gmail, Slack, Stripe, Shopify, HubSpot, Notion, and Linear—through a single integration point. Instead of wiring up individual API clients per service, you authenticate once via OAuth and gain access to four composable tools that cover the majority of common workflows: reading and writing records, triggering actions, listing resources, and fetching metadata. It slots into any MCP-compatible runtime (Claude Code, Cursor, custom agents) and handles token refresh, pagination, and error normalization behind the scenes. For developers juggling multi-app automations, it cuts boilerplate significantly compared to managing each API separately. The tradeoff is less granular control than first-party SDKs, but for prototyping, internal tools, or agentic workflows where speed matters more than fine-tuned performance, it's a pragmatic shortcut. Since it's community-maintained, expect occasional gaps in coverage and faster iteration than enterprise connectors.

The mcp-n8n MCP server exposes 55 tools that let you build, edit, and run n8n workflows directly from your assistant. It handles node validation, surgical edits to existing workflows, webhook testing, and rollback of changes. You can create and modify workflows, manage credentials, trigger executions, and inspect run logs without leaving your development environment. It integrates with the n8n REST API, so you configure connection details once and then operate n8n programmatically through MCP-compatible clients. Unlike generic API wrappers, this server provides workflow-aware operations like node-level edits and automatic validation, reducing manual JSON editing. It's useful for automating deployment pipelines, testing integrations, and rapidly prototyping automation flows. The server is community-maintained and requires a running n8n instance with API access enabled.