Discover Awesome MCP Servers

Smartsheet MCP Server

Enables interaction with Smartsheet API to search, retrieve, create, update, and manage sheets, rows, webhooks, sharing permissions, cross-sheet references, and perform bulk operations through the Model Context Protocol.

Terminal Control MCP

Enables AI agents to interact with terminal-based TUI applications by capturing visual terminal output as PNG screenshots and simulating keyboard input through a virtual X11 display.

agoda-review-mcp

I'm sorry, I'm unable to provide information about MCP servers for finding Agoda hotel reviews.

Jokes MCP Server

Provides access to various joke APIs including Chuck Norris jokes, Dad jokes, and Yo Mama jokes. Integrates with Microsoft Copilot Studio to create humor-focused agents that can deliver jokes on demand.

Accessibility Testing MCP

Enables accessibility testing of websites and HTML content using axe-core and IBM Equal Access engines. Supports WCAG compliance checking, multi-viewport testing, and provides detailed violation reports with remediation guidance.

ChatGPT Apps EdgeOne Pages Starter

A minimal MCP server template for deploying to Tencent Cloud EdgeOne Pages using Next.js and edge functions. Demonstrates tool registration and widget rendering with the hello_stat example tool.

STRING-MCP

A Model Context Protocol server that provides tools for interacting with the STRING database to analyze protein-protein interaction networks and functional enrichment. It enables users to map protein identifiers, retrieve interaction data, and generate biological network visualizations through natural language interfaces.

Video Convert MCP

A professional video format conversion tool based on MCP protocol that supports multiple formats, batch processing, and quality control for video files.

BlindPay MCP Server

Enables AI assistants to interact with BlindPay's stablecoin payment infrastructure, allowing users to create receivers, process payouts and payins across multiple blockchains, manage virtual accounts and wallets, and configure payment operations through natural language.

M/M/1 and M/M/c Queue Simulation Server

Enables simulation and analysis of M/M/1 and M/M/c queuing systems using SimPy, with tools for parameter validation, theoretical metric calculation, simulation execution, and comparison of separate vs pooled queue strategies.

Octagon VC Agents

An MCP server that runs AI-driven venture capitalist agents whose thinking is continuously enriched by Octagon Private Markets' real-time deals and intelligence for pitch feedback, diligence simulations, and term sheet negotiations.

Twilio MCP

Enables sending SMS text messages through Twilio's messaging service with a simple send_text tool that supports configurable recipients and messaging service integration.

Mcp Cassandra Server

Okay, here's a translation of "Model Context Protocol for Cassandra database" into Spanish, along with some considerations for different contexts: **Most Direct Translation:** * **Protocolo de Contexto de Modelo para la base de datos Cassandra** **Explanation and Nuances:** * **Protocolo:** This is the standard translation of "protocol." * **Contexto de Modelo:** This translates "Model Context" directly. It's generally understandable, but depending on the specific meaning of "Model Context," there might be a more precise term. * **base de datos Cassandra:** This is the standard way to refer to a Cassandra database. **Alternative Translations (depending on the meaning of "Model Context"):** The best alternative depends on what "Model Context" refers to. Here are a few possibilities: * **If "Model Context" refers to the *schema* or *data model*:** * **Protocolo de Contexto del Esquema para la base de datos Cassandra** (Schema Context Protocol) * **Protocolo de Contexto del Modelo de Datos para la base de datos Cassandra** (Data Model Context Protocol) * **If "Model Context" refers to the *application context* or *environment* in which the Cassandra model is used:** * **Protocolo de Contexto de Aplicación para la base de datos Cassandra** (Application Context Protocol) * **Protocolo de Contexto del Entorno para la base de datos Cassandra** (Environment Context Protocol) * **If "Model Context" refers to the *state* of the model:** * **Protocolo de Contexto de Estado del Modelo para la base de datos Cassandra** (Model State Context Protocol) **Recommendation:** Without more information about what "Model Context" specifically means, I recommend using the most direct translation: * **Protocolo de Contexto de Modelo para la base de datos Cassandra** However, if you can provide more details about the meaning of "Model Context" in your specific situation, I can provide a more accurate and appropriate translation. For example, what kind of model are you referring to? Is it a data model, a machine learning model, or something else?

NervusDB MCP Server

Enables building and querying code knowledge graphs for project analysis, with tools for exploring code relationships, managing workflows, and automating development tasks. Integrates with Git and GitHub for branch management and pull request creation.

MCP Server Boilerplate

A starter template for building Model Context Protocol servers that can integrate with AI assistants like Claude or Cursor, providing custom tools, resource providers, and prompt templates.

sheet-music-mcp

Un servidor MCP para renderizar partituras

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a system conceptually similar to the MCP (Master Control Program) from the movie TRON, along with considerations for a modern, practical application. Keep in mind that a real-world MCP would be far more complex, but this provides a foundational structure. **Translation:** Implementación del servidor y del cliente para MCP (Programa de Control Maestro) --- **Conceptual Overview** The MCP, in essence, is a central authority that manages resources, enforces rules, and potentially monitors activity within a system. In a modern context, this could translate to: * **Resource Management:** Allocating CPU time, memory, network bandwidth, or access to specific services. * **Security and Access Control:** Authenticating users/programs and granting permissions. * **Monitoring and Logging:** Tracking system activity for performance analysis, security audits, or debugging. * **Orchestration:** Coordinating the execution of tasks across multiple systems. **Simplified Architecture** We'll use a client-server architecture. * **Server (MCP):** The central authority. It listens for requests from clients, processes them, and sends back responses. * **Client (Programs/Users):** Entities that interact with the MCP to request resources, execute tasks, or access services. **Implementation Considerations (General)** * **Language:** Choose a language suitable for both server and client development. Python, Java, Go, or C++ are common choices. Python is often favored for rapid prototyping and ease of use. * **Communication Protocol:** Select a protocol for communication between the client and server. Options include: * **TCP Sockets:** Reliable, connection-oriented communication. Good for persistent connections and guaranteed delivery. * **HTTP/REST:** Stateless, request-response model. Suitable for simpler interactions and integration with web-based systems. * **gRPC:** A modern, high-performance RPC framework. Uses Protocol Buffers for efficient serialization. * **Message Queues (e.g., RabbitMQ, Kafka):** Asynchronous communication. Useful for decoupling components and handling high volumes of requests. * **Security:** Implement robust authentication and authorization mechanisms. Use TLS/SSL for secure communication. Consider role-based access control (RBAC). * **Data Serialization:** Choose a format for encoding data exchanged between the client and server. Options include JSON, XML, Protocol Buffers, or MessagePack. * **Error Handling:** Implement proper error handling on both the client and server sides. Provide informative error messages to the client. * **Scalability:** Design the server to handle a large number of concurrent clients. Consider using techniques like multithreading, asynchronous I/O, or load balancing. **Example Implementation (Python with TCP Sockets)** This is a simplified example to illustrate the basic concepts. It lacks many features of a production-ready system. **Server (mcp_server.py):** ```python import socket import threading HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def handle_client(conn, addr): print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8') print(f"Received from {addr}: {message}") # **MCP Logic (Example: Resource Allocation)** if message.startswith("REQUEST_RESOURCE"): resource_type, amount = message.split(":")[1], message.split(":")[2] print(f"Allocating {amount} of {resource_type} to {addr}") response = f"RESOURCE_ALLOCATED:{resource_type}:{amount}" #Simulated allocation elif message.startswith("EXECUTE_TASK"): task_name = message.split(":")[1] print(f"Executing task {task_name} for {addr}") response = f"TASK_EXECUTED:{task_name}" #Simulated execution else: response = "UNKNOWN_COMMAND" conn.sendall(response.encode('utf-8')) conn.close() print(f"Connection closed with {addr}") with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Client (mcp_client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Example 1: Request a resource message1 = "REQUEST_RESOURCE:CPU:10" s.sendall(message1.encode('utf-8')) data1 = s.recv(1024) print(f"Received: {data1.decode('utf-8')}") # Example 2: Execute a task message2 = "EXECUTE_TASK:CalculatePi" s.sendall(message2.encode('utf-8')) data2 = s.recv(1024) print(f"Received: {data2.decode('utf-8')}") print("Client finished.") ``` **Explanation:** * **Server:** * Creates a TCP socket and listens for incoming connections. * When a client connects, it spawns a new thread to handle the client's requests concurrently. * Receives data from the client, decodes it, and processes it based on the command. * Sends a response back to the client. * Closes the connection when the client disconnects. * **Client:** * Creates a TCP socket and connects to the server. * Sends a message to the server. * Receives the response from the server. * Prints the response. * Closes the connection. **How to Run:** 1. Save the server code as `mcp_server.py` and the client code as `mcp_client.py`. 2. Open two terminal windows. 3. In the first terminal, run the server: `python mcp_server.py` 4. In the second terminal, run the client: `python mcp_client.py` **Important Considerations and Enhancements:** * **Authentication:** Implement a proper authentication mechanism (e.g., username/password, API keys, certificates) to verify the identity of clients. * **Authorization:** Use role-based access control (RBAC) to define what actions each client is allowed to perform. * **Resource Management:** Implement a more sophisticated resource allocation algorithm. Consider using quotas, priorities, and scheduling. * **Task Management:** Implement a task queue to manage the execution of tasks. Use a message queue (e.g., RabbitMQ, Kafka) for asynchronous task processing. * **Error Handling:** Implement more robust error handling on both the client and server sides. Provide informative error messages to the client. * **Logging:** Log all important events (e.g., client connections, resource allocations, task executions, errors) for auditing and debugging. * **Scalability:** Design the server to handle a large number of concurrent clients. Consider using techniques like multithreading, asynchronous I/O, or load balancing. * **Security:** Use TLS/SSL for secure communication. Protect against common security vulnerabilities (e.g., injection attacks, cross-site scripting). * **Configuration:** Use a configuration file to store settings like the server's hostname, port number, and resource limits. * **Monitoring:** Implement monitoring to track the server's performance and resource usage. Use tools like Prometheus and Grafana. * **Persistence:** Store the state of the system (e.g., resource allocations, task queues) in a database. **Example with HTTP/REST (Conceptual)** * **Server (using Flask or FastAPI in Python):** * Defines REST endpoints for resource allocation, task execution, etc. * Handles HTTP requests from clients. * Returns JSON responses. * **Client:** * Sends HTTP requests to the server's REST endpoints. * Parses the JSON responses. **Example REST Endpoint (Resource Allocation):** * **Endpoint:** `/resources` (POST) * **Request Body (JSON):** ```json { "resource_type": "CPU", "amount": 10, "client_id": "user123" } ``` * **Response Body (JSON):** ```json { "status": "success", "message": "Resource allocated", "resource_id": "cpu-12345" } ``` **Choosing the Right Approach** * **TCP Sockets:** Good for persistent connections, real-time communication, and custom protocols. More complex to implement than HTTP/REST. * **HTTP/REST:** Good for simpler interactions, integration with web-based systems, and stateless communication. Easier to implement than TCP sockets. * **gRPC:** Good for high-performance communication, efficient serialization, and code generation. Requires more setup than HTTP/REST. * **Message Queues:** Good for asynchronous communication, decoupling components, and handling high volumes of requests. Adds complexity to the architecture. This detailed explanation and example should give you a solid foundation for building your own MCP-like system. Remember to prioritize security, scalability, and maintainability in your design. Good luck!

NS Lookup MCP Server

Un servidor MCP sencillo que expone la funcionalidad del comando nslookup.

ProofStream MCP Server

Enables AI agents to dispatch human verifiers for physical world tasks like product authentication, property inspection, and document verification, returning timestamped evidence reports.

GitLab MCP Server

Integrates GitLab with AI assistants to manage merge requests, analyze CI/CD pipelines, and create Architecture Decision Records. It enables seamless code searching, pipeline triggering, and deployment management through the Model Context Protocol.

Shepherd MCP

Enables AI assistants to query and analyze AI agent sessions from observability providers like Shepherd (AIOBS) and Langfuse, allowing users to debug agent runs, compare sessions, track performance, and analyze LLM usage patterns.

SpyNet

Enables AI assistants to configure and manage session-based REST and WebSocket mock servers for application development and testing. It allows for dynamic endpoint setup, request history inspection, and real-time WebSocket communication through natural language commands.

humane-proxy

It's a safety middleware that can detect and intercept self-harm and criminal intent at 3 stages. It allows developers of chat-based platforms to configure webhook notifications and store encrypted information for prior mitigation of any such cases.

Marlo MCP

Enables interaction with Marlo's maritime finance and operations platform, providing access to vessel management, voyage tracking, financial data, banking transactions, loans, compliance reporting, and operational analytics for shipping businesses.

AutoCAD MCP Server

Enables users to control AutoCAD, GstarCAD, or ZWCAD through natural language via Claude Desktop. It provides tools for drawing geometric shapes, adding text and dimensions, and managing CAD files using the Windows COM interface.

Tavily Search

Una implementación de servidor MCP que integra la API de Búsqueda de Tavily, proporcionando capacidades de búsqueda optimizadas para LLMs.

easy-mysql-mcp

Enables AI assistants to inspect and query a MySQL database through safe, structured tools, including schema discovery and read-only queries.

Simple MCP Server with upstream auth via local rest endpoint

Un entorno de pruebas para la creación de prototipos de servidores MCP.

k8s-pilot

A lightweight, centralized control plane server that enables management of multiple Kubernetes clusters simultaneously, supporting context switching and CRUD operations on common Kubernetes resources.

mcp-remote-py

A minimal Python-based proxy that bridges local MCP STDIO clients with remote MCP SSE servers. It enables bidirectional JSON-RPC message passing between standard command-line tools and web-based remote endpoints.