Discover Awesome MCP Servers

MCP Demo Server

A minimal fastmcp demonstration server that provides a simple addition tool through the MCP protocol, supporting deployment via Docker with multiple transport modes.

Applitools MCP Server

Enables AI assistants to set up, manage, and analyze visual tests using Applitools Eyes within Playwright JavaScript and TypeScript projects. It supports adding visual checkpoints, configuring cross-browser testing via Ultrafast Grid, and retrieving structured test results.

SwiftOpenAI MCP Server

A universal server that enables MCP-compatible clients (like Claude Desktop, Cursor, VS Code) to access OpenAI's APIs for chat completions, image generation, embeddings, and model listing through a standardized interface.

Somnia MCP Server

Enables AI agents to interact with the Somnia blockchain network, including documentation search, blockchain queries, wallet management, cryptographic signing, and on-chain operations.

PPTX Generator MCP Server

Generates professional PowerPoint presentations from Markdown with support for code blocks, tables, custom branding, and mixed formatting. Transforms lesson plans and documentation into styled PPTX files with syntax highlighting and customizable themes.

Cars MCP Server

Okay, here's a basic example of how you might set up a simple Minecraft Protocol (MCP) server using Spring AI. This is a conceptual outline and requires significant further development to be a fully functional server. It focuses on integrating Spring AI for potential AI-driven features within the server. **Important Considerations:** * **MCP Protocol Complexity:** The Minecraft protocol is complex. This example simplifies it drastically. Building a real server requires deep understanding of the protocol and handling many packet types. * **Spring AI's Role:** Spring AI is used here to *potentially* add AI-driven features. The core server functionality is separate. The example shows how you *could* integrate AI for things like responding to player commands or generating content. * **Incomplete Example:** This is a *very* basic starting point. It lacks error handling, proper packet parsing, world management, player management, and many other essential features. * **Libraries:** You'll need to add dependencies to your `pom.xml` or `build.gradle` for Spring Boot, Spring AI, and potentially a networking library like Netty (although this example uses basic Java sockets for simplicity). **Conceptual Code Example (Java with Spring Boot and Spring AI):** ```java // pom.xml (or build.gradle) - Add these dependencies // <dependency> // <groupId>org.springframework.boot</groupId> // <artifactId>spring-boot-starter-web</artifactId> // </dependency> // <dependency> // <groupId>org.springframework.ai</groupId> // <artifactId>spring-ai-openai</artifactId> // Or another AI provider // <version>0.8.0</version> // Check for the latest version // </dependency> // <dependency> // <groupId>org.springframework.boot</groupId> // <artifactId>spring-boot-starter-test</artifactId> // <scope>test</scope> // </dependency> import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @SpringBootApplication public class MinecraftServerApplication { public static void main(String[] args) { SpringApplication.run(MinecraftServerApplication.class, args); } } @Component class MinecraftServer { private static final int PORT = 25565; // Default Minecraft port private final ExecutorService executorService = Executors.newFixedThreadPool(10); // Thread pool for handling clients @Autowired private AiClient aiClient; // Inject Spring AI client @PostConstruct public void startServer() { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("Minecraft server started on port " + PORT); while (true) { Socket clientSocket = serverSocket.accept(); System.out.println("New client connected: " + clientSocket.getInetAddress()); executorService.submit(new ClientHandler(clientSocket, aiClient)); // Pass AI client to handler } } catch (IOException e) { System.err.println("Server exception: " + e.getMessage()); e.printStackTrace(); } } static class ClientHandler implements Runnable { private final Socket clientSocket; private final AiClient aiClient; public ClientHandler(Socket socket, AiClient aiClient) { this.clientSocket = socket; this.aiClient = aiClient; } @Override public void run() { try (DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream())) { // **VERY BASIC** handshake (simplified) int packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); if (packetId == 0x00) { // Example: Handshake packet ID // Read handshake data (protocol version, server address, port, next state) int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = in.readUnsignedByte(); System.out.println("Handshake: Protocol " + protocolVersion + ", Address " + serverAddress + ", Port " + serverPort + ", Next State " + nextState); if (nextState == 1) { // Status request // Respond with server status (simplified) String statusJson = "{\"version\": {\"name\": \"My Server\", \"protocol\": " + protocolVersion + "}, \"players\": {\"max\": 10, \"online\": 0}, \"description\": {\"text\": \"A simple server\"}}"; sendString(out, statusJson); // Read ping packet and respond (simplified) packetId = in.readUnsignedByte(); if (packetId == 0x01) { long pingPayload = in.readLong(); sendLong(out, pingPayload); } } else if (nextState == 2) { // Login request // Handle login (simplified) String playerName = readString(in); System.out.println("Player " + playerName + " is trying to log in."); // **AI Integration Example:** Use AI to generate a welcome message PromptTemplate promptTemplate = new PromptTemplate("Generate a welcome message for player {playerName} joining the server."); promptTemplate.add("playerName", playerName); String aiWelcomeMessage = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Welcome Message: " + aiWelcomeMessage); // Send login success (simplified) sendLoginSuccess(out, playerName); // Send a chat message (simplified) - including the AI message sendChatMessage(out, "Server: Welcome, " + playerName + "! " + aiWelcomeMessage); // Start game logic (simplified) - send join game packet, etc. sendJoinGame(out); } } // Keep the connection alive and handle further packets (simplified) while (clientSocket.isConnected()) { try { packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); // Example: Handle chat message (0x03) if (packetId == 0x03) { String chatMessage = readString(in); System.out.println("Received chat message: " + chatMessage); // **AI Integration Example:** Use AI to respond to the chat message PromptTemplate promptTemplate = new PromptTemplate("Respond to the following chat message: {chatMessage}"); promptTemplate.add("chatMessage", chatMessage); String aiResponse = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Response: " + aiResponse); sendChatMessage(out, "Server (AI): " + aiResponse); } // Add more packet handling logic here... } catch (IOException e) { // Client disconnected System.out.println("Client disconnected: " + clientSocket.getInetAddress()); break; } } } catch (IOException e) { System.err.println("Client handler exception: " + e.getMessage()); e.printStackTrace(); } finally { try { clientSocket.close(); } catch (IOException e) { System.err.println("Error closing socket: " + e.getMessage()); } } } // Helper methods for reading and writing data (VarInt, String, etc.) - See below private int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } private String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes); } private void sendString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes("UTF-8"); writeVarInt(out, bytes.length); out.write(bytes); } private void sendLong(DataOutputStream out, long l) throws IOException { out.writeByte(0x01); // Packet ID out.writeLong(l); out.flush(); } private void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } else { out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } } private void sendChatMessage(DataOutputStream out, String message) throws IOException { out.writeByte(0x0F); // Chat Message packet ID sendString(out, "{\"text\":\"" + message + "\"}"); // JSON formatted chat message out.writeByte(0x00); // Position (0: chat box, 1: system message, 2: game info) out.writeByte(0x00); // Sender UUID (not used in this example) out.flush(); } private void sendLoginSuccess(DataOutputStream out, String playerName) throws IOException { out.writeByte(0x02); // Login Success packet ID sendString(out, "00000000-0000-0000-0000-000000000000"); // UUID (dummy) sendString(out, playerName); writeVarInt(out, 0); // Number of properties (none in this example) out.flush(); } private void sendJoinGame(DataOutputStream out) throws IOException { out.writeByte(0x26); // Join Game packet ID out.writeInt(0); // Entity ID out.writeByte(0); // Gamemode (Survival) out.writeByte(0); // Dimension (Overworld) out.writeByte(1); // Hashed seed out.writeByte(0); // Max Players sendString(out, "minecraft:overworld"); // Level Type writeVarInt(out, 32); // View Distance writeVarInt(out, 32); // Simulation Distance out.writeByte(0); // Reduced Debug Info out.writeByte(0); // Enable respawn screen out.writeByte(0); // Is hardcore out.writeByte(0); // Is flat out.flush(); } } } ``` **Explanation and Key Points:** 1. **Dependencies:** Make sure you have the necessary Spring Boot, Spring AI, and potentially other dependencies (like Netty for more robust networking) in your `pom.xml` or `build.gradle`. The example shows the Spring AI OpenAI starter. You'll need an OpenAI API key configured in your `application.properties` or `application.yml` file. 2. **`MinecraftServerApplication`:** A standard Spring Boot application entry point. 3. **`MinecraftServer`:** * `@Component`: Makes this a Spring-managed bean. * `@Autowired AiClient`: Injects the Spring AI client. This is how you access the AI functionality. * `@PostConstruct`: Ensures that `startServer()` is called after the Spring context is initialized. * `ServerSocket`: Listens for incoming connections on port 25565 (the default Minecraft port). * `ExecutorService`: A thread pool to handle multiple client connections concurrently. * `ClientHandler`: A `Runnable` that handles the communication with a single client. 4. **`ClientHandler`:** * `Socket`: Represents the connection to a Minecraft client. * `DataInputStream` and `DataOutputStream`: Used for reading and writing data to the client socket. Minecraft uses a binary protocol. * **Handshake (Simplified):** The code attempts to handle the initial handshake packet (ID 0x00). This is *highly* simplified. A real server needs to handle the handshake correctly to determine the client's protocol version and intended state (status or login). * **Status Request (Simplified):** If the client requests the server status (next state = 1), the server sends a basic JSON response with server information. * **Login Request (Simplified):** If the client requests to log in (next state = 2), the server reads the player's name. * **AI Integration (Welcome Message):** This is where Spring AI comes in. A `PromptTemplate` is used to create a prompt for the AI: "Generate a welcome message for player {playerName} joining the server." The `aiClient.generate()` method sends the prompt to the AI provider (e.g., OpenAI) and gets a response. The AI-generated message is then included in the chat message sent to the player. * **Chat Message Handling (Simplified):** The code attempts to handle chat messages (packet ID 0x03). * **AI Integration (Chat Response):** Another example of AI integration. The AI is used to respond to the player's chat message. * **Packet Handling:** The `while (clientSocket.isConnected())` loop is where you would add logic to handle other Minecraft packets. You need to read the packet ID and then parse the packet data according to the Minecraft protocol specification. * **Helper Methods:** The `readVarInt`, `readString`, `sendString`, `sendLong`, `writeVarInt`, `sendChatMessage`, `sendLoginSuccess`, and `sendJoinGame` methods are helper functions for reading and writing data in the format expected by the Minecraft protocol. `VarInt` is a variable-length integer encoding. 5. **AI Configuration:** You'll need to configure your Spring AI client in your `application.properties` or `application.yml` file. For example, if you're using OpenAI: ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY ``` **To Run This Example (Conceptual):** 1. **Create a Spring Boot project:** Use Spring Initializr (start.spring.io) to create a new Spring Boot project with the Web, Spring AI (OpenAI or another provider), and potentially other dependencies. 2. **Add the code:** Copy the code above into your project. 3. **Configure Spring AI:** Add your OpenAI API key (or the API key for your chosen AI provider) to your `application.properties` or `application.yml` file. 4. **Run the application:** Run the Spring Boot application. 5. **Connect with a Minecraft client:** Try connecting to `localhost:25565` with a Minecraft client. **Important:** This example is *very* basic and likely won't work perfectly with a standard Minecraft client without significant modifications. You'll probably need to use a custom client or a modified version of the game to test it effectively. **Next Steps (To Make This More Functional):** * **Implement the Full Minecraft Protocol:** This is the biggest task. You need to understand and implement the correct packet handling for all the packets you want to support. Refer to the Minecraft protocol documentation (e.g., on the Minecraft Wiki). * **World Management:** Create a system for loading, saving, and managing the game world. * **Player Management:** Track player data (inventory, position, health, etc.). * **Game Logic:** Implement the core game mechanics (e.g., block breaking, placing, entity movement, combat). * **Error Handling:** Add robust error handling to catch exceptions and prevent the server from crashing. * **Networking:** Consider using a more robust networking library like Netty for better performance and scalability. * **Security:** Implement security measures to prevent cheating and unauthorized access. * **Configuration:** Use Spring Boot's configuration features to make the server configurable (e.g., port number, world name, AI settings). **Important Notes on AI Integration:** * **Cost:** Using AI services like OpenAI can incur costs based on usage. Be mindful of your API usage and set limits if necessary. * **Latency:** AI requests can introduce latency. Consider using asynchronous processing or caching to minimize the impact on the game's responsiveness. * **Creativity vs. Control:** AI can generate creative content, but you may need to fine-tune the prompts and responses to ensure they fit the game's context and rules. * **Ethical Considerations:** Be aware of the ethical implications of using AI in your game, such as potential biases in the AI's responses. This example provides a starting point for building a Minecraft server with Spring AI. It's a complex project, but with careful planning and implementation, you can create a unique and engaging gaming experience. Remember to consult the Minecraft protocol documentation and the Spring AI documentation for more detailed information.

mcp-jenkins

Integrasi Model Context Protocol (MCP) Jenkins adalah implementasi sumber terbuka yang menjembatani Jenkins dengan model bahasa AI mengikuti spesifikasi MCP dari Anthropic. Proyek ini memungkinkan interaksi AI yang aman dan kontekstual dengan alat Jenkins sambil menjaga privasi dan keamanan data.

FFmpeg MCP

Enables video and audio processing through FFmpeg, supporting format conversion, compression, trimming, audio extraction, frame extraction, video merging, and subtitle burning through natural language commands.

mcp_server

Okay, I understand. You're looking for a weather microservice (MCP likely refers to Microservice Communication Protocol) that can be accessed by a client IDE like Cursor. Here's a breakdown of how you could approach building such a system, along with considerations for Indonesian users: **1. Core Functionality: The Weather Microservice** * **Technology Stack:** * **Language:** Python (with Flask or FastAPI), Node.js (with Express), Go, or Java (with Spring Boot) are all good choices. Python is often favored for its ease of use and rich ecosystem of libraries for data handling. * **Framework:** Flask or FastAPI (Python), Express (Node.js), Spring Boot (Java) - These frameworks simplify building web APIs. * **Weather API:** You'll need to integrate with a third-party weather API. Popular options include: * **OpenWeatherMap:** Free and paid tiers. Good coverage, including Indonesia. * **AccuWeather:** Commercial API, generally reliable. * **WeatherAPI.com:** Another commercial option. * **Visual Crossing Weather:** Offers historical and forecast data. * **Data Storage (Optional):** If you want to cache weather data or store historical information, consider a database like PostgreSQL, MySQL, or MongoDB. Caching can significantly improve response times and reduce API usage costs. * **API Endpoints:** * `/weather/city/{city_name}`: Returns the current weather for a given city. Example: `/weather/city/Jakarta` * `/weather/coordinates/{latitude}/{longitude}`: Returns the current weather for a given latitude and longitude. Example: `/weather/coordinates/-6.2088/106.8456` (Jakarta coordinates) * `/forecast/city/{city_name}`: Returns a weather forecast for a given city. * `/forecast/coordinates/{latitude}/{longitude}`: Returns a weather forecast for given coordinates. * **Data Format:** JSON (JavaScript Object Notation) is the standard for API responses. * **Example (Python with Flask):** ```python from flask import Flask, jsonify import requests import os app = Flask(__name__) # Replace with your actual API key from OpenWeatherMap or another provider API_KEY = os.environ.get("WEATHER_API_KEY") or "YOUR_API_KEY" BASE_URL = "https://api.openweathermap.org/data/2.5/weather" # Example: OpenWeatherMap @app.route('/weather/city/<city_name>') def get_weather_by_city(city_name): try: url = f"{BASE_URL}?q={city_name}&appid={API_KEY}&units=metric" # Use metric for Celsius response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return jsonify(data) except requests.exceptions.RequestException as e: return jsonify({'error': str(e)}), 500 except Exception as e: return jsonify({'error': str(e)}), 500 @app.route('/weather/coordinates/<latitude>/<longitude>') def get_weather_by_coordinates(latitude, longitude): try: url = f"{BASE_URL}?lat={latitude}&lon={longitude}&appid={API_KEY}&units=metric" response = requests.get(url) response.raise_for_status() data = response.json() return jsonify(data) except requests.exceptions.RequestException as e: return jsonify({'error': str(e)}), 500 except Exception as e: return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True) ``` **Explanation:** * **Flask:** Sets up a simple web server. * **`API_KEY`:** Crucially, store your API key securely (environment variable is best). *Never* hardcode it directly into your code that you commit to a repository. * **`BASE_URL`:** The base URL for the weather API you're using. * **`get_weather_by_city` and `get_weather_by_coordinates`:** These are the API endpoints. They take the city name or coordinates as input, make a request to the weather API, and return the JSON response. * **Error Handling:** Includes basic error handling to catch network issues and API errors. * **`units=metric`:** Important for Indonesian users (and most of the world) to get temperatures in Celsius. **2. Client IDE Integration (Cursor Example)** * **Cursor Custom Command/Extension:** Cursor allows you to create custom commands or extensions. You'll need to write code (likely in JavaScript/TypeScript) that: 1. Takes user input (e.g., city name, coordinates). 2. Makes an HTTP request to your weather microservice's API endpoint. 3. Parses the JSON response from the microservice. 4. Displays the weather information in a user-friendly way within the Cursor IDE. * **Example (Conceptual Cursor Command):** ```javascript // (Conceptual - this is not complete, runnable Cursor code) async function getWeather(city) { const apiUrl = `http://localhost:5000/weather/city/${city}`; // Replace with your microservice URL try { const response = await fetch(apiUrl); const data = await response.json(); if (response.ok) { // Format and display the weather data in Cursor const temperature = data.main.temp; const description = data.weather[0].description; console.log(`Weather in ${city}: ${temperature}°C, ${description}`); // Or use Cursor's UI API to display it better } else { console.error(`Error: ${data.error}`); } } catch (error) { console.error(`Network error: ${error}`); } } // Example usage (triggered by a Cursor command) getWeather("Jakarta"); ``` **Key Considerations for Cursor Integration:** * **Cursor API:** You'll need to consult the Cursor documentation to understand how to create custom commands, access the editor, and display information. * **Asynchronous Operations:** Fetching data from the API is an asynchronous operation. Use `async/await` to handle it properly. * **Error Handling:** Robust error handling is essential. * **User Interface:** Think about how to present the weather information clearly and concisely within the IDE. **3. Indonesian Considerations (Localization)** * **City Names:** Handle Indonesian city names correctly (e.g., "Jakarta" vs. "DKI Jakarta"). Consider using a city name database or a geocoding API to map variations to the correct location. * **Language:** If you want to provide weather information in Indonesian, you'll need to: * Use a weather API that supports Indonesian language output (some do). * Translate the weather descriptions yourself (e.g., "clear sky" to "langit cerah"). This is more complex but gives you full control. * **Units:** Celsius is the standard in Indonesia, so ensure your API requests use `units=metric`. * **Time Zones:** Be mindful of time zones. Jakarta is in GMT+7. Display times in the user's local time zone. **4. Deployment** * **Microservice:** Deploy your weather microservice to a cloud platform like: * **Heroku:** Easy to deploy Python, Node.js, and other applications. * **AWS (Amazon Web Services):** More complex but very powerful. Use services like EC2, Lambda, and API Gateway. * **Google Cloud Platform (GCP):** Similar to AWS. Use services like Cloud Run, Cloud Functions, and API Gateway. * **Azure:** Microsoft's cloud platform. * **Cursor Extension:** The deployment of the Cursor extension will depend on how Cursor allows extensions to be distributed (e.g., a marketplace, manual installation). **5. Scalability and Reliability** * **Caching:** Implement caching to reduce API calls and improve response times. * **Monitoring:** Monitor your microservice's performance and error rates. * **Load Balancing:** If you expect a lot of traffic, use a load balancer to distribute requests across multiple instances of your microservice. * **Rate Limiting:** Implement rate limiting to prevent abuse of your API. **Example Indonesian Weather Response (Hypothetical):** ```json { "city": "Jakarta", "temperature": 30, "description": "Cerah berawan", // Partly cloudy "humidity": 70, "wind_speed": 5, "time": "2023-10-27 14:30 WIB" } ``` **In Indonesian:** Implementasi server MCP cuaca yang dapat dipanggil oleh IDE klien seperti Cursor. **Explanation of the Indonesian Translation:** * **Implementasi:** Implementation * **server MCP cuaca:** weather MCP server * **yang dapat dipanggil:** that can be called * **oleh IDE klien:** by a client IDE * **seperti Cursor:** like Cursor **Key Takeaways:** * Start with a simple weather microservice using a framework like Flask or FastAPI. * Integrate with a reliable weather API. * Focus on getting the core functionality working first. * Then, create a Cursor command/extension to access the microservice. * Consider Indonesian localization (city names, language, units). * Deploy your microservice to a cloud platform. * Think about scalability and reliability as your application grows. This is a comprehensive outline. You'll need to break it down into smaller tasks and implement each part step by step. Good luck!

Image Process MCP Server

Sebuah Server MCP untuk pemrosesan gambar yang menggunakan pustaka Sharp untuk menyediakan fungsionalitas manipulasi gambar. (Atau, bisa juga: Server MCP untuk pemrosesan gambar yang memanfaatkan *library* Sharp untuk menyediakan fungsi manipulasi gambar.)

Excel MCP Server

Enables conversational data analysis of Excel/CSV files through natural language queries, powered by 395 Excel functions via HyperFormula and multi-provider AI. Supports advanced analytics, bulk operations, financial modeling, and large file processing with intelligent chunking.

Kolosal Vision MCP

Provides AI-powered image analysis and OCR capabilities using the Kolosal Vision API. Supports analyzing images from URLs, local files, or base64 data with natural language queries for object detection, scene description, text extraction, and visual assessment.

TOTP MCP Server

Generates time-based one-time password (TOTP) 2FA codes for configured accounts, enabling Claude to automate workflows requiring two-factor authentication.

MCP Tailwind Gemini Server

Advanced Model Context Protocol server that integrates Gemini AI with Tailwind CSS, providing intelligent component generation, class optimization, and cross-platform design assistance across major development environments.

PaddleOCR MCP Server

Multiple text-type recognition, handwriting recognition, and high-precision parsing of complex documents.

Skyvern MCP

Skyvern MCP server lets AI agents control a real browser to navigate websites, fill forms, authenticate, and extract structured data. Supports multi-step automation workflows via natural language.

OpenProject MCP Server

Enables AI assistants to interact with OpenProject installations for comprehensive project management, including creating projects and work packages, managing users and assignments, creating dependencies, and generating Gantt charts through natural language commands.

Jokes MCP Server

An MCP server that integrates with Microsoft Copilot Studio to deliver humor content upon request, providing Chuck Norris and Dad jokes through standardized LLM context protocol.

YouTube to LinkedIn MCP Server

Cermin dari

MCP Server Boilerplate

A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflow to help developers create their own tools and resource providers.

Medikode Medical Coding MCP Server

Enables AI assistants to access Medikode's medical coding platform for validating CPT/ICD-10 codes, performing chart quality assurance, parsing EOBs, calculating RAF scores, and extracting HCC codes from clinical documentation.

Spiral MCP Server

Implementasi server Protokol Konteks Model yang menyediakan antarmuka standar untuk berinteraksi dengan model bahasa Spiral, menawarkan alat untuk menghasilkan teks dari perintah (prompt), berkas, atau URL web.

MCP Client-Server Sandbox for LLM Augmentation

Kotak pasir lengkap untuk meningkatkan inferensi LLM (lokal atau cloud) dengan MCP Client-Server. Tempat pengujian gesekan rendah untuk validasi MCP Server dan evaluasi agentik.

Weather MCP Server

Provides real-time weather information for 12 major Chinese cities and global locations using the wttr.in API. Built with the HelloAgents framework, it requires no API keys and supports queries in both Chinese and English.

Model Context Protocol (MCP) MSPaint App Automation

Okay, here's a conceptual outline and a simplified example of how you might approach creating a Model Context Protocol (MCP) server and client to solve math problems and display the solution in MSPaint. This is a complex task, and this example focuses on the core communication and process execution. It's not a fully functional, production-ready system, but it provides a starting point. **Important Considerations:** * **MCP (Model Context Protocol):** MCP is not a standard, widely-used protocol. I'm assuming you're using it as a general term for a custom communication protocol. You'll need to define the exact message format and structure for your MCP. * **Security:** This example doesn't include any security measures. In a real-world application, you'd need to implement authentication, authorization, and encryption. * **Error Handling:** The error handling is basic. You'll need to add more robust error handling for production use. * **MSPaint Automation:** Automating MSPaint directly can be tricky and unreliable. A better approach might be to generate an image file (e.g., PNG) programmatically and then simply open it with the default image viewer (which might be MSPaint). * **Math Solving:** This example uses a very basic math evaluation. For more complex problems, you'll need a dedicated math library (e.g., SymPy in Python). **Conceptual Outline:** 1. **MCP Definition:** * Define the message format for requests (client to server) and responses (server to client). For example: * Request: `MATH: <math_expression>` * Response: `SOLUTION: <solution_string>` or `ERROR: <error_message>` 2. **Server:** * Listens for incoming connections on a specific port. * Receives math expressions from clients. * Evaluates the expression (using a math library or simple evaluation). * Generates a solution string. * Creates an image of the solution (using a library or by writing to a file that MSPaint can open). * Sends the solution string back to the client. 3. **Client:** * Connects to the server. * Sends a math expression to the server. * Receives the solution string from the server. * Displays the solution (ideally by opening an image file). **Simplified Python Example (using sockets):** ```python # server.py import socket import subprocess # For running MSPaint (or opening an image) import os def evaluate_math(expression): """ Evaluates a simple math expression. Replace with a more robust math library for complex expressions. """ try: result = eval(expression) # WARNING: eval() can be dangerous! return str(result) except Exception as e: return f"Error: {str(e)}" def create_solution_image(solution, filename="solution.png"): """ Creates a simple image file with the solution. (Replace with a more sophisticated image generation library like Pillow) """ # This is a placeholder. In a real application, you'd use a library # to draw the solution text onto an image. with open("temp.txt", "w") as f: f.write(solution) # Create a dummy image file (replace with actual image generation) os.system(f"echo {solution} > {filename}") # This is a very basic example return filename def run_server(): host = '127.0.0.1' # Localhost port = 12345 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((host, port)) server_socket.listen(1) print(f"Server listening on {host}:{port}") while True: conn, addr = server_socket.accept() print(f"Connection from {addr}") data = conn.recv(1024).decode() if not data: break if data.startswith("MATH:"): expression = data[5:].strip() solution = evaluate_math(expression) image_file = create_solution_image(solution) # Create the image response = f"SOLUTION: {solution}" conn.sendall(response.encode()) # Open the image with MSPaint (or the default image viewer) try: subprocess.Popen(['mspaint', image_file]) # Windows specific # For other OS, use the default image viewer: # os.system(f"open {image_file}") # macOS # os.system(f"xdg-open {image_file}") # Linux except FileNotFoundError: print("MSPaint not found. Make sure it's in your PATH.") except Exception as e: print(f"Error opening MSPaint: {e}") else: conn.sendall("ERROR: Invalid request".encode()) conn.close() if __name__ == "__main__": run_server() ``` ```python # client.py import socket def run_client(): host = '127.0.0.1' port = 12345 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((host, port)) except ConnectionRefusedError: print("Server not running. Please start the server first.") return expression = input("Enter a math expression: ") request = f"MATH: {expression}" client_socket.sendall(request.encode()) data = client_socket.recv(1024).decode() print(f"Received: {data}") client_socket.close() if __name__ == "__main__": run_client() ``` **How to Run:** 1. **Save:** Save the code as `server.py` and `client.py`. 2. **Run the Server:** Open a terminal or command prompt and run `python server.py`. 3. **Run the Client:** Open another terminal or command prompt and run `python client.py`. 4. **Enter Expression:** The client will prompt you to enter a math expression (e.g., `2 + 2`). 5. **See the Result:** The server will evaluate the expression, create a (very basic) image file, send the solution back to the client, and attempt to open the image in MSPaint. The client will also print the received solution. **Explanation and Improvements:** * **Sockets:** The code uses Python's `socket` library for basic TCP communication. * **`eval()` (DANGER):** The `eval()` function is used to evaluate the math expression. **This is extremely dangerous in a real application because it can execute arbitrary code.** Never use `eval()` with untrusted input. Use a safe math parsing library like `ast.literal_eval()` for simple expressions or a full-fledged math library like SymPy for more complex ones. * **Image Generation:** The `create_solution_image` function is a placeholder. You'll need to replace it with code that actually draws the solution onto an image. Libraries like Pillow (PIL) are excellent for this. * **MSPaint Automation:** The `subprocess.Popen(['mspaint', image_file])` line attempts to open the image in MSPaint. This is Windows-specific. For cross-platform compatibility, you can use `os.system()` with the appropriate command for opening the default image viewer on each operating system (see the comments in the code). * **Error Handling:** The error handling is minimal. You should add `try...except` blocks to handle potential errors like network connection issues, invalid math expressions, and problems opening MSPaint. * **MCP Format:** The MCP format is very simple (just `MATH:` and `SOLUTION:` prefixes). You can make it more robust by including message IDs, checksums, and other metadata. * **Threading/Asynchronous:** For a more scalable server, use threading or asynchronous programming (e.g., `asyncio`) to handle multiple client connections concurrently. **Example using Pillow for Image Generation (replace `create_solution_image`):** ```python from PIL import Image, ImageDraw, ImageFont def create_solution_image(solution, filename="solution.png"): """Creates an image with the solution using Pillow.""" image_width = 400 image_height = 200 image = Image.new("RGB", (image_width, image_height), "white") draw = ImageDraw.Draw(image) # Choose a font (you might need to adjust the path) try: font = ImageFont.truetype("arial.ttf", 24) # Replace with your font path except IOError: font = ImageFont.load_default() text_color = "black" text_position = (20, image_height // 2 - 12) # Center vertically draw.text(text_position, solution, fill=text_color, font=font) image.save(filename) return filename ``` **To use the Pillow example:** 1. **Install Pillow:** `pip install Pillow` 2. **Replace** the `create_solution_image` function in `server.py` with the Pillow version. 3. **Make sure** you have a font file (like `arial.ttf`) in a location your script can access, or use `ImageFont.load_default()`. This revised example provides a more practical starting point for building your MCP server and client. Remember to address the security concerns and improve the error handling before using it in a real-world scenario. Also, carefully consider the complexity of the math problems you want to solve and choose an appropriate math library.

MCP Firebird

Sebuah server yang mengimplementasikan Protokol Konteks Model (MCP) dari Anthropic untuk basis data Firebird SQL, memungkinkan Claude dan LLM lainnya untuk mengakses, menganalisis, dan memanipulasi data dalam basis data Firebird secara aman melalui bahasa alami.