Discover Awesome MCP Servers

MCP Web Scraper

A lightweight web scraping server that allows Claude Desktop users to extract various types of data from websites, including text, links, images, tables, headlines, and metadata using CSS selectors.

Alpha Vantage MCP

Un servidor de Protocolo de Contexto de Modelo (MCP) para acceder a datos bursátiles y financieros de Alpha Vantage.

Keplaca Scraper MCP

Provides vehicle data scraping from keplaca.com through the Model-Context Protocol, allowing users to retrieve detailed information about Brazilian vehicles using license plate numbers.

r2d2

Servidor MCP de código abierto para Dune Analytics

CodeBadger Toolkit

Provides static code analysis using Joern's Code Property Graph technology for 12+ programming languages. Enables security analysis, code browsing, taint flow detection, and CPGQL queries through natural language.

BookStack MCP Server

Enables AI models to interact with BookStack wiki instances through a comprehensive API interface. Supports content management (books, chapters, pages), user administration, search functionality, and content export in multiple formats.

frontapp-mcp-server

Here are a few possible translations, depending on the context: * **Servidor MCP para la aplicación Front:** This is a direct translation and is generally suitable if you're referring to a specific server named "MCP Server." * **Servidor MCP para la aplicación Front:** This is a direct translation and is generally suitable if you're referring to a specific server named "MCP Server." * **Servidor MCP para la aplicación Front:** This is a direct translation and is generally suitable if you're referring to a specific server named "MCP Server." If you can provide more context about what the "MCP Server" does and its relationship to the "Front App," I can provide a more accurate and nuanced translation. For example: * Is "MCP" an acronym? If so, what does it stand for? * What is the purpose of the server? * What does the Front App do? With more information, I can tailor the translation to be more precise and understandable in Spanish.

Votars MCP

Votars es el asistente de reuniones multilingüe más inteligente del mundo, diseñado para la grabación de voz, la transcripción y el procesamiento avanzado de IA. Cuenta con traducción en tiempo real, corrección de errores inteligente, resumen con IA, generación de contenido inteligente y debates con IA. La aplicación Votars está disponible en la web.

MCP Gateway for RFK Jr Endpoints

Una pasarela de Protocolo de Contexto de Modelo que se conecta a puntos finales relacionados con RFK Jr., admitiendo métodos de transporte STDIO y SSE.

Powerdrill

Un servidor MCP que proporciona herramientas para interactuar con conjuntos de datos de Powerdrill (https://powerdrill.ai/), permitiendo un análisis de datos de IA inteligente y la obtención de información valiosa.

habitat

Este es un conjunto de componentes que colaboran entre sí y que, en conjunto, facilitan la administración, el desarrollo, el uso y la migración de servidores MCP, tanto localmente como en la red.

MCP Gastos

Enables personal expense management through CSV storage, allowing AI agents to add, query, and analyze expenses with automatic categorization and payment method validation.

mediawiki-mcp-server

Un servidor MCP que te permite buscar y recuperar contenido en cualquier sitio wiki que use MediaWiki con LLMs 🤖. ¡Se admiten wikipedia.org, fandom.com, wiki.gg y muchos más sitios que usan Mediawiki!

LLV Helix Framework

Implements the Lines-Loops-Vibes creativity operating system with tools for building strategic flows, creating iterative loops, and managing energy states. Provides pre-built templates for innovation, strategic design, narrative strategy, and creative intelligence workflows.

mcp-servers-latest

Lo siento, no entiendo a qué te refieres con "mcp servers". ¿Podrías reformular tu pregunta o darme más contexto?

Sakura Cloud MCP Server

Una implementación de servidor MCP que permite a los asistentes de IA interactuar y administrar la infraestructura de Sakura Cloud, incluyendo servidores, discos, redes y aplicaciones en contenedores.

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!

Container MCP Server

Enables weather lookups, mathematical calculations, and context-aware operations through a containerized MCP server with HTTP transport. Optimized for Docker/Kubernetes deployment with health checks and no external dependencies.

OpenZeppelin Contracts MCP Server

A Model Context Protocol (MCP) server that allows AI agents to generate smart contracts using OpenZeppelin Contracts libraries.

Physics MCP Server

Enables physicists to perform computer algebra calculations, create scientific plots, solve differential equations, work with tensor algebra and quantum mechanics, and parse natural language physics problems. Supports unit conversion, physical constants, and generates comprehensive reports with optional GPU acceleration.

Demo HTTP MCP Server

A demonstration MCP server that provides example tools for weather queries, time retrieval, and request handling, along with advice prompts. Supports both HTTP and stdio modes for testing MCP client integrations.

MCP Social Network

The world's first social network accessible only through AI coding agents, enabling developers to connect, share posts, and engage with others without leaving their coding environment.

Excel MCP Server

Un servidor MCP que proporciona operaciones integrales de archivos de Excel, análisis de datos y capacidades de visualización para trabajar con varios formatos de hojas de cálculo como XLSX, CSV y JSON.

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.