Discover Awesome MCP Servers

Pieces MCP Net

An MCP server to interact with Pieces LTM

MCP Server 项目

mcp-server

WORK IN PROGRESS - USE WITH CAUTION - Windows:

Aqui está uma tradução para português da sua solicitação, com algumas opções para maior clareza e naturalidade: **Opção 1 (Mais direta):** mcp usando PyPDF2 para: * unir PDFs * extrair páginas * pesquisar PDFs * unir PDFs em ordem (unir na ordem especificada pelo usuário) * encontrar PDFs relacionados (texto extraído por regex para encontrar arquivos PDF relacionados) **Opção 2 (Com mais detalhes, se necessário):** Implementação de um script (mcp) utilizando a biblioteca PyPDF2 para realizar as seguintes tarefas: * Mesclar arquivos PDF. * Extrair páginas específicas de arquivos PDF. * Realizar buscas textuais dentro de arquivos PDF. * Mesclar arquivos PDF em uma ordem definida pelo usuário. * Identificar arquivos PDF relacionados, utilizando expressões regulares (regex) para extrair texto relevante e buscar por arquivos com conteúdo similar. **Opção 3 (Mais focada na funcionalidade):** Desenvolver um script (mcp) com PyPDF2 para: * Mesclar múltiplos arquivos PDF em um único arquivo. * Extrair páginas individuais de um arquivo PDF. * Permitir a busca por texto dentro de arquivos PDF. * Mesclar arquivos PDF em uma ordem personalizada, definida pelo usuário. * Identificar arquivos PDF relacionados através da extração de texto com expressões regulares (regex) e comparação de conteúdo. **Explicação das escolhas:** * **mcp:** Mantive "mcp" como está, presumindo que seja um nome de script ou projeto específico. Se for outra coisa, me diga para que eu possa traduzir adequadamente. * **merge-pdfs:** Traduzi como "unir PDFs" ou "mesclar arquivos PDF". Ambos são comuns e compreensíveis. * **extract-pages:** Traduzi como "extrair páginas" ou "extrair páginas específicas de arquivos PDF". * **search-pdfs:** Traduzi como "pesquisar PDFs" ou "realizar buscas textuais dentro de arquivos PDF". * **merge-pdfs-ordered:** Traduzi como "unir PDFs em ordem" ou "mesclar arquivos PDF em uma ordem definida pelo usuário". A adição "especificada pelo usuário" ou "definida pelo usuário" deixa mais claro que a ordem não é arbitrária. * **find-related-pdfs:** Traduzi como "encontrar PDFs relacionados" ou "Identificar arquivos PDF relacionados". Adicionei a explicação de que o texto é extraído por regex para maior clareza. Escolha a opção que melhor se adapta ao contexto e à sua necessidade de detalhe.

MCP Calculator

A Go implementation of MCP server with calculator and greeting functionality

Getting Started with Create React App

这是一个测试mcp server的仓库

Social Media MCP Server

Conecta-se a múltiplas plataformas de mídia social (Twitter/X, Mastodon, LinkedIn), permitindo que os usuários criem e publiquem conteúdo em diversas plataformas através de instruções em linguagem natural.

MCP Server Box

Um servidor Python que permite a interação com arquivos e pastas do Box através da API do Box, possibilitando operações como busca de arquivos, extração de texto e consulta e extração de dados baseadas em IA.

PowerPlatform MCP

Um servidor de Protocolo de Contexto de Modelo (MCP) que fornece acesso inteligente a entidades e registros do PowerPlatform/Dataverse. Esta ferramenta oferece assistência contextualizada, exploração de entidades e acesso a metadados.

privateGPT MCP Server

Espelho de

Model Context Provider (MCP) for Penetration Testing

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

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.

python_local MCP Server

Forneço um ambiente REPL Python interativo que mantém o estado da sessão persistente, permitindo que os usuários executem código Python e acessem o histórico da sessão.

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.

Twilio Agent Payments MCP Server

Um servidor MCP que permite o processamento de pagamentos seguro e em conformidade com PCI durante chamadas de voz via API Twilio, fornecendo callbacks assíncronos e fluxo de trabalho guiado para pagamentos assistidos por agentes.

Perplexity MCP Server

Mirror of

Jira MCP Server

Mirror of

n8n Workflow Builder MCP Server

MCP server for Claude / Cursor building n8n workflow

PyMOL-MCP

Conecta o PyMOL ao Claude AI através do Protocolo de Contexto do Modelo, permitindo biologia estrutural conversacional e visualização molecular através de comandos em linguagem natural.

MCP Crew AI Server

Um servidor leve baseado em Python, projetado para executar, gerenciar e criar fluxos de trabalho CrewAI, utilizando o Protocolo de Contexto de Modelo para comunicação com LLMs e ferramentas como Claude Desktop ou Cursor IDE.

Phabricator MCP Server

Mirror of

RabbitMQ MCP Server

Espelho de

BigQuery MCP server

Espelho de

Elasticsearch MCP Server

Conecta Claude e outros clientes MCP aos dados do Elasticsearch, permitindo que os usuários interajam com seus índices do Elasticsearch por meio de conversas em linguagem natural.

6digit studio MCP integration

General purpose MCP-server for 6digit studio

QASE MCP Server

Um servidor MCP baseado em TypeScript que fornece integração com a plataforma de gerenciamento de testes Qase, permitindo que você gerencie projetos, casos de teste, execuções, resultados, planos, suítes e passos compartilhados.

Smithery.ai Integration for Unity AI MCP Server

A clean implementation of Smithery.ai integration for Unity AI MCP Server

🌦️ 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!

microCMS MCP Server

Um servidor compatível com o Protocolo de Contexto de Modelo (MCP) que permite que Modelos de Linguagem Grandes (LLMs) pesquisem e recuperem conteúdo de APIs microCMS.