MCP Tools | Model Context Protocol Server Directory

The LNbits MCP server bridges LLMs directly with the Lightning Network, enabling AI agents to manage Bitcoin payments and receive funds programmatically. Instead of relying on static API calls, developers can integrate real-time wallet capabilities—such as generating invoices and executing payouts—directly into their AI workflows. This tool transforms an LLM from a simple chat interface into a financial agent capable of handling micro-payments. It is particularly useful for building autonomous payment bots, implementing 'pay-per-query' AI services, or automating Lightning-based reward systems. Integration is straightforward for any MCP-compatible client, removing the need to write custom boilerplate for LNbits API authentication and endpoint mapping.

The supabase-mcp-server bridges the gap between LLMs and your Supabase infrastructure by exposing project and organization management via the Model Context Protocol. Instead of manually toggling through the Supabase dashboard to track project IDs or manage organizational settings, developers can now perform these administrative tasks directly through an MCP-enabled client. It effectively turns your AI assistant into a DevOps helper capable of querying project metadata and handling structural updates. This is particularly useful for developers managing multiple environments or automating the scaffolding of new projects without leaving their IDE. Integration is straightforward, requiring standard MCP configuration and a valid Supabase API key to authenticate requests.

The OpenZeppelin contracts-wizard MCP server bridges the gap between LLM code generation and industry-standard security patterns. Instead of relying on an AI's training data—which may be outdated or prone to hallucinating syntax—this tool allows agents to programmatically interface with OpenZeppelin's vetted templates. Developers can use it to scaffold secure ERC-20, ERC-721, or ERC-1155 contracts by specifying required features like minting, burning, or access control. By shifting the generation logic from probabilistic guessing to a template-driven system, it significantly reduces the risk of critical vulnerabilities in the initial deployment phase and ensures compatibility with the latest contract versions.

The last9-mcp-server bridges the gap between local development and production observability by exposing telemetry data directly to LLMs. Instead of manually switching between an IDE and a monitoring dashboard to debug regressions, developers can query real-time logs, metrics, and distributed traces through the Model Context Protocol. This integration allows AI assistants to analyze live system behavior and correlate production errors with specific lines of code, transforming the debugging workflow from manual hypothesis testing to data-driven resolution. It is particularly useful for resolving 'it works on my machine' bugs where the root cause is tied to environmental state or specific production traffic patterns.

The bitcoin-mcp server bridges the gap between LLMs and the Bitcoin blockchain by providing a standardized interface for on-chain data retrieval and cryptographic operations. Instead of relying on the model's training data—which is inherently outdated for blockchain states—this tool allows AI to perform real-time tasks such as validating wallet addresses, decoding raw transaction hex, and querying current block heights or transaction details. For developers building crypto-integrated agents, it eliminates the need to write repetitive boilerplate for API calls to explorers or local nodes. It effectively transforms an AI from a general knowledge base into a functional Bitcoin interface capable of parsing complex chain data and managing key generation logic locally.

The bear-mcp-server bridges the gap between LLMs and Bear Notes, providing a standardized interface for AI models to interact with your local macOS knowledge base. Instead of manually copying and pasting notes, this MCP implementation allows the model to query, read, and retrieve specific content directly from your Bear library. For developers building personal productivity workflows or RAG-like systems on macOS, this tool transforms Bear from a static markdown editor into a dynamic context source. It integrates seamlessly with any MCP-compliant host, enabling the AI to reference your private documentation or project notes in real-time without requiring complex API middleware.

The planetscale/mcp server bridges the gap between LLMs and your database schema, allowing AI agents to interact directly with PlanetScale databases. Instead of manually pasting table definitions or query results into a prompt, this tool enables the model to inspect schemas, execute read queries, and analyze data in real-time. For developers, this means faster debugging and the ability to generate accurate migrations or complex SQL queries based on the actual state of the database. It integrates seamlessly via the PlanetScale CLI, eliminating the need for custom middleware to expose your data layer to AI assistants. Compared to static context windows, this provides a dynamic, live interface to your production or development environments.

The ai-vision-mcp server bridges the gap between LLMs and visual data by integrating Google Gemini and Vertex AI directly into the Model Context Protocol. Unlike basic image-to-text tools, this server provides structured visual analysis, making it particularly useful for developers handling UI/UX audits or automated visual regression testing. It allows an AI agent to 'see' and interpret interfaces across different operating systems, enabling tasks like identifying layout shifts, verifying element placement, or analyzing video frames for behavioral bugs. By exposing these multimodal capabilities as MCP tools, it removes the need to manually upload screenshots to a chat interface, allowing the AI to trigger visual inspections programmatically during the development workflow.

The playwright-mcp server bridges the gap between LLMs and live web environments by exposing Playwright's browser automation capabilities via the Model Context Protocol. Unlike raw HTML scraping, this tool provides structured accessibility snapshots, allowing models to perceive page layouts and interactive elements as a human would, which significantly reduces token noise and improves element targeting. Developers can integrate this to build autonomous agents capable of navigating complex SPAs, performing end-to-end UI testing, or extracting real-time data from authenticated sessions. It effectively transforms a static LLM into an active web operator by providing a standardized interface for clicking, typing, and page navigation without requiring custom glue code for every session.

The finmap-org MCP server bridges the gap between LLMs and real-time financial market data, specifically targeting US, UK, Russian, and Turkish exchanges. Unlike general web-search tools, this server provides structured access to ticker-level metadata, sector classifications, and liquidity metrics such as trade volume and market capitalization. For developers building financial dashboards or analysis agents, it eliminates the need to write custom API wrappers for multiple regional exchanges. It supports both raw data retrieval and the generation of visual representations like treemaps and histograms, making it an efficient choice for integrating quantitative market snapshots directly into an AI-driven workflow.

The azure-cli-mcp server bridges the gap between LLMs and your Azure environment by exposing the Azure CLI as a set of executable tools. Instead of manually copying resource IDs or querying the portal, developers can delegate infrastructure management—such as checking VM status, managing App Services, or listing resource groups—directly to the model. It functions as a thin, efficient wrapper, meaning it inherits the full capability and authentication flow of your local az CLI installation. For those already using the CLI, this integration removes the context-switching overhead, allowing for natural language infrastructure auditing and rapid resource manipulation without leaving the IDE.

The jira-github-mcp server bridges the gap between project management and version control by exposing Jira and GitHub APIs directly to your LLM. Instead of manually switching tabs to sync tickets with code, developers can now automate the traceability chain within their IDE. The tool enables the AI to fetch Jira issue details, create corresponding GitHub branches, and track PR status based on ticket IDs. It is particularly useful for automating repetitive administrative tasks like updating ticket statuses upon commit or generating PR descriptions from issue requirements. By unifying these two ecosystems via the Model Context Protocol, it reduces context-switching overhead and ensures that the development lifecycle remains synchronized without manual data entry.

The Yuque-MCP-Server bridges the gap between LLMs and Yuque's structured knowledge bases. Instead of manually copying documentation into a prompt, this server allows AI models to programmatically query, read, and manage documents via the Yuque API. For developers, this means your AI agent can now perform real-time knowledge retrieval, update internal wikis, or analyze document trends directly within the chat interface. It effectively transforms Yuque from a passive storage site into an active context source for your AI workflow, eliminating the friction of context switching and manual data entry during technical documentation tasks.

The cal-mcp server extends LLM capabilities by offloading mathematical computations to a dedicated execution environment, eliminating the common 'hallucination' issues associated with complex arithmetic in large language models. Instead of relying on probabilistic token prediction for math, this tool allows the model to perform precise calculations via a standardized interface. It is particularly useful for developers building agents that require high numerical accuracy for financial data, scientific formulas, or dynamic coordinate calculations. Integration is straightforward via the Model Context Protocol, allowing any MCP-compatible client to treat the calculator as a native tool without requiring custom wrapper code for every new mathematical operation.

The mcp-stockfish server bridges the gap between LLMs and the Stockfish engine, allowing AI models to perform precise chess analysis and move validation. Instead of relying on the model's probabilistic understanding of board states—which often leads to illegal moves in complex positions—this tool provides a deterministic source of truth. Developers can integrate it to build chess coaching apps, automated game analysis tools, or sophisticated bots that combine LLM natural language reasoning with grandmaster-level engine calculations. It abstracts the engine's UCI protocol into a standardized MCP interface, making it trivial to plug Stockfish's evaluation capabilities into any MCP-compliant client across Windows, macOS, or Linux.

The apiarya/wemo-mcp-server provides a local interface for integrating WeMo smart home hardware into LLM-powered workflows. Unlike cloud-dependent bridges, this implementation leverages pywemo to communicate directly with devices on the local network, reducing latency and improving privacy. For developers, this means the ability to expose physical environment controls—such as lighting levels and power states—as executable tools within an MCP-compliant client. It handles the complexities of multi-phase device discovery and HomeKit authentication internally, allowing you to implement natural language automation for home labs or office environments without managing a proprietary cloud API.

The latex-mcp-server bridges the gap between LLMs and the complex LaTeX ecosystem, moving beyond simple code generation to actual document orchestration. Instead of manually copying snippets into an editor, developers can now delegate the compilation process, bibliography management, and figure integration directly to the model. It is particularly useful for researchers and technical writers who need to automate the synchronization of cited papers with their manuscripts or execute visualization scripts to generate dynamic plots. By treating LaTeX as a programmable environment rather than a static markup language, this server reduces the friction of the 'write-compile-debug' loop and allows the AI to verify visual outputs in real-time.

The mcp-server-chatsum tool bridges the gap between fragmented chat histories and LLM context windows. Instead of manually scrolling through archives or copying logs, developers can programmatically query and summarize conversation threads directly within their MCP-enabled environment. It functions as a retrieval layer for chat data, allowing you to extract key decisions, action items, or technical context from previous discussions without leaving your IDE. By treating chat logs as a queryable data source, it streamlines the process of catching up on project threads or documenting undocumented verbal agreements, making it a practical utility for teams relying on asynchronous communication.

The capsulecrm-mcp server bridges the gap between LLMs and Capsule CRM, transforming your AI assistant from a chat interface into a functional CRM operator. Instead of manually exporting CSVs or toggling tabs, developers can now grant their AI agents the ability to programmatically query contacts, track sales opportunities, and manage task pipelines via the Model Context Protocol. It integrates seamlessly with Claude Desktop through a provided DTX configuration, eliminating the need for custom glue code. This tool is particularly useful for automating lead qualification, summarizing client history during active sessions, or updating pipeline stages through natural language commands, effectively treating your CRM as a dynamic context window for the model.

The mcp-kibela-server provides a standardized interface for LLMs to interact directly with Kibela, a cloud-based contact management system. Instead of manually exporting CSVs or toggling between tabs, developers can now leverage MCP to query, update, and manage contact databases through their AI agent. This tool is particularly useful for automating CRM workflows, synchronizing professional networks, or building custom internal tools that require real-time access to contact metadata. By implementing the Model Context Protocol, it eliminates the need for writing custom API glue code for every single prompt, allowing the model to fetch specific contact details or update entries based on conversation context.

The tsgram-mcp server bridges the gap between Telegram's messaging interface and Claude's reasoning capabilities, specifically enabling local workspace interaction via a mobile device. Unlike standard chat bots, this implementation leverages the Model Context Protocol to allow developers to read and modify local files through a Telegram client. It effectively transforms a mobile device into a remote IDE terminal, allowing for asynchronous code reviews, quick hotfixes, and workspace management without needing a full desktop environment. For developers working in TypeScript, it provides a streamlined way to integrate LLM-driven file operations directly into a platform they already use for communication, reducing the friction of switching between mobile communication and development tools.

The mcp-aiven server integrates Aiven's managed data infrastructure directly into your LLM workflow. Instead of toggling between your IDE and the Aiven console, this tool allows you to programmatically navigate projects and interact with managed instances of PostgreSQL, Apache Kafka, ClickHouse, and OpenSearch. For developers, this means the ability to query database states, verify service configurations, and manage cloud resources using natural language prompts within an MCP-compatible client. It effectively bridges the gap between high-level AI reasoning and low-level infrastructure management, reducing the cognitive load of context-switching during deployment or debugging phases.

The plane-mcp-server bridges the gap between LLMs and Plane, providing a standardized interface to interact with your project management workspace. Instead of manually switching tabs to track tickets, developers can now query issue statuses, update task details, and manage project workflows directly within their AI-enabled IDE or chat interface. By leveraging the Model Context Protocol, this server exposes Plane's API endpoints as tools, allowing the model to perform real-time CRUD operations on issues and projects. It is particularly useful for automating sprint summaries, syncing documentation with active tickets, or triaging backlogs without leaving the coding environment.

The mcp-simple-openai-assistant tool bridges the gap between Claude and OpenAI's Assistant API, allowing developers to leverage specific GPT-based assistants directly within an MCP-enabled environment. Instead of managing separate chat interfaces, you can now delegate complex tasks to pre-configured OpenAI assistants that possess their own custom instructions and knowledge bases. This is particularly useful for workflows requiring the specialized reasoning of a GPT-4o assistant while utilizing Claude as the primary orchestration layer. Integration is straightforward, requiring only an OpenAI API key and the assistant ID, effectively turning your LLM interface into a multi-model hub without writing custom glue code.