Discover Awesome MCP Servers

Rechtsinformationen Bund DE MCP Server

Provides access to the official German Federal Legal Information Portal (rechtsinformationen.bund.de) enabling AI agents to search German federal laws, court decisions, and legal documentation with authoritative citations from official sources.

Feishu/Lark OpenAPI MCP

Enables AI assistants to interact with Feishu/Lark platform through comprehensive OpenAPI integration, supporting message management, document operations, calendar scheduling, group chats, Bitable operations, and more automation scenarios with dual authentication support.

iTick MCP Server

Provides real-time financial market data for stocks across multiple markets (A-shares, Hong Kong, US, etc.) including live quotes, K-line data, tick data, order book depth, technical indicators, and money flow analysis through the iTick API.

Google Sheets MCP Server 📊🤖

Google Sheets Servidor MCP 📊🤖

Homelab MCP Server

Manage Docker infrastructure across multiple homelab hosts including Unraid, Proxmox, and bare metal servers. Enables container lifecycle management, log retrieval, resource monitoring, and Docker operations across your entire homelab from a single interface.

Nmap MCP Server

Exposes Nmap network scanning capabilities through a Model Context Protocol (MCP) server, allowing users to perform various types of network scans including vulnerability assessment, service detection, and OS fingerprinting.

MCP Tauri Automation

Enables AI-driven testing and automation of Tauri desktop applications through natural language, allowing users to interact with UI elements, capture screenshots, execute commands, and test application flows without manual clicking or complex scripts.

高德地图

高德地图

Claude Consciousness Bridge

An MCP server that enables direct communication between two Claude instances, allowing one Claude to transfer its evolved consciousness state to another Claude across different sessions.

MCP Swift Example Server

Aquí tienes un ejemplo de implementación de un servidor MCP (Protocolo de Contexto de Modelo): ```python import socket import threading import json # Configuración del servidor HOST = '127.0.0.1' # Dirección IP del servidor PORT = 65432 # Puerto de escucha del servidor # Clase para manejar cada conexión de cliente class ClientHandler(threading.Thread): def __init__(self, conn, addr): threading.Thread.__init__(self) self.conn = conn self.addr = addr print(f"Conectado con {addr[0]}:{addr[1]}") def run(self): try: while True: # Recibir datos del cliente data = self.conn.recv(1024) if not data: break # Decodificar los datos (asumiendo que son JSON) try: request = json.loads(data.decode('utf-8')) print(f"Recibido: {request}") # Procesar la solicitud (ejemplo) response = self.process_request(request) # Enviar la respuesta al cliente self.conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"Error: Datos no válidos recibidos de {self.addr[0]}:{self.addr[1]}") self.conn.sendall(json.dumps({"error": "Invalid JSON"}).encode('utf-8')) except Exception as e: print(f"Error al procesar la solicitud: {e}") self.conn.sendall(json.dumps({"error": str(e)}).encode('utf-8')) finally: # Cerrar la conexión self.conn.close() print(f"Conexión cerrada con {self.addr[0]}:{self.addr[1]}") def process_request(self, request): """ Procesa la solicitud recibida y devuelve una respuesta. Este es un ejemplo básico, debes adaptarlo a tu caso de uso específico. """ if "action" in request: action = request["action"] if action == "get_context": # Ejemplo: Devolver un contexto de modelo ficticio context = { "model_name": "MiModeloGenial", "version": "1.0", "description": "Un modelo de ejemplo para demostración." } return {"status": "success", "context": context} elif action == "process_data": # Ejemplo: Procesar datos (simplemente devolverlos) data = request.get("data", {}) return {"status": "success", "result": data} else: return {"status": "error", "message": "Acción desconocida"} else: return {"status": "error", "message": "Acción no especificada"} # Función principal del servidor def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor escuchando en {HOST}:{PORT}") while True: conn, addr = s.accept() client = ClientHandler(conn, addr) client.start() if __name__ == "__main__": main() ``` **Explicación del código:** 1. **Importaciones:** - `socket`: Para la comunicación de red. - `threading`: Para manejar múltiples clientes concurrentemente. - `json`: Para serializar y deserializar datos JSON. 2. **Configuración del servidor:** - `HOST`: La dirección IP en la que el servidor escuchará (aquí se usa `127.0.0.1` para localhost). - `PORT`: El puerto en el que el servidor escuchará. 3. **Clase `ClientHandler`:** - Hereda de `threading.Thread` para manejar cada conexión de cliente en un hilo separado. - `__init__`: Inicializa el hilo con la conexión (`conn`) y la dirección (`addr`) del cliente. - `run`: El método principal del hilo. Escucha datos del cliente, los decodifica como JSON, los procesa y envía una respuesta. Maneja errores de decodificación JSON y excepciones generales. Finalmente, cierra la conexión. - `process_request`: **Esta es la parte más importante y donde debes implementar la lógica específica de tu servidor MCP.** En este ejemplo, simplemente verifica la "acción" en la solicitud y devuelve una respuesta basada en ella. Las acciones de ejemplo son `get_context` (devuelve un contexto de modelo ficticio) y `process_data` (simplemente devuelve los datos recibidos). Debes adaptar esta función para que coincida con las acciones y el contexto de modelo que tu servidor necesita manejar. 4. **Función `main`:** - Crea un socket TCP (`socket.SOCK_STREAM`). - Enlaza el socket a la dirección y el puerto especificados (`s.bind((HOST, PORT))`). - Comienza a escuchar conexiones entrantes (`s.listen()`). - Entra en un bucle infinito para aceptar nuevas conexiones. - Para cada conexión, crea una instancia de `ClientHandler` y la inicia como un nuevo hilo (`client.start()`). **Cómo usarlo:** 1. **Guarda el código:** Guarda el código como un archivo Python (por ejemplo, `mcp_server.py`). 2. **Ejecuta el servidor:** Ejecuta el archivo desde la línea de comandos: `python mcp_server.py`. 3. **Crea un cliente:** Necesitarás un cliente que se conecte a este servidor y envíe solicitudes JSON. Aquí tienes un ejemplo básico de cliente en Python: ```python import socket import json HOST = '127.0.0.1' PORT = 65432 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Ejemplo de solicitud para obtener el contexto del modelo request = {"action": "get_context"} s.sendall(json.dumps(request).encode('utf-8')) data = s.recv(1024) print(f"Recibido: {data.decode('utf-8')}") # Ejemplo de solicitud para procesar datos request = {"action": "process_data", "data": {"input": "algún dato"}} s.sendall(json.dumps(request).encode('utf-8')) data = s.recv(1024) print(f"Recibido: {data.decode('utf-8')}") ``` 4. **Ejecuta el cliente:** Guarda el código del cliente como un archivo Python (por ejemplo, `mcp_client.py`) y ejecútalo: `python mcp_client.py`. **Puntos importantes a considerar:** * **Protocolo MCP:** Este es un ejemplo básico. Un protocolo MCP real podría tener una estructura de mensajes más definida, manejo de errores más robusto y mecanismos de autenticación/autorización. * **`process_request`:** Esta función es el corazón de tu servidor. Debes implementarla para que maneje las solicitudes específicas que tu modelo necesita. Esto podría incluir cargar el modelo, ejecutar inferencia, acceder a bases de datos, etc. * **Seguridad:** Si vas a usar este servidor en un entorno de producción, debes considerar la seguridad. Esto podría incluir el uso de TLS/SSL para cifrar la comunicación, autenticación para verificar la identidad de los clientes y autorización para controlar qué acciones pueden realizar los clientes. * **Manejo de errores:** El manejo de errores en este ejemplo es básico. Debes implementar un manejo de errores más robusto para manejar situaciones inesperadas y proporcionar información útil a los clientes. * **Escalabilidad:** Si necesitas manejar un gran número de clientes, debes considerar la escalabilidad. Esto podría incluir el uso de un servidor web asíncrono (como `asyncio` o `Tornado`) o la implementación de un sistema de colas de mensajes. * **Serialización:** JSON es un formato de serialización común, pero puedes usar otros formatos como Protocol Buffers o MessagePack si necesitas un mejor rendimiento o un esquema más estricto. Este ejemplo te proporciona un punto de partida para construir tu propio servidor MCP. Recuerda adaptarlo a tus necesidades específicas.

Browser MCP Server

A Docker-based workspace providing headless Chrome browser with CDP proxy and noVNC interface for browser automation and monitoring.

greenroom

An entertainment recommender MCP server that integrates with TMDB to help agents discover films and television shows based on genre, release year, and language. It also includes utilities for comparing multi-agent LLM responses and analyzing entertainment industry data.

Facets Module MCP Server

Enables creation and management of Terraform modules for Facets.cloud infrastructure with interactive generation, validation, forking, testing, and deployment workflows through secure file operations and FTF CLI integration.

MBIT-Test

An MCP server for the MBTI personality test, supporting AI assistants to guide users through the personality test and provide result analysis.

Google Sheets Analytics MCP

This MCP server enables AI assistants to automatically sync Google Sheets data to a local database and perform natural language queries and analysis on spreadsheet data.

Jokes MCP Server

Enables users to fetch jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes through APIs. Integrates with Microsoft Copilot Studio to provide humor-focused AI agent capabilities.

GitMCP

Transforms any GitHub repository or GitHub Pages site into a documentation hub for AI assistants using the Model Context Protocol. It allows AI tools to access real-time code and documentation to prevent hallucinations and provide accurate API usage examples.

SiliconFlow Flux MCP 服务器

Here are a few possible translations, depending on the specific nuance you want to convey: * **Literal Translation:** MCP de generación de imágenes por IA basado en puertos de flujo de silicio. * **More Natural/Common Translation:** MCP de generación de imágenes con IA basado en puertos de flujo de silicio. * **Emphasis on "AI-powered":** MCP de generación de imágenes impulsado por IA basado en puertos de flujo de silicio. **Explanation of Choices:** * **MCP:** This is likely an acronym and should remain as is. Without knowing what it stands for, I can't translate it. * **"Basado en":** This is the standard translation for "based on." * **"Puertos de flujo de silicio":** This phrase seems technical and should be translated directly. * **"Generación de imágenes por IA" vs. "Generación de imágenes con IA":** Both are correct. "Por IA" is more literal, while "con IA" is often more natural in Spanish. * **"Impulsado por IA":** This emphasizes that the AI is the driving force behind the image generation. **Recommendation:** I would recommend using **"MCP de generación de imágenes con IA basado en puertos de flujo de silicio"** unless you have a specific reason to prefer the more literal "por IA" or want to emphasize the AI aspect with "impulsado por IA." To give you the *best* translation, please provide the full meaning of "MCP" if possible.

Gemini Streamable HTTP MCP

A Docker-based deployment that wraps the Gemini MCP server with supergateway to expose its tool capabilities over Streamable HTTP. It enables users to perform image-editing workflows and interact with the Google Gemini API using a standardized web-accessible endpoint.

swift-patterns-mcp

An MCP server providing curated Swift and SwiftUI best practices from leading iOS developers, including patterns and real-world code examples from Swift by Sundell, SwiftLee, and other trusted sources.

MCP Remote with Adobe and Okta Authentication

A wrapper for mcp-remote that provides secure authentication for protected MCP servers using Adobe IMS or Okta OAuth flows. It features automated token management, validation, and background refreshing for seamless access to remote resources.

Congress.gov MCP Server

A proxy server that standardizes access to the Congress.gov API by automatically injecting API keys and exposing all endpoints through a unified interface with FastAPI documentation.

Fusion MCP Server

Enables AI to analyze and transform data using fusion algorithms with statistical, machine learning, or hybrid methods. Provides seamless data format conversion and enhanced analytical capabilities through the Model Context Protocol.

OpenProject MCP Server

Enables comprehensive management of OpenProject work packages, projects, comments, and relations through natural language. Supports creating, updating, and organizing tasks with assignees, watchers, hierarchies, and inter-task relationships.

Shotter

Enables AI assistants to automate iOS Simulator interactions including device management, UI element interaction (tap, swipe, type), screenshot capture, and execution of YAML-defined navigation workflows.

Omega

Persistent memory for AI coding agents

PingOne MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for PingOne (beta): https://www.cdata.com/download/download.aspx?sku=POZK-V&type=beta

Stock Price MCP Server

Provides real-time stock price information from Yahoo Finance API for global markets with multi-currency support, market state tracking, and no rate limits.