MCP Servers

Discover Awesome MCP Servers

Extend your agent with 19,496 capabilities via MCP servers.

All19,496

s-GitHubTestRepo-Henry

created from MCP server demo

Modular Outlook MCP Server

MCP server for Claude to access Outlook data via Microsoft Graph API

Rails MCP Server

A Ruby gem implementation of a Model Context Protocol (MCP) server for Rails projects. This server allows LLMs (Large Language Models) to interact with Rails projects through the Model Context Protocol.

Bilibili MCP 服务器

MCP 서버 학습

MCP Workers AI

MCP servers sdk for Cloudflare Workers

MCP2HTTP

MCP2HTTP is a minimal transport adapter that bridges MCP clients using stdio with stateless HTTP servers.

Remote MCP Server on Cloudflare

Dockerized Salesforce MCP Server

Dockerized Salesforce MCP Server for REST API integration

Basilisp nREPL MCP Bridge

simple MCP server for nREPL

Model Context Protocol (MCP) Implementation

Learn MCP by building from Scarch

Zoom MCP Server

MCP server for Zoom

Exa MCP Server 🔍

클로드는 MCP (모델 컨텍스트 프로토콜)을 사용하여 웹 검색 | Exa를 수행할 수 있습니다.

@modelcontextprotocol/server-terminal

Terminal server implementation for Model Context Protocol

mcp_server_local_files

Local File System MCP Server

MCP Expert Server

Mirror of

iOS Simulator MCP Server

Mirror of

mcp-server-datahub

DataHub의 공식 MCP 서버 (

Browser JavaScript Evaluator

This is a reference design for a MCP server that hosts a web page that connects back to the server via sse and allows Claude to execute javascript on the page.

Fiberflow MCP Gateway

Run Fiberflow MCP SSE Server over stdio.

GooseTeam

Look, a flock of geese! An MCP server and protocol for Goose agent collaboration.

MCPClient Python Application

Okay, I understand. You want an implementation for interacting between an MCP (presumably Minecraft Protocol) server and an Ollama model. This is a complex project, so let's break down the key components and provide a conceptual outline with code snippets. I'll focus on the core logic and leave out boilerplate code for brevity. **Conceptual Outline** 1. **Minecraft Server Interaction (MCP):** * Establish a connection to the Minecraft server. * Listen for player chat messages. * Parse the chat messages to extract the player's input. * Send responses back to the Minecraft server to be displayed to the player. 2. **Ollama Model Interaction:** * Send the player's input to the Ollama model. * Receive the model's response. 3. **Orchestration:** * Connect the Minecraft server interaction and the Ollama model interaction. * Handle errors gracefully. * Potentially implement a command prefix to trigger the Ollama interaction. **Code Snippets (Python - Example)** This example uses Python because it's commonly used for both Minecraft server interaction and interacting with APIs. You'll need libraries like `mcstatus` (for basic server status and RCON) or a more robust Minecraft protocol library like `python-minecraft-protocol` (for more advanced interaction) and `requests` for making HTTP requests to the Ollama API. ```python import mcstatus import requests import json import time # --- Minecraft Server Interaction --- def get_server_status(server_address, server_port): """Gets the status of the Minecraft server.""" try: server = mcstatus.JavaServer(server_address, server_port) status = server.status() return status except Exception as e: print(f"Error getting server status: {e}") return None def send_command_to_server(server_address, server_port, rcon_password, command): """Sends a command to the Minecraft server using RCON.""" try: server = mcstatus.JavaServer(server_address, server_port) with server.rcon(rcon_password) as rcon: response = rcon.command(command) return response except Exception as e: print(f"Error sending command: {e}") return None def listen_for_chat_messages(server_address, server_port, rcon_password, command_prefix="!ollama"): """Listens for chat messages and processes them.""" # This is a simplified example. A real implementation would need to # continuously monitor the server logs or use a more sophisticated # Minecraft protocol library to receive chat messages in real-time. # This example uses RCON to get the latest server log entries. # It's not ideal for real-time chat monitoring, but it demonstrates the concept. while True: log_entries = send_command_to_server(server_address, server_port, rcon_password, "log read") if log_entries: for line in log_entries.splitlines(): if "]: [CHAT]" in line: try: username = line.split("]: [CHAT]")[0].split("<")[1].split(">")[0] message = line.split("]: [CHAT]")[1].strip() if message.startswith(command_prefix): user_input = message[len(command_prefix):].strip() print(f"Received message from {username}: {user_input}") ollama_response = get_ollama_response(user_input) if ollama_response: send_command_to_server(server_address, server_port, rcon_password, f"say {username}: {ollama_response}") else: send_command_to_server(server_address, server_port, rcon_password, f"say Ollama error.") except IndexError: print(f"Could not parse chat message: {line}") time.sleep(5) # Check for new messages every 5 seconds. Adjust as needed. # --- Ollama Model Interaction --- OLLAMA_API_URL = "http://localhost:11434/api/generate" # Default Ollama API endpoint OLLAMA_MODEL = "llama2" # Replace with your desired Ollama model def get_ollama_response(prompt): """Sends a prompt to the Ollama model and returns the response.""" try: data = { "prompt": prompt, "model": OLLAMA_MODEL, "stream": False # Set to True for streaming responses } response = requests.post(OLLAMA_API_URL, json=data, stream=False) #stream=False for non-streaming response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) json_response = response.json() return json_response["response"] except requests.exceptions.RequestException as e: print(f"Error communicating with Ollama: {e}") return None except json.JSONDecodeError as e: print(f"Error decoding Ollama response: {e}") return None except KeyError as e: print(f"Error extracting response from Ollama JSON: {e}") return None # --- Main --- if __name__ == "__main__": SERVER_ADDRESS = "your_server_address" # Replace with your server address SERVER_PORT = 25565 # Default Minecraft port RCON_PASSWORD = "your_rcon_password" # Replace with your RCON password status = get_server_status(SERVER_ADDRESS, SERVER_PORT) if status: print(f"Server is online with {status.players.online} players.") listen_for_chat_messages(SERVER_ADDRESS, SERVER_PORT, RCON_PASSWORD) else: print("Server is offline.") ``` **Explanation and Key Considerations:** * **Minecraft Protocol Library:** The `mcstatus` library is very basic. For real-time chat monitoring and more robust interaction, use `python-minecraft-protocol`. This library allows you to directly interact with the Minecraft protocol, giving you much more control. It's more complex to use, but it's necessary for a production-ready implementation. You'll need to handle packet parsing and authentication. * **RCON (Remote Console):** RCON is used in the example for simplicity. It allows you to send commands to the server. However, it's not ideal for real-time chat monitoring because you have to poll the server logs. `python-minecraft-protocol` is the better approach for real-time interaction. * **Ollama API:** The code assumes Ollama is running locally on the default port (11434). Adjust `OLLAMA_API_URL` if your Ollama instance is running elsewhere. * **Error Handling:** The code includes basic error handling, but you should add more robust error handling for production use. Consider logging errors to a file. * **Command Prefix:** The `command_prefix` (e.g., `!ollama`) allows players to trigger the Ollama interaction. This prevents the model from responding to every chat message. * **Rate Limiting:** Implement rate limiting to prevent abuse and to avoid overwhelming the Ollama model. You can track the number of requests from each player and limit the frequency. * **Security:** Be very careful about security. Never hardcode sensitive information like RCON passwords in your code. Use environment variables or a configuration file to store sensitive data. Sanitize user input to prevent prompt injection attacks. * **Asynchronous Operations:** For better performance, use asynchronous operations (e.g., `asyncio` in Python) to handle the Minecraft server interaction and the Ollama API calls concurrently. This will prevent the program from blocking while waiting for responses. * **Model Selection:** The `OLLAMA_MODEL` variable allows you to choose which Ollama model to use. Make sure the model is installed in your Ollama instance. * **Streaming Responses:** The `stream` parameter in the Ollama API request can be set to `True` to receive streaming responses. This allows you to display the model's output in real-time as it's being generated. You'll need to modify the code to handle the streaming response format. * **Prompt Engineering:** Experiment with different prompts to get the best results from the Ollama model. You can include context from the Minecraft world in the prompt to make the responses more relevant. * **Context Management:** Consider implementing context management to allow the model to remember previous conversations. You can store the conversation history for each player and include it in the prompt. **Example Usage:** 1. Install the necessary libraries: ```bash pip install mcstatus requests ``` 2. Replace the placeholder values in the code with your actual server address, port, and RCON password. 3. Run the script. 4. In Minecraft, type `!ollama What is the meaning of life?` in the chat. The script will send the prompt to the Ollama model and display the response in the Minecraft chat. **Korean Translation of Key Terms:** * **Minecraft Protocol (MCP):** 마인크래프트 프로토콜 * **Ollama Model:** Ollama 모델 * **Server Address:** 서버 주소 * **Server Port:** 서버 포트 * **RCON Password:** RCON 비밀번호 * **Chat Message:** 채팅 메시지 * **Prompt:** 프롬프트 * **Response:** 응답 * **Command Prefix:** 명령어 접두사 * **Rate Limiting:** 속도 제한 * **Security:** 보안 * **Asynchronous Operations:** 비동기 작업 * **Prompt Engineering:** 프롬프트 엔지니어링 * **Context Management:** 컨텍스트 관리 This detailed explanation and code outline should give you a solid foundation for building your Minecraft server and Ollama model integration. Remember to choose the appropriate Minecraft protocol library based on your needs and to prioritize security and error handling. Good luck!