Discover Awesome MCP Servers

Spring AI MCP Batch Job Server

Um servidor Spring Boot Model Context Protocol (MCP) que fornece ferramentas de processamento em lote para transações financeiras.

Pipedream MCP Server

Enables interaction with over 2,800 APIs and applications through Pipedream's Connect platform. Provides managed OAuth authentication and API request capabilities for integrating multiple services through natural language.

Vercel MCP Python Server

A serverless MCP server deployed on Vercel that provides basic utility tools including echo, time retrieval, arithmetic operations, and mock weather information. Includes an interactive client application for testing and demonstration purposes.

Mcp Server

Here's an example of a simple MCP (Minecraft Protocol) server written in Python, designed to be easily understood and potentially adapted for use with Claude. This is a *very* basic example and doesn't implement the full Minecraft protocol. It's intended to illustrate the core concepts of listening for connections and sending/receiving data. ```python import socket import struct import json # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Standard Minecraft port # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a variable-length integer from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = ord(byte) result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a variable-length integer to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def read_string(sock): """Reads a string from the socket, prefixed by a varint length.""" length = read_varint(sock) if length is None: return None # Connection closed data = sock.recv(length) try: return data.decode('utf-8') except UnicodeDecodeError: return None # Invalid string def write_string(sock, string): """Writes a string to the socket, prefixed by a varint length.""" encoded_string = string.encode('utf-8') write_varint(sock, len(encoded_string)) sock.send(encoded_string) def send_packet(sock, packet_id, data): """Sends a packet with a given ID and data.""" packet = struct.pack(">b", packet_id) + data write_varint(sock, len(packet)) sock.send(packet) # --- Server Logic --- def handle_handshake(sock): """Handles the initial handshake packet.""" protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Unpack as big-endian unsigned short next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, State {next_state}") return next_state def handle_status_request(sock): """Handles the status request and sends a response.""" # Receive empty status request packet (ID 0x00) packet_id = read_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID in status request: {packet_id}") return # Craft a simple status response status = { "version": { "name": "My Claude Server", "protocol": 763 # Example protocol version }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A server powered by Claude (sort of)!" } } status_json = json.dumps(status) print(f"Sending status: {status_json}") # Send status response packet (ID 0x00) write_string(sock, status_json) send_packet(sock, 0x00, b"") # Ping response (empty packet) def handle_login_start(sock): """Handles the login start packet (player name).""" player_name = read_string(sock) print(f"Login attempt from: {player_name}") # For simplicity, we'll just accept the connection. In a real server, # you'd handle authentication, UUID generation, etc. # Send Login Success packet (ID 0x02) uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID send_packet(sock, 0x02, write_string(sock, uuid).encode('utf-8') + write_string(sock, player_name).encode('utf-8')) # Send Join Game packet (ID 0x26) - Minimal data for joining entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 20 level_type = "default" reduced_debug_info = False enable_respawn_screen = True join_game_data = struct.pack(">iBbql", entity_id, gamemode, dimension, hashed_seed, max_players) + \ write_string(sock, level_type).encode('utf-8') + \ struct.pack("?b", reduced_debug_info, enable_respawn_screen) send_packet(sock, 0x26, join_game_data) # Send Player Position & Rotation packet (ID 0x36) x, y, z = 0.0, 64.0, 0.0 yaw, pitch = 0.0, 0.0 flags = 0x00 # No flags set teleport_id = 0 position_data = struct.pack(">dddbbi", x, y, z, yaw, pitch, flags, teleport_id) send_packet(sock, 0x36, position_data) # Send Clientbound Plugin Message (ID 0x18) - Required for some clients channel = "minecraft:brand" brand = "vanilla" plugin_message_data = write_string(sock, channel).encode('utf-8') + write_string(sock, brand).encode('utf-8') send_packet(sock, 0x18, plugin_message_data) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: # Handshake next_state = handle_handshake(conn) if next_state == 1: # Status handle_status_request(conn) elif next_state == 2: # Login handle_login_start(conn) # After login, you'd enter the game loop and handle player input. # This example doesn't implement that. else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # --- Main Server Loop --- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions for each stage of the Minecraft protocol (handshake, status, login). This makes it much easier to understand and extend. * **VarInt Handling:** Correctly implements reading and writing variable-length integers (VarInts), which are crucial for the Minecraft protocol. The `read_varint` function now handles connection closed gracefully. * **String Handling:** Includes functions for reading and writing strings, prefixed by their length as a VarInt. Handles potential `UnicodeDecodeError`. * **Status Response:** Crafts a valid JSON status response that a Minecraft client can understand. Includes version, player count, and description. * **Login Handling:** Handles the `Login Start` packet and sends a `Login Success` packet. **Important:** This is a *very* simplified login. A real server would need to handle authentication and UUID generation. * **Join Game Packet:** Sends a minimal `Join Game` packet, which is necessary for the client to actually enter the game world. Includes entity ID, gamemode, dimension, etc. * **Player Position Packet:** Sends a `Player Position & Rotation` packet to set the player's initial position in the world. * **Clientbound Plugin Message:** Sends a `Clientbound Plugin Message` with the "minecraft:brand" channel. Some clients require this. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors during client handling. * **Comments:** Extensive comments explain each step of the process. * **`SO_REUSEADDR`:** Sets the `SO_REUSEADDR` socket option to allow the server to be restarted quickly without waiting for the port to be released. * **Correct Unpacking:** Uses `struct.unpack(">H", ...)` to correctly unpack the port number from the handshake packet as a big-endian unsigned short. * **UTF-8 Encoding:** Explicitly encodes strings to UTF-8 before sending them. * **Packet Sending Helper:** The `send_packet` function simplifies sending packets by handling the VarInt length prefix. * **Minimal Dependencies:** Only uses the standard `socket`, `struct`, and `json` libraries. * **Connection Closed Handling:** `read_varint` now returns `None` if the connection is closed, allowing the server to handle it gracefully. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` 3. **Connect:** In your Minecraft client, add a new server with the address `127.0.0.1` and port `25565`. **Important:** You may need to disable client-side authentication or use a development client that allows connecting to servers without proper authentication. This server *does not* implement authentication. You will likely need to set "online-mode=false" in your client's `server.properties` file (if applicable) or use a cracked/offline client. 4. **Observe:** Watch the server's output in the terminal to see the handshake, status request, and login information. **Important Considerations for Claude Integration:** * **Claude's Role:** Think about what you want Claude to *do* with the Minecraft server. Some possibilities: * **AI-Controlled Entities:** Use Claude to control the behavior of non-player characters (NPCs) in the game. You'd need to extend the server to handle entity movement, AI logic, and communication with Claude. * **World Generation:** Use Claude to generate interesting terrain or structures. You'd need to modify the server to send the appropriate chunk data to the client. * **Chatbot:** Use Claude to create a more intelligent chatbot that can interact with players in the game. You'd need to handle chat messages and send responses back to the client. * **Game Logic:** Use Claude to dynamically adjust game rules or events based on player actions. * **Communication:** You'll need a way for the Python server to communicate with Claude. This could involve: * **API Calls:** The server can make API calls to Claude's API to get responses or instructions. This is the most common approach. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Redis) to asynchronously send data between the server and Claude. * **Shared Memory:** (Less common) Use shared memory to allow the server and Claude to directly access the same data. * **Protocol Complexity:** The Minecraft protocol is complex. This example only implements a small subset of it. You'll likely need to use a more complete Minecraft library or implement more of the protocol yourself to achieve your desired functionality. Consider libraries like `mcproto` or `python-minecraft-protocol`. * **Security:** If you're exposing your server to the internet, be very careful about security. The Minecraft protocol has known vulnerabilities. Implement proper authentication and input validation to prevent attacks. **Example: Claude as a Chatbot (Conceptual)** 1. **Receive Chat Message:** Extend the server to receive chat messages from the client. This involves parsing the appropriate Minecraft packet. 2. **Send to Claude:** Send the chat message to Claude's API. You might include additional context, such as the player's name, location, and current game state. 3. **Receive Response:** Receive a response from Claude. 4. **Send Chat Message:** Send a chat message back to the client (or to all clients) with Claude's response. **Portuguese Translation of Key Concepts:** * **MCP (Minecraft Protocol):** Protocolo Minecraft * **Server:** Servidor * **Client:** Cliente * **Handshake:** Handshake (aperto de mão inicial, negociação) * **Status:** Status (estado) * **Login:** Login (autenticação) * **Packet:** Pacote (dados enviados pela rede) * **VarInt (Variable-length Integer):** Inteiro de Comprimento Variável * **JSON:** JSON (formato de dados) * **API (Application Programming Interface):** API (Interface de Programação de Aplicações) * **Message Queue:** Fila de Mensagens * **Shared Memory:** Memória Compartilhada * **Entity:** Entidade (personagem, objeto no jogo) * **Chunk:** Chunk (pedaço do mundo do Minecraft) * **Authentication:** Autenticação * **UUID (Universally Unique Identifier):** UUID (Identificador Único Universal) This comprehensive example and explanation should give you a solid foundation for building a Minecraft server that integrates with Claude. Remember to start small, test frequently, and focus on one specific goal at a time. Good luck!

MCP Server with OpenAI Integration

Production-ready MCP server that integrates OpenAI API with extensible tool support, enabling dynamic plugin loading and knowledge search capabilities through multiple interfaces including CLI and browser UI.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

KubeBlocks Cloud MCP Server

MCP server for KubeBlocks Cloud

Twilio MCP Server by CData

This read-only MCP Server allows you to connect to Twilio data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Stimulus Docs MCP Server

An MCP server that provides access to up-to-date Stimulus JS documentation directly within Claude conversations and VS Code.

Actor-Critic Thinking MCP Server

Provides dual-perspective analysis through alternating actor (creator/performer) and critic (analyzer/evaluator) viewpoints, generating comprehensive performance evaluations with balanced, actionable feedback.

MCP 学习项目⚡

Aprendizagem individual de MCP

context-portal

context-portal

🎯 Kubernetes AI Management System

Sistema de Gerenciamento Kubernetes Alimentado por IA: Uma plataforma que combina processamento de linguagem natural com gerenciamento Kubernetes. Usuários podem realizar diagnósticos em tempo real, monitoramento de recursos e análise inteligente de logs. Simplifica o gerenciamento Kubernetes através de IA conversacional, fornecendo uma alternativa moderna.

arduino-mcp-server

Um servidor Arduino MCP escrito em Go.

SSH Read-Only MCP Server

Enables secure remote SSH command execution with strict read-only enforcement, allowing safe delegation of SSH access to Claude while preventing write operations. Supports connection pooling, command validation, and comprehensive logging for audit trails.

Security Infrastructure MCP Server

A comprehensive implementation of Model Context Protocol servers enabling natural language interactions with security platforms including Splunk SIEM, CrowdStrike EDR, and Microsoft MISP for threat intelligence querying and analysis.

GDB MCP Server

Um servidor MCP para depuração GDB.

MCP Calculator

A protocol interface that extends AI capabilities by enabling models to interact with external systems for calculations, email operations, knowledge search, and more.

Vault Mcp Server

Repositório do Servidor MCP para Vault no Hackathon da YZi Labs

MIDI Analyzer MCP Server

Enables comprehensive analysis of MIDI SMF files including loading, parsing, track analysis, event extraction with filtering, and detailed file summaries. Supports memory management for efficient repeated access to loaded MIDI files.

Sequential Thinking MVP Server

Enables AI assistants to perform structured, step-by-step reasoning by breaking down complex problems into numbered thoughts, with support for revising previous steps and exploring alternative reasoning paths.

ShipStation 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 ShipStation (beta): https://www.cdata.com/download/download.aspx?sku=HSZK-V&type=beta

Appointment Manager MCP Server

Enables users to manage appointments through a FastAPI backend with PostgreSQL database. Supports creating, listing, updating, and deleting appointments via natural language interactions through Claude.

MCP Serverless Functions Example

A basic example of developing and running serverless Model Context Protocol (MCP) using Netlify Functions, demonstrating how to deploy and access serverless functions with customized URLs.

MCP-Blender

Enables Claude AI to directly interact with and control Blender for rapid, natural language-based 3D modeling. Supports parametric design and relational design through direct Blender integration.

FM8 MCP Server

Enables AI assistants to control Native Instruments FM8 synthesizer parameters through MIDI CC messages, allowing natural language programming of FM synthesis sounds including operator routing, frequency ratios, and modulation matrix settings.

Math Agent with Microsoft Word and Gmail Integration

Servidor MCP para Agente de Matemática com Integração com Microsoft Word e Gmail

Spider MCP

Enables web searching and webpage scraping using pure crawler technology without requiring official APIs. Supports Bing web and news search, batch webpage scraping, and content extraction through Puppeteer automation.

Anki MCP Server

Espelho de