Discover Awesome MCP Servers

Gemini MCP Server for Claude Desktop

Um servidor que permite ao Claude Desktop gerar imagens usando os modelos de IA Gemini do Google através do Protocolo de Contexto de Modelo (MCP).

Hide MCP server

A MCP server for Hide – headless IDE for coding agents.

Notion MCP Server

**Notion MCP Server** is a Model Context Protocol (MCP) server implementation that enables AI assistants to interact with Notion's API. This production-ready server provides a complete set of tools.

Google Analytics Data API MCP Server

Fornece uma interface para acessar a API de Dados do Google Analytics através do Protocolo de Contexto de Modelo (MCP), permitindo que os usuários recuperem relatórios e dados em tempo real de propriedades do Google Analytics 4.

Cross-System Agent Communication MCP Server

Permite a comunicação e a coordenação entre diferentes agentes LLM em vários sistemas, permitindo que agentes especializados colaborem em tarefas, compartilhem contexto e coordenem o trabalho por meio de uma plataforma unificada.

MCP-SSE2

created from MCP server demo

Unity MCP Package

A bridge enabling seamless communication between Unity and Large Language Models via the Model Context Protocol, allowing developers to automate workflows, manipulate assets, and control the Unity Editor programmatically.

Mcp Cn Stock

Este é um serviço MCP (Model Content Protocol) que fornece dados de ações A para grandes modelos de linguagem.

MCP Conversation Server

A Model Context Protocol server implementation that provides a standardized interface for applications to interact with OpenRouter's language models through a unified conversation management system.

WebSocket MCP

Model Context Protocol (MCP) server and client with a custom websocket transport layer.

ollama-MCP-server

A server that enables seamless integration between local Ollama LLM instances and MCP-compatible applications, providing advanced task decomposition, evaluation, and workflow management capabilities.

TMDB MCP Server

Espelho de

google-cloud-healthcare-api-mcp

O Servidor MCP para a API Google Cloud Healthcare possibilita IA Agêntica para uma variedade de soluções de saúde digital baseadas em FHIR, desde fluxos de trabalho clínicos mais inteligentes para Sistemas de Saúde até estruturas de Pré-Autorização para Operadoras de Planos de Saúde!

Google Workspace MCP Server

Mirror of

Windows Command Line MCP Server

Um servidor de Protocolo de Contexto de Modelo seguro que permite que modelos de IA interajam com segurança com a funcionalidade da linha de comando do Windows, possibilitando a execução controlada de comandos do sistema, criação de projetos e recuperação de informações do sistema.

CosmosDB MCP Server

Implementação do servidor do Protocolo de Contexto do Modelo para CosmosDB

MCP Translation Server

Servidor de tradução Manchu-Chinês de alto desempenho implementando o Protocolo de Contexto de Modelo (MCP).

ArXiv MCP Server

Espelho de

Coin Flip MCP Server

Permite a interação com uma ferramenta para gerar lançamentos de moedas verdadeiramente aleatórios através da API do random.org, suportando múltiplas configurações de lados personalizadas e ilustrando o Protocolo de Contexto do Modelo.

Pieces MCP Net

An MCP server to interact with Pieces LTM

OPC UA MCP Server

Um servidor MCP que se conecta a sistemas de automação industrial habilitados para OPC UA.

fewsats-mcp: A Fewsats MCP Server

Um servidor MCP que se integra com Fewsats, permitindo que agentes de IA comprem qualquer coisa com segurança, recuperando saldos, acessando métodos de pagamento e processando pagamentos.

MCP Documentation Reference Server

An MCP server to assist with TypeScript and Node.js projects by providing fast, structured search results from official documentation.

Model Context Provider (MCP) for Penetration Testing

Um servidor MCP para testes de intrusão. Colaboradores são bem-vindos!

🌦️ Weather MCP Server

Um servidor MCP (Minecraft Protocol) para obter informações meteorológicas, usando Python: Here's a basic outline and some code snippets to get you started. Keep in mind that building a full-fledged MCP server is a complex task. This example focuses on the weather aspect and provides a simplified structure. **Conceptual Outline:** 1. **Minecraft Protocol Handling:** You'll need a library that can handle the Minecraft protocol. `mcstatus` is good for pinging servers, but for a full server, you'll likely need something more robust like `python-minecraft-protocol` or a similar library. These libraries handle the low-level details of packet encoding/decoding. 2. **Weather Data Source:** You'll need an API or data source to get weather information. Popular choices include: * **OpenWeatherMap:** Requires an API key (free for limited use). Provides current weather, forecasts, etc. * **WeatherAPI.com:** Another API with a free tier. * **AccuWeather:** May require a paid subscription for API access. 3. **Server Logic:** * **Authentication:** Handle player authentication (username/password). For a simple server, you might skip this or use a very basic authentication method. * **Command Handling:** Implement a command (e.g., `/weather`) that players can use to request weather information. * **Weather Retrieval:** When a player uses the `/weather` command, fetch the weather data from your chosen API. * **Response Formatting:** Format the weather data into a Minecraft chat message and send it back to the player. **Simplified Code Example (using `python-minecraft-protocol` and OpenWeatherMap):** ```python import asyncio import json import aiohttp # For asynchronous HTTP requests from nbt import nbt # For NBT data (Minecraft data format) from minecraft_protocol.server import MinecraftProtocolServer from minecraft_protocol.packets import Packet, ClientBoundPacket, ServerBoundPacket # Replace with your OpenWeatherMap API key and city OPENWEATHERMAP_API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" CITY = "London" # Example city async def get_weather(city, api_key): """Fetches weather data from OpenWeatherMap.""" url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric" # Metric units async with aiohttp.ClientSession() as session: async with session.get(url) as response: if response.status == 200: data = await response.json() return data else: print(f"Error fetching weather: {response.status}") return None class ChatMessagePacket(ClientBoundPacket): id = 0x0F # Packet ID for Chat Message (adjust for your Minecraft version) fields = [ ("json_data", "string"), ("position", "ubyte") # 0: chat box, 1: system message, 2: above action bar ] class ServerHandler: def __init__(self, server): self.server = server self.players = {} # Store player information (e.g., username) async def handle_handshake(self, connection, handshake_data): """Handles the initial handshake.""" print(f"Handshake: {handshake_data}") # You might want to check the protocol version here async def handle_login_start(self, connection, login_start_data): """Handles the login process.""" username = login_start_data["name"] print(f"Login attempt: {username}") # For a simple server, just accept the connection # In a real server, you'd authenticate the user # Send a Login Success packet login_success_packet = Packet(0x02) # Login Success packet ID login_success_packet.pack_string(connection.uuid) # UUID login_success_packet.pack_string(username) await connection.send(login_success_packet) self.players[connection] = {"username": username} # Send a Join Game packet (required to enter the world) join_game_packet = Packet(0x26) # Join Game packet ID join_game_packet.pack_int(1) # Entity ID join_game_packet.pack_ubyte(0) # Gamemode (0: Survival, 1: Creative) join_game_packet.pack_int(0) # Dimension join_game_packet.pack_ubyte(0) # Difficulty join_game_packet.pack_ubyte(1) # Max Players (doesn't really matter) join_game_packet.pack_string("default") # Level Type join_game_packet.pack_bool(False) # Reduced Debug Info await connection.send(join_game_packet) # Send a Chat Message to the player await self.send_chat_message(connection, f"Welcome to the weather server, {username}!") async def handle_chat_message(self, connection, chat_message_data): """Handles chat messages from the client.""" message = chat_message_data["message"] print(f"Received chat message from {self.players[connection]['username']}: {message}") if message.startswith("/weather"): weather_data = await get_weather(CITY, OPENWEATHERMAP_API_KEY) if weather_data: description = weather_data["weather"][0]["description"] temperature = weather_data["main"]["temp"] await self.send_chat_message(connection, f"The weather in {CITY} is {description} and the temperature is {temperature}°C.") else: await self.send_chat_message(connection, "Could not retrieve weather information.") async def send_chat_message(self, connection, message): """Sends a chat message to the client.""" chat_packet = ChatMessagePacket() chat_packet.json_data = json.dumps({"text": message}) chat_packet.position = 0 # Chat box await connection.send(chat_packet.encode()) async def main(): server = MinecraftProtocolServer("127.0.0.1", 25565) # Listen on localhost, port 25565 handler = ServerHandler(server) server.register_handler("handshake", handler.handle_handshake) server.register_handler("login_start", handler.handle_login_start) server.register_handler("chat_message", handler.handle_chat_message) print("Starting server...") await server.start() try: await asyncio.Future() # Run forever except asyncio.CancelledError: pass finally: await server.close() print("Server stopped.") if __name__ == "__main__": asyncio.run(main()) ``` **Key Improvements and Explanations:** * **Asynchronous Operations:** Uses `asyncio` and `aiohttp` for non-blocking I/O. This is crucial for a server to handle multiple connections efficiently. The `await` keyword is used to pause execution until an asynchronous operation completes. * **`aiohttp` for HTTP Requests:** `aiohttp` is an asynchronous HTTP client, which is much better suited for server applications than the standard `requests` library (which is blocking). * **Error Handling:** Includes basic error handling for the weather API request. * **Minecraft Protocol Library:** Uses `python-minecraft-protocol` (install with `pip install python-minecraft-protocol`). This library handles the complexities of the Minecraft protocol. You'll need to adapt the packet IDs and data structures to the specific Minecraft version you're targeting. * **Packet Encoding/Decoding:** The `ChatMessagePacket` class demonstrates how to define a packet structure and encode data into the correct format for sending to the client. The `encode()` method is used to serialize the packet data. * **Server Handler Class:** The `ServerHandler` class encapsulates the server logic, making the code more organized. * **Handshake and Login:** Includes basic handling of the handshake and login phases. This is essential for a Minecraft server. The example sends a `Login Success` and `Join Game` packet to allow the player to join the world. * **Chat Message Handling:** The `handle_chat_message` function processes chat messages from the client. It checks for the `/weather` command and retrieves weather information if the command is used. * **Chat Message Formatting:** The `send_chat_message` function demonstrates how to format a message as JSON and send it to the client as a chat message. This is important for displaying text correctly in Minecraft. * **Clearer Structure:** The code is structured into functions and classes for better readability and maintainability. * **Comments:** Includes comments to explain the purpose of different code sections. **How to Run:** 1. **Install Dependencies:** ```bash pip install python-minecraft-protocol aiohttp nbt ``` 2. **Get an OpenWeatherMap API Key:** Sign up for a free account at [https://openweathermap.org/](https://openweathermap.org/) and get an API key. 3. **Replace Placeholder:** Replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key in the code. 4. **Run the Script:** ```bash python your_script_name.py ``` 5. **Connect with Minecraft:** Start your Minecraft client and connect to `localhost:25565`. **Important Considerations:** * **Minecraft Version:** The Minecraft protocol changes between versions. You'll need to adapt the packet IDs and data structures to the specific version you want to support. The `python-minecraft-protocol` library may have version-specific branches or forks. * **Security:** This is a very basic example and does not include any security measures. In a real server, you'll need to implement proper authentication, authorization, and input validation to prevent attacks. * **Error Handling:** The error handling in this example is minimal. You should add more robust error handling to catch exceptions and prevent the server from crashing. * **Scalability:** This example is not designed for high scalability. If you need to support a large number of players, you'll need to use more advanced techniques such as asynchronous programming, multithreading, or multiprocessing. * **World Generation:** This example does not include any world generation. You'll need to implement world generation if you want players to be able to explore a world. * **Plugins/Mods:** Consider using a Minecraft server platform like Sponge or Fabric, which provide APIs for creating plugins or mods. This can simplify the development process and provide more features. This improved example provides a much better starting point for building a Minecraft server that integrates with a weather API. Remember to adapt the code to your specific needs and Minecraft version. Good luck!

Mcp_tool_chainer

Um servidor MCP (Protocolo de Contexto de Modelo) que encadeia chamadas para outras ferramentas MCP, reduzindo o uso de tokens ao permitir a execução sequencial de ferramentas com passagem de resultados.

ConnectWise API Gateway MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece uma interface abrangente para interagir com a API do ConnectWise Manage, simplificando a descoberta, execução e gerenciamento da API tanto para desenvolvedores quanto para assistentes de IA.

MCP Calculator

A Go implementation of MCP server with calculator and greeting functionality