Discover Awesome MCP Servers

go-docs

MCP server that provides real-time Go documentation and expert programming assistance by fetching from pkg.go.dev.

hojokin-antenna-mcp

Enables AI assistants to search Japanese government subsidies and grants, including archived closed calls and recurring application periods based on historical data.

grok-quorum-mcp

Enables Claude to query Grok as a peer for collaborative reasoning, code reviews, and architecture debates. It provides access to real-time web research and multiple specialized reasoning modes through the xAI API.

freebuff-bridge

MCP server that bridges agents to Freebuff Desktop sessions, enabling project and thread management, prompt sending, queue control, and wake-on-demand via REST API, SSE, and MCP tools.

visualizer-mcp

Connects AI assistants to Siemens Questa Visualizer, enabling natural language control of HDL simulation such as opening waveforms, running simulation, and examining signal values.

jgrants-mcp

デジタル庁による補助金APIをラップしたMCPサーバーです。

mcp-view

An MCP server that builds a local webpage to view AI plans, reports, and diagrams, so the AI only needs to send a URL pointer instead of long text. It provides three tools (view_plan, view_report, view_diagram) and tracks project changes for diff viewing.

Cerase Tasks MCP

A tasks and projects board MCP server for agents, providing create, list, and status update tools with agent-scoped access via control-plane proxy.

OdooForge MCP Server

Enables AI assistants to fully control and manage Odoo 18 ERP instances through 79 tools, including configuration, data operations, reporting, and code generation, with built-in domain knowledge and specialist agents.

opencode-browser-control

A Playwright-powered MCP server for browser automation using ARIA snapshots and element refs, enabling LLMs to control Chrome/Edge without CSS selectors.

Design Checklists MCP

Provides read-only access to over 100 UX/UI design checklists from Checklist.design, enabling users to search and retrieve design guidance for specific flows and screens. Runs locally without an API key.

SUMO-MCP Server

Connects LLMs to Eclipse SUMO traffic simulation, enabling AI agents to automate traffic network generation, demand modeling, signal optimization, simulation execution, and real-time TraCI control through natural language.

mcp-incus-vm

Enables AI agents to control and automate Incus/QEMU virtual machines via SSH, supporting mouse/keyboard, screenshots, commands, and lifecycle management.

EVE Online OSINT MCP Server

An MCP (Model Context Protocol) server that provides OSINT (Open Source Intelligence) capabilities for EVE Online using multiple APIs including ESI, EveWho, and zKillboard. This server allows AI assistants to gather comprehensive intelligence on EVE Online characters, corporations, and alliances by

tradier-mcp

MCP server exposing Tradier brokerage tools to Claude, enabling account balance checks, position management, order operations, and market data queries.

WiseTech Image MCP Server

Enables image upscaling, face enhancement, and background removal via public image URLs, returning base64 PNG results.

Canvas MCP Server

Enables AI assistants to manage Canvas LMS courses, announcements, rubrics, assignments, modules, pages, and student data via the Canvas API.

acronis-mcp

MCP server that exposes Acronis Cyber Protect Cloud APIs as 14 read-only tools for managing alerts, tasks, agents, resources, policies, and tenants.

Redis MCP Server

Okay, here's a translation of "Redis MCP Server - Python implementation with docker" into Spanish, along with some options depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Servidor Redis MCP - Implementación en Python con Docker** **Option 2 (Slightly More Descriptive):** * **Servidor MCP de Redis - Implementación en Python usando Docker** **Option 3 (Emphasizing Containerization):** * **Servidor Redis MCP - Implementación en Python, contenedorizado con Docker** **Explanation of Choices:** * **Servidor:** Server * **Redis:** Redis (no translation needed) * **MCP:** MCP (Most likely an acronym, so it's best to leave it as is) * **Implementación:** Implementation * **en Python:** in Python * **con Docker / usando Docker:** with Docker / using Docker * **contenedorizado con Docker:** containerized with Docker (emphasizes the use of Docker for containerization) **Recommendation:** I would recommend **Option 1: Servidor Redis MCP - Implementación en Python con Docker** as the most straightforward and commonly understood translation. If you want to emphasize that Docker is being used for containerization, then **Option 3** is a good choice.

skill-curator-mcp

Enables AI agents to intelligently match tasks to skills through semantic embeddings, track skill effectiveness, detect skill gaps, and discover new skills from external sources.

Multi-Channel Processing (MCP) Server

A serverless AI-powered system built with Cloudflare Workers that handles multiple communication channels efficiently while integrating OpenAI Agents SDK for AI capabilities.

opensprinkler-mcp

Enables managing OpenSprinkler irrigation controllers via Claude Desktop, including starting/stopping stations, setting rain delays, and viewing controller status.

ibge-br-mcp

This server provides access to IBGE's public APIs, enabling AI assistants to query geographic, demographic, and statistical data from Brazil.

korea-onegov-mcp

Enables searching and retrieving Korean government documents (press releases, policies, laws, statistics, etc.) from about 50 central administrative agencies through natural language interactions with AI assistants like Claude and ChatGPT.

Weather MCP Server

A production-ready MCP server that provides real-time weather information, forecasts, air quality, and weather alerts through the OpenWeatherMap API. It integrates with Claude Desktop and other MCP-compatible clients for natural language weather queries.

INPI: Marcas

Consulta de marcas do INPI em fonte oficial, com uma ferramenta de leitura via MCP.

Labguru MCP Server

Enables natural language interaction with the Labguru laboratory management system, providing 63 tools across experiments, protocols, inventory, and more.

Math MCP Server for MacOS

Okay, here's a breakdown of how you could implement a math agent using the Model Control Protocol (MCP) to perform calculations and visually present results in Keynote, including drawing shapes and adding text to slides. This is a complex project, so I'll outline the key components and considerations. **Conceptual Overview** The core idea is to have a system where: 1. **User Input:** The user provides a mathematical problem or instruction (e.g., "Calculate the area of a circle with radius 5 and show the result in Keynote with a circle diagram"). 2. **Math Agent (MCP Controller):** This agent receives the input, parses it, performs the necessary calculations, and formulates instructions for Keynote. It acts as the MCP controller. 3. **Keynote (MCP Model):** Keynote is the application that will be controlled. It acts as the MCP model. It needs to have a mechanism to receive instructions from the Math Agent and execute them (e.g., create a slide, draw a circle, add text). 4. **Communication (MCP):** The Math Agent and Keynote communicate using the Model Control Protocol. This protocol defines how the agent sends commands and how Keynote responds. **Key Components and Implementation Steps** 1. **Math Agent (MCP Controller):** * **Natural Language Processing (NLP):** You'll need an NLP component to understand the user's input. This could involve: * **Intent Recognition:** Identifying the user's goal (e.g., "calculate area," "plot a graph," "solve an equation"). * **Entity Extraction:** Extracting the relevant parameters (e.g., radius of the circle, equation to solve). Libraries like spaCy or NLTK (in Python) are helpful. For more complex math, consider using libraries like SymPy to parse mathematical expressions. * **Mathematical Calculation Engine:** Use a library like NumPy, SciPy, or SymPy (in Python) to perform the actual calculations. * **MCP Command Generation:** This is the crucial part. Based on the calculations and the user's request, the agent needs to generate MCP commands that Keynote can understand. These commands will specify: * Creating a new slide. * Drawing shapes (circles, rectangles, lines, etc.). * Adding text (labels, results, explanations). * Formatting (font, color, size, position). * **MCP Communication:** Implement the MCP client to send the commands to Keynote. This will likely involve using sockets or some other inter-process communication mechanism. 2. **Keynote (MCP Model):** * **MCP Server:** Keynote needs to act as an MCP server, listening for commands from the Math Agent. This is the most challenging part, as Keynote doesn't natively support MCP. You'll likely need to use one of the following approaches: * **AppleScript:** AppleScript is Keynote's scripting language. You can write an AppleScript that listens for commands (e.g., via a file or socket) and then executes the corresponding Keynote actions (creating slides, drawing shapes, adding text). This is probably the most practical approach. * **Keynote Plugin (if possible):** If Keynote allows plugins (I'm not sure if it does), you could write a plugin that implements the MCP server. This would be more complex but potentially more efficient. * **Accessibility API:** You *might* be able to use the macOS Accessibility API to control Keynote programmatically, but this is likely to be very fragile and difficult. * **Command Parsing and Execution:** The Keynote component needs to parse the MCP commands it receives and then execute the corresponding actions in Keynote. This will involve using AppleScript (or the plugin API) to manipulate Keynote's objects (slides, shapes, text boxes). 3. **Model Control Protocol (MCP):** * **Define the Protocol:** Since you're building this from scratch, you need to define the MCP. A simple text-based protocol might look like this: ``` # Example MCP Commands CREATE_SLIDE DRAW_CIRCLE x=100 y=100 radius=50 color=red ADD_TEXT x=200 y=50 text="Area = 78.54" font=Arial size=12 ``` * **Command Structure:** Each command should have a clear structure (e.g., `COMMAND_NAME attribute1=value1 attribute2=value2`). * **Error Handling:** Define how Keynote should respond to errors (e.g., send an error message back to the Math Agent). * **Acknowledgement:** Consider having Keynote send an acknowledgement after each command is executed successfully. 4. **Communication Mechanism:** * **Sockets:** Sockets are a common way to implement inter-process communication. The Math Agent would open a socket and connect to Keynote (which would be listening on a specific port). * **Files:** A simpler approach (especially for initial testing) is to have the Math Agent write commands to a file, and Keynote periodically checks the file for new commands. This is less efficient but easier to set up. **Example Scenario (Area of a Circle)** 1. **User Input:** "Calculate the area of a circle with radius 5 and show the result in Keynote." 2. **Math Agent:** * Parses the input and extracts "radius = 5." * Calculates the area: `area = pi * radius^2 = 3.14159 * 5^2 = 78.53975`. * Generates MCP commands: ``` CREATE_SLIDE DRAW_CIRCLE x=300 y=200 radius=100 color=blue ADD_TEXT x=200 y=50 text="Radius = 5" font=Helvetica size=14 ADD_TEXT x=200 y=100 text="Area = 78.54" font=Helvetica size=14 ``` * Sends the commands to Keynote via a socket. 3. **Keynote:** * Receives the commands. * Executes the commands using AppleScript: * Creates a new slide. * Draws a blue circle at (300, 200) with a radius of 100. * Adds the text "Radius = 5" and "Area = 78.54" at the specified positions. **Code Snippets (Illustrative - Python and AppleScript)** **Python (Math Agent - MCP Controller)** ```python import socket import math def calculate_circle_area(radius): area = math.pi * radius**2 return area def generate_keynote_commands(radius, area): commands = [ "CREATE_SLIDE", f"DRAW_CIRCLE x=300 y=200 radius={radius * 20} color=blue", # Scale radius for visual size f"ADD_TEXT x=200 y=50 text='Radius = {radius}' font=Helvetica size=14", f"ADD_TEXT x=200 y=100 text='Area = {area:.2f}' font=Helvetica size=14" ] return "\n".join(commands) def send_commands_to_keynote(commands, host='localhost', port=12345): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((host, port)) s.sendall(commands.encode()) # Optionally, receive acknowledgement from Keynote # data = s.recv(1024) # print('Received', repr(data)) if __name__ == "__main__": radius = 5 area = calculate_circle_area(radius) keynote_commands = generate_keynote_commands(radius, area) print(keynote_commands) send_commands_to_keynote(keynote_commands) ``` **AppleScript (Keynote - MCP Model - Simplified Example)** ```applescript -- This is a very basic example. A real implementation would need to: -- 1. Listen for commands (e.g., via a file or socket). -- 2. Parse the commands. -- 3. Handle errors. on create_slide() tell application "Keynote" tell front document make new slide at end with properties {base slide: missing value} end tell end tell end create_slide on draw_circle(x_pos, y_pos, radius, circle_color) tell application "Keynote" tell front document tell current slide set new_shape to make new oval at end with properties {width: radius * 2, height: radius * 2, position:{x_pos, y_pos}} tell new_shape set fill color to circle_color end tell end tell end tell end tell end draw_circle on add_text(x_pos, y_pos, text_content, text_font, text_size) tell application "Keynote" tell front document tell current slide set new_text_box to make new text item at end with properties {position:{x_pos, y_pos}, content:text_content} tell new_text_box set font name to text_font set size to text_size end tell end tell end tell end tell end add_text -- Example usage (replace with actual command parsing) -- create_slide() -- draw_circle(300, 200, 100, "blue") -- add_text(200, 50, "Radius = 5", "Helvetica", 14) -- add_text(200, 100, "Area = 78.54", "Helvetica", 14) ``` **Important Considerations:** * **Error Handling:** Implement robust error handling in both the Math Agent and Keynote. This is crucial for a reliable system. * **Security:** If you're using sockets, be aware of security implications. Consider using authentication and encryption if necessary. * **Complexity:** This is a complex project. Start with a simple scenario (like the area of a circle) and gradually add more features. * **Alternatives:** Consider whether there are simpler alternatives. For example, could you generate images of the results and insert them into Keynote? Or could you use a different presentation tool that has better scripting capabilities? * **Keynote Limitations:** Be aware of the limitations of Keynote's scripting capabilities. Some things might be difficult or impossible to achieve. * **Testing:** Thoroughly test your system with a variety of inputs and scenarios. **In summary, this project requires a combination of NLP, mathematical computation, inter-process communication, and Keynote scripting. The most challenging part is likely to be implementing the MCP server in Keynote using AppleScript (or a plugin, if possible). Start small, test frequently, and be prepared to iterate on your design.**

Zenoti MCP Server

Enables AI agents to manage spa/wellness operations via Zenoti API, including appointments, guests, services, and billing.

ProdPad MCP Server

An MCP server that connects Claude to ProdPad, giving Claude direct access to your product management data including ideas, feedback, roadmaps, OKRs, and initiatives.