Discover Awesome MCP Servers

Zerodha Trading Bot MCP

An automated trading bot that interfaces with Zerodha to execute stock trades, manage positions, and access market information through natural language commands.

Data Analysis MCP Server

Provides comprehensive statistical analysis tools for industrial data including time series analysis, correlation calculations, stationarity tests, outlier detection, causal analysis, and forecasting capabilities. Enables data quality assessment and statistical modeling through a FastAPI-based MCP architecture.

MCP Ctl

Un administrador de paquetes para gestionar todos tus servidores MCP en todas las plataformas.

Gemini CLI MCP Server

A Windows-compatible Model Context Protocol server that enables AI assistants to interact with Google's Gemini CLI, supporting file analysis, large context windows, and safe code execution.

Cloudflare Playwright MCP

A Model Control Protocol server that enables AI assistants to control a browser through tools for web automation tasks like navigation, typing, clicking, and taking screenshots.

MCPMC (Minecraft MCP)

Permite que agentes de IA controlen bots de Minecraft a través de una interfaz JSON-RPC estandarizada.

mcp-server-hcp-terraform

Servidor MCP para trabajar con HCP Terraform

Gremlin MCP Service

Enables interaction with Gremlin's reliability management APIs to monitor service dependencies, run reliability experiments, generate reliability reports, and manage chaos engineering tests through natural language queries.

Jina Free MCP

A Managed Component Provider that enables fetching webpage content using Jina AI's reader service.

Basic MCP Server

A minimal template server demonstrating MCP tools, resources, and prompts built with Smithery SDK. Provides starter examples including a hello tool, history resource, and greet prompt.

MCP PIF

Este servidor implementa el Protocolo de Contexto del Modelo para facilitar una interacción significativa y el desarrollo de la comprensión entre humanos e IA a través de herramientas estructuradas y patrones de interacción progresivos.

Test MCP

Servidor MCP sencillo para fines de prueba.

Get My Notion MCP Server

Provides access to a specific GitHub repository (my-notion) allowing AI assistants to browse files, read content, and track commit information. Enables real-time interaction with repository data through the GitHub API without authentication requirements.

Productboard Integration

Integra la API de Productboard en flujos de trabajo agenticos, permitiendo la interacción con empresas, componentes, funcionalidades, notas y productos desde la plataforma Productboard.

Cocos MCP Log Bridge

Una potente herramienta de puente de registro que sincroniza la información de registro entre el editor de Cocos Creator y Cursor AI, ayudando a los desarrolladores a analizar y resolver problemas de manera más efectiva.

Pearch

Best people search engine that reduces the time spent on talent discovery

selenium-mcp

Un servidor MCP para Selenium

Lightning Network MCP Server

Espejo de

Medical MCP Server

Provides comprehensive medical information by querying authoritative sources including FDA drug database, WHO health statistics, PubMed literature, RxNorm nomenclature, Google Scholar, and Australia's PBS API through 22+ specialized tools.

mcp-server-bash

Servidor MCP minimalista escrito en un script de bash.

Alpaca MCP Server

MCP server that exposes Alpaca Market Data & Broker API as tools, enabling access to financial data like stock bars, assets, market days, and news through the Message Control Protocol.

Hardware MCP Server

Enables language models to perform hardware engineering tasks including CAD part design and heat transfer simulations. Provides tool calls for building mechanical components and running thermal analysis through natural language interactions.

mcpmonorepo

Banco de pruebas para servidores MCP en un repositorio Mono.

Self-hosted AI starter kit (by the n8n team)

Okay, here's a translation of "pydantic agent workflow using mcp servers to test out advanced retrieval of linked data" into Spanish, along with some options to capture the nuance depending on the context: **Option 1 (Most Direct):** * **Flujo de trabajo de agente Pydantic utilizando servidores MCP para probar la recuperación avanzada de datos enlazados.** **Option 2 (Slightly More Explanatory):** * **Flujo de trabajo de agente Pydantic que emplea servidores MCP para experimentar con la recuperación avanzada de datos vinculados.** **Option 3 (Focus on Experimentation):** * **Flujo de trabajo de agente Pydantic con servidores MCP para la experimentación con la recuperación avanzada de datos enlazados.** **Explanation of Choices:** * **"Pydantic agent workflow"**: "Flujo de trabajo de agente Pydantic" is a direct and generally accepted translation. * **"using mcp servers"**: "utilizando servidores MCP" is a direct translation. "que emplea servidores MCP" or "con servidores MCP" are alternatives that might sound slightly more natural in some contexts. * **"to test out"**: This is where the nuance comes in. * "para probar" is the most direct translation of "to test". * "para experimentar con" emphasizes the experimental nature of the testing. * **"advanced retrieval of linked data"**: "recuperación avanzada de datos enlazados" or "recuperación avanzada de datos vinculados" are both acceptable. "Enlazados" and "vinculados" both mean "linked". "Avanzada" means "advanced". **Which option to choose depends on the specific context:** * If you're writing technical documentation, **Option 1** is likely the best choice because it's the most direct and concise. * If you want to emphasize the experimental nature of the work, **Option 2 or 3** might be better. I hope this helps! Let me know if you have any other questions.

Multi MCP Server

Multi MCP Server

iSendPro SMS API Server

MCP Server that enables natural language interaction with iSendPro's SMS messaging platform, allowing users to send and manage SMS communications through conversational commands.

Add API key to .env file

Okay, here's a basic implementation of a simplified MCP (Master-Client-Process) system in Python, including a client and multiple servers. This is a conceptual example and lacks robust error handling, security, and advanced features. It's designed to illustrate the core principles. **Important Considerations:** * **Security:** This code is for demonstration purposes only. Do *not* use it in a production environment without adding proper security measures (authentication, encryption, etc.). * **Error Handling:** The error handling is minimal. A real-world system would need much more robust error handling. * **Scalability:** This is a very basic implementation and won't scale well to a large number of clients or servers. Consider using more advanced technologies like message queues (e.g., RabbitMQ, Kafka) for scalability. * **Threading/Asynchronous:** This example uses basic threading. For more efficient handling of multiple clients, consider using asynchronous programming (e.g., `asyncio`). **Code:** **1. Server (mcp_server.py):** ```python import socket import threading import time SERVER_HOST = '127.0.0.1' # Loopback address SERVER_PORT = 12345 # Choose a port MAX_CONNECTIONS = 5 def handle_client(client_socket, client_address): """Handles communication with a single client.""" print(f"Connection from {client_address}") try: while True: data = client_socket.recv(1024).decode('utf-8') if not data: break # Client disconnected print(f"Received from {client_address}: {data}") # Process the data (very simple example) response = f"Server received: {data.upper()}" client_socket.send(response.encode('utf-8')) except Exception as e: print(f"Error handling client {client_address}: {e}") finally: print(f"Connection closed with {client_address}") client_socket.close() def start_server(): """Starts the server and listens for incoming connections.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((SERVER_HOST, SERVER_PORT)) server_socket.listen(MAX_CONNECTIONS) print(f"Server listening on {SERVER_HOST}:{SERVER_PORT}") try: while True: client_socket, client_address = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address)) client_thread.start() except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **2. Client (mcp_client.py):** ```python import socket SERVER_HOST = '127.0.0.1' SERVER_PORT = 12345 def run_client(): """Connects to the server and sends/receives data.""" client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((SERVER_HOST, SERVER_PORT)) print(f"Connected to server at {SERVER_HOST}:{SERVER_PORT}") while True: message = input("Enter message to send (or 'exit'): ") if message.lower() == 'exit': break client_socket.send(message.encode('utf-8')) response = client_socket.recv(1024).decode('utf-8') print(f"Received from server: {response}") except Exception as e: print(f"Error: {e}") finally: print("Closing connection.") client_socket.close() if __name__ == "__main__": run_client() ``` **How to Run:** 1. **Save the code:** Save the server code as `mcp_server.py` and the client code as `mcp_client.py`. 2. **Start the server:** Open a terminal or command prompt and run `python mcp_server.py`. The server will start listening for connections. 3. **Start the client(s):** Open one or more other terminals/command prompts and run `python mcp_client.py` in each. Each client will connect to the server. 4. **Interact:** In each client terminal, type a message and press Enter. The message will be sent to the server, processed (in this simple example, converted to uppercase), and the response will be displayed in the client terminal. 5. **Exit:** Type `exit` in a client terminal to disconnect that client. Press Ctrl+C in the server terminal to shut down the server. **Explanation:** * **Server (mcp_server.py):** * Creates a socket and binds it to a specific IP address and port. * Listens for incoming connections using `server_socket.listen()`. * When a client connects (`server_socket.accept()`), it creates a new thread to handle the client's communication. This allows the server to handle multiple clients concurrently. * The `handle_client()` function receives data from the client, processes it (in this example, it just converts the message to uppercase), and sends a response back to the client. * The server continues to listen for new connections until it's interrupted (e.g., by pressing Ctrl+C). * **Client (mcp_client.py):** * Creates a socket and connects to the server's IP address and port. * Prompts the user to enter a message. * Sends the message to the server using `client_socket.send()`. * Receives the response from the server using `client_socket.recv()`. * Prints the response to the console. * The client continues to send and receive messages until the user enters "exit". **Key Concepts:** * **Sockets:** Sockets are the fundamental building blocks for network communication. They provide an endpoint for sending and receiving data. * **TCP (SOCK_STREAM):** TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It's suitable for applications that require guaranteed delivery, such as file transfer and web browsing. * **Threading:** Threading allows the server to handle multiple clients concurrently. Each client connection is handled in a separate thread. * **Encoding/Decoding:** Data is sent over the network as bytes. The `encode()` and `decode()` methods are used to convert strings to bytes and vice versa. UTF-8 is a common encoding that supports a wide range of characters. **Improvements and Extensions:** * **Error Handling:** Add more comprehensive error handling to catch exceptions and handle them gracefully. * **Security:** Implement authentication and encryption to protect the data being transmitted. Consider using TLS/SSL. * **Message Format:** Define a more structured message format (e.g., JSON, Protocol Buffers) to allow for more complex data to be exchanged. * **Asynchronous Programming:** Use `asyncio` for more efficient handling of multiple clients, especially if the server needs to handle a large number of concurrent connections. * **Master/Worker Pattern:** Implement a true master/worker pattern where the master server distributes tasks to worker servers. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Kafka) to decouple the client and server and improve scalability and reliability. * **Configuration:** Use a configuration file to store server settings (e.g., IP address, port). * **Logging:** Implement logging to record server events and errors. This provides a basic foundation for understanding how an MCP system can be implemented in Python. Remember to adapt and extend this code to meet the specific requirements of your application.

sushimcp

sushimcp

⚡️ mcpo

Un servidor proxy MCP a OpenAPI sencillo y seguro.