Discover Awesome MCP Servers

OpenTargets MCP Server

Unofficial Model Context Protocol server for accessing Open Targets platform data for gene-drug-disease associations research.

Your Money Left The Chat

A Rust + MCP powered financial tracker that knows exactly where your money ghosted you.

MCP Server

A Multi-Agent Conversation Protocol Server that interfaces with the Exa Search API, allowing agents to perform semantic search operations through a standardized protocol.

PentestThinkingMCP

An AI-powered penetration testing reasoning engine that provides automated attack path planning, step-by-step guidance for CTFs/HTB challenges, and tool recommendations using Beam Search and MCTS algorithms.

Cold Email Assistant

Automates cold email outreach for job applications by parsing job postings, generating personalized emails using AI, and sending them or saving as drafts in Gmail with resume attachments.

Directmedia MCP

Provides programmatic access to the Directmedia Publishing 'Digitale Bibliothek' collection, a 1990s German electronic book library containing 101 volumes of classic literature and philosophy with text extraction, search, and navigation capabilities.

Sample Model Context Protocol Demos

Okay, here are some examples of how to use the Model Context Protocol with AWS, translated into Indonesian: **Judul: Kumpulan Contoh Penggunaan Protokol Konteks Model dengan AWS** **Pendahuluan:** Protokol Konteks Model (Model Context Protocol) adalah cara untuk menyediakan informasi kontekstual ke model machine learning Anda saat di-deploy. Informasi ini dapat mencakup data konfigurasi, kredensial, atau metadata lainnya yang dibutuhkan model untuk beroperasi dengan benar. Dengan AWS, Anda dapat memanfaatkan berbagai layanan untuk mengelola dan menyediakan konteks model ini. **Contoh 1: Menyediakan Kredensial AWS ke Model yang Berjalan di Amazon SageMaker** * **Bahasa Inggris:** "Let's say you have a model deployed on Amazon SageMaker that needs to access data from an S3 bucket. Instead of hardcoding the AWS credentials into the model code, you can use the SageMaker execution role to provide the necessary permissions. The model can then use the AWS SDK to assume the role and access the S3 bucket." * **Bahasa Indonesia:** "Katakanlah Anda memiliki model yang di-deploy di Amazon SageMaker yang perlu mengakses data dari bucket S3. Alih-alih memasukkan kredensial AWS secara langsung (hardcoding) ke dalam kode model, Anda dapat menggunakan peran eksekusi SageMaker untuk menyediakan izin yang diperlukan. Model kemudian dapat menggunakan AWS SDK untuk mengambil peran tersebut dan mengakses bucket S3." **Penjelasan:** * **SageMaker Execution Role:** Peran IAM yang diberikan ke instance SageMaker. Ini memberikan izin kepada instance untuk mengakses layanan AWS lainnya. * **AWS SDK:** Perpustakaan (library) yang memungkinkan model Anda berinteraksi dengan layanan AWS. * **Keuntungan:** Keamanan yang lebih baik (tidak ada kredensial yang di-hardcode), manajemen kredensial yang terpusat. **Contoh 2: Menggunakan AWS Secrets Manager untuk Menyimpan dan Mengakses Kunci API** * **Bahasa Inggris:** "Your model might need to call an external API that requires an API key. You can store the API key securely in AWS Secrets Manager and then retrieve it from your model at runtime. This prevents the API key from being exposed in your code or configuration files." * **Bahasa Indonesia:** "Model Anda mungkin perlu memanggil API eksternal yang memerlukan kunci API. Anda dapat menyimpan kunci API dengan aman di AWS Secrets Manager dan kemudian mengambilnya dari model Anda saat runtime. Ini mencegah kunci API terekspos dalam kode atau file konfigurasi Anda." **Penjelasan:** * **AWS Secrets Manager:** Layanan untuk menyimpan dan mengelola rahasia (secrets) seperti kunci API, kata sandi database, dan sertifikat. * **Runtime:** Waktu ketika model sedang berjalan dan memproses data. * **Keuntungan:** Keamanan yang ditingkatkan, rotasi rahasia yang mudah. **Contoh 3: Menggunakan AWS Systems Manager Parameter Store untuk Menyimpan Konfigurasi Model** * **Bahasa Inggris:** "You can use AWS Systems Manager Parameter Store to store configuration parameters for your model, such as the learning rate, batch size, or the path to a pre-trained model. This allows you to easily update the configuration without redeploying the model." * **Bahasa Indonesia:** "Anda dapat menggunakan AWS Systems Manager Parameter Store untuk menyimpan parameter konfigurasi untuk model Anda, seperti learning rate, ukuran batch, atau path ke model yang sudah dilatih sebelumnya (pre-trained model). Ini memungkinkan Anda untuk dengan mudah memperbarui konfigurasi tanpa perlu melakukan redeploy model." **Penjelasan:** * **AWS Systems Manager Parameter Store:** Layanan untuk menyimpan data konfigurasi dan rahasia. * **Learning Rate, Batch Size:** Contoh parameter yang sering digunakan dalam machine learning. * **Keuntungan:** Manajemen konfigurasi yang terpusat, pembaruan konfigurasi yang mudah. **Contoh 4: Menggunakan Amazon DynamoDB untuk Menyimpan Metadata Model** * **Bahasa Inggris:** "You can store metadata about your model in Amazon DynamoDB, such as the model version, training data used, and performance metrics. This metadata can be used for model tracking, auditing, and debugging." * **Bahasa Indonesia:** "Anda dapat menyimpan metadata tentang model Anda di Amazon DynamoDB, seperti versi model, data pelatihan yang digunakan, dan metrik kinerja. Metadata ini dapat digunakan untuk pelacakan model, audit, dan debugging." **Penjelasan:** * **Amazon DynamoDB:** Database NoSQL yang cepat dan scalable. * **Metadata:** Data tentang data (dalam hal ini, data tentang model). * **Keuntungan:** Pelacakan model yang lebih baik, kemampuan audit, dan debugging yang lebih mudah. **Contoh 5: Menggunakan AWS Lambda untuk Menyediakan Konteks Model Dinamis** * **Bahasa Inggris:** "You can use AWS Lambda to create a function that dynamically retrieves context information for your model based on the input data. For example, the Lambda function could retrieve user-specific data from a database and pass it to the model as context." * **Bahasa Indonesia:** "Anda dapat menggunakan AWS Lambda untuk membuat fungsi yang secara dinamis mengambil informasi konteks untuk model Anda berdasarkan data input. Misalnya, fungsi Lambda dapat mengambil data spesifik pengguna dari database dan meneruskannya ke model sebagai konteks." **Penjelasan:** * **AWS Lambda:** Layanan komputasi tanpa server (serverless) yang memungkinkan Anda menjalankan kode tanpa menyediakan atau mengelola server. * **Konteks Dinamis:** Informasi konteks yang berubah berdasarkan input. * **Keuntungan:** Fleksibilitas yang tinggi, kemampuan untuk menyediakan konteks yang dipersonalisasi. **Kesimpulan:** Contoh-contoh di atas menunjukkan beberapa cara untuk menggunakan Protokol Konteks Model dengan AWS. Dengan memanfaatkan layanan AWS seperti SageMaker, Secrets Manager, Parameter Store, DynamoDB, dan Lambda, Anda dapat mengelola dan menyediakan konteks model dengan aman dan efisien. Pilihan layanan yang tepat akan bergantung pada kebutuhan spesifik model dan aplikasi Anda. **Catatan:** Pastikan untuk selalu mengikuti praktik terbaik keamanan AWS saat mengelola kredensial dan data sensitif.

COTI MCP Server

Enables AI applications to interact with the COTI blockchain for private token operations, supporting account management, private ERC20/ERC721 tokens, and secure transactions using Multi-Party Computation (MPC) technology.

MCP Email Service

Enables multi-account email management with AI-powered monitoring, intelligent filtering, and automated notifications across multiple platforms including Gmail, Outlook, QQ Mail, and 163 Mail.

long-context-mcp

An MCP server implementing Recursive Language Models (RLM) to process arbitrarily large contexts through a programmatic probe, recurse, and synthesize loop. It enables LLMs to perform multi-step investigations and evidence-backed extraction across massive file sets without being limited by standard context windows.

Vercel MCP Server Template

A starter template for deploying Model Context Protocol (MCP) servers on Vercel using TypeScript and Vercel Functions. It includes example tools for rolling dice and checking weather to demonstrate tool integration patterns.

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.

A MCP server for Godot RAG

Server MCP ini digunakan untuk menyediakan dokumentasi Godot ke model Godot RAG.

Perplexity MCP Server

Integrates Perplexity AI's search-enhanced language models with Claude Desktop, providing three tools with different complexity levels for quick fact-checking, technical analysis, and deep research.

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.

MMA MCP Server

Enables users to search and query information about military service alternative companies in South Korea through the Military Manpower Administration (MMA) API. Supports filtering by service type, industry, company size, location, and recruitment status.