Discover Awesome MCP Servers

Sefaria Jewish Library MCP Server

Espelho de

mcp-client-and-server MCP server

Mirror of

MCP Servers Hub

Descubra servidores e clientes MCP interessantes.

🎯 Kubernetes MCP Server

Servidor MCP com tecnologia de IA entende consultas em linguagem natural sobre seu cluster Kubernetes

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.

s-GitHubTestRepo-Henry

created from MCP server demo

Bilibili MCP 服务器

Aprendizagem do servidor MCP (ou estudo do servidor 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.

Model Context Protocol (MCP) Implementation

Learn MCP by building from Scarch

Modular Outlook MCP Server

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

@modelcontextprotocol/server-terminal

Terminal server implementation for Model Context Protocol

Exa MCP Server 🔍

Claude pode realizar Pesquisas na Web | Exa com MCP (Protocolo de Contexto do Modelo).

Dockerized Salesforce MCP Server

Dockerized Salesforce MCP Server for REST API integration

Basilisp nREPL MCP Bridge

simple MCP server for nREPL

Zoom MCP Server

MCP server for Zoom

mcp_server_local_files

Local File System MCP Server

MCP Expert Server

Mirror of

mcp-server-datahub

O servidor MCP oficial para o DataHub (

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.

GooseTeam

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

iOS Simulator MCP Server

Mirror of

MCPClient Python Application

Okay, I understand. You want an implementation that allows an MCP (presumably Minecraft Protocol) server to interact with an Ollama model. This is a complex task that involves several steps. Here's a breakdown of the concepts, potential implementation strategies, and code snippets to get you started. Keep in mind that this is a high-level overview and will require significant development effort to create a fully functional system. **Core Concepts** * **MCP (Minecraft Protocol):** This is the communication protocol used between Minecraft clients and servers. You'll need to understand how to send and receive packets to interact with the server. Libraries like `mcstatus` (Python) or similar libraries in other languages can help with this. * **Ollama:** This is a tool that allows you to run large language models (LLMs) locally. You'll need to have Ollama installed and a model downloaded. You'll interact with Ollama via its API (usually a REST API). * **Bridge/Middleware:** You'll need a piece of software (the "bridge") that sits between the Minecraft server and the Ollama model. This bridge will: * Receive messages from the Minecraft server (e.g., player chat). * Format the messages and send them to the Ollama model. * Receive the response from the Ollama model. * Format the response and send it back to the Minecraft server (e.g., as a chat message, a command execution, etc.). **Implementation Strategy** Here's a possible implementation strategy, using Python as the example language (but you could use other languages like Java, Go, etc.): 1. **Minecraft Server Interaction:** * **Choose a Library:** Select a library that allows you to interact with the Minecraft protocol. `mcstatus` is good for basic server status, but for more advanced interaction (like reading chat), you'll likely need a more robust library or write your own packet handling. Consider libraries that allow you to create a Minecraft bot. * **Authentication:** If you need to authenticate with the server, implement the necessary login sequence. * **Chat Monitoring:** Listen for chat messages from players. Parse the messages to extract the player's name and the message content. * **Command Handling (Optional):** You might want to allow players to use specific commands (e.g., `/ask <question>`) to interact with the Ollama model. 2. **Ollama Interaction:** * **Ollama API:** Use the Ollama API to send prompts to the model and receive responses. The API is typically a REST API. * **Prompt Engineering:** Design your prompts carefully. You'll need to provide context to the model so it can generate relevant responses. For example, you might include the player's name, the current game state (if you can access it), and the question they asked. * **Response Parsing:** Parse the response from the Ollama model to extract the relevant information. 3. **The Bridge (Middleware):** * **Event Loop:** Create an event loop that continuously listens for messages from the Minecraft server and sends prompts to the Ollama model. * **Message Formatting:** Format the messages from the Minecraft server into a suitable prompt for the Ollama model. * **Response Formatting:** Format the response from the Ollama model into a message that can be sent back to the Minecraft server. * **Error Handling:** Implement error handling to gracefully handle errors such as network issues, API errors, and invalid prompts. * **Rate Limiting:** Implement rate limiting to prevent the Ollama model from being overloaded. **Code Snippets (Python - Illustrative)** ```python import asyncio import aiohttp import json # Replace with your actual Minecraft server details MINECRAFT_SERVER_ADDRESS = "your_server_ip" MINECRAFT_SERVER_PORT = 25565 # Replace with your Ollama model name OLLAMA_MODEL_NAME = "llama2" # Or any other model you have # --- Minecraft Interaction (Illustrative - Requires a proper Minecraft library) --- async def read_minecraft_chat(): """ This is a placeholder. You'll need to use a Minecraft library to actually connect to the server and read chat messages. """ # Example: Assume you have a function that returns a list of chat messages # chat_messages = await get_chat_messages_from_minecraft_server() # For now, let's simulate a chat message await asyncio.sleep(1) # Simulate waiting for a message return [{"player": "Player123", "message": "Hello, Ollama! What is the capital of France?"}] # --- Ollama Interaction --- async def send_to_ollama(prompt: str) -> str: """Sends a prompt to the Ollama API and returns the response.""" url = "http://localhost:11434/api/generate" # Default Ollama API endpoint headers = {"Content-Type": "application/json"} data = { "model": OLLAMA_MODEL_NAME, "prompt": prompt, "stream": False # Set to True for streaming responses } async with aiohttp.ClientSession() as session: try: async with session.post(url, headers=headers, data=json.dumps(data)) as response: if response.status == 200: response_data = await response.json() return response_data["response"] else: print(f"Ollama API Error: {response.status} - {await response.text()}") return "Error communicating with Ollama." except aiohttp.ClientError as e: print(f"AIOHTTP Error: {e}") return "Error communicating with Ollama." # --- Bridge Logic --- async def process_chat_message(player: str, message: str): """Processes a chat message and sends it to Ollama.""" prompt = f"Minecraft Player {player} says: {message}. Respond as a helpful assistant in the Minecraft world." print(f"Sending prompt to Ollama: {prompt}") ollama_response = await send_to_ollama(prompt) print(f"Ollama Response: {ollama_response}") # --- Send the response back to the Minecraft server --- await send_message_to_minecraft(f"Ollama: {ollama_response}") # Replace with actual sending logic async def send_message_to_minecraft(message: str): """ Placeholder for sending a message back to the Minecraft server. You'll need to use your Minecraft library to implement this. """ print(f"Sending to Minecraft: {message}") # Example: await minecraft_bot.send_chat_message(message) pass async def main(): """Main event loop.""" print("Starting MCP-Ollama bridge...") while True: chat_messages = await read_minecraft_chat() if chat_messages: for chat_message in chat_messages: await process_chat_message(chat_message["player"], chat_message["message"]) await asyncio.sleep(0.1) # Check for new messages every 100ms if __name__ == "__main__": asyncio.run(main()) ``` **Explanation of the Code:** * **`read_minecraft_chat()`:** This is a placeholder. You'll need to replace this with code that actually connects to your Minecraft server and reads chat messages. This is the most complex part, as it requires understanding the Minecraft protocol. * **`send_to_ollama()`:** This function sends a prompt to the Ollama API. It uses the `aiohttp` library for asynchronous HTTP requests. It constructs a JSON payload with the model name and the prompt. * **`process_chat_message()`:** This function takes a chat message from a player, formats it into a prompt for Ollama, sends the prompt to Ollama, and then sends the response back to the Minecraft server. * **`send_message_to_minecraft()`:** This is another placeholder. You'll need to replace this with code that sends a message back to the Minecraft server. * **`main()`:** This is the main event loop. It continuously checks for new chat messages from the Minecraft server and processes them. **Key Considerations and Challenges:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and constantly evolving. You'll need to stay up-to-date with the latest changes. * **Ollama API Stability:** The Ollama API is relatively new, so it may be subject to change. * **Prompt Engineering:** The quality of the responses from the Ollama model will depend heavily on the quality of your prompts. Experiment with different prompts to find what works best. * **Latency:** There will be some latency involved in sending prompts to the Ollama model and receiving responses. This latency can be noticeable to players. Consider using streaming responses from Ollama to improve perceived responsiveness. * **Resource Usage:** Running an LLM locally can be resource-intensive. Make sure your server has enough CPU and memory to handle the load. * **Security:** Be careful about the prompts you send to the Ollama model. Avoid sending sensitive information. Also, be aware that the Ollama model could potentially generate harmful or offensive content. Implement appropriate filtering and moderation. * **Context Management:** LLMs have limited context windows. You'll need to manage the context effectively to ensure that the model can generate relevant responses. Consider using techniques like summarization or conversation history to provide context. * **Rate Limiting:** Implement rate limiting to prevent players from overloading the Ollama model. * **Error Handling:** Implement robust error handling to gracefully handle errors such as network issues, API errors, and invalid prompts. **Steps to Get Started:** 1. **Install Ollama:** Follow the instructions on the Ollama website to install Ollama on your server. 2. **Download a Model:** Download a suitable LLM from Ollama (e.g., `ollama pull llama2`). 3. **Choose a Minecraft Library:** Select a library that allows you to interact with the Minecraft protocol. 4. **Implement Minecraft Chat Reading:** Implement the `read_minecraft_chat()` function to read chat messages from your Minecraft server. 5. **Implement Minecraft Message Sending:** Implement the `send_message_to_minecraft()` function to send messages back to your Minecraft server. 6. **Test and Iterate:** Test your implementation thoroughly and iterate on your prompts and code to improve the quality of the responses. **Translation to Portuguese (Summary):** Aqui está uma visão geral de como implementar uma interação entre um servidor MCP (Minecraft Protocol) e um modelo Ollama: 1. **Conceitos:** * **MCP:** Protocolo de comunicação do Minecraft. * **Ollama:** Ferramenta para executar modelos de linguagem grandes (LLMs) localmente. * **Ponte/Middleware:** Software que conecta o servidor Minecraft e o Ollama. 2. **Estratégia:** * Usar uma biblioteca para interagir com o protocolo Minecraft (ex: `mcstatus` em Python, ou similar). * Autenticar com o servidor Minecraft (se necessário). * Monitorar o chat do Minecraft. * Usar a API do Ollama para enviar prompts e receber respostas. * Criar prompts bem definidos para o Ollama. * Formatar as mensagens do Minecraft para o Ollama e as respostas do Ollama para o Minecraft. * Implementar tratamento de erros e limitação de taxa. 3. **Código (Python - Exemplo):** O código fornecido demonstra como enviar prompts para o Ollama e receber respostas, mas requer implementação da interação com o servidor Minecraft. 4. **Considerações:** * Complexidade do protocolo Minecraft. * Estabilidade da API do Ollama. * Engenharia de prompts (qualidade dos prompts afeta a qualidade das respostas). * Latência (tempo de resposta). * Uso de recursos (Ollama pode consumir muitos recursos). * Segurança (evitar enviar informações sensíveis e moderar o conteúdo gerado). * Gerenciamento de contexto (LLMs têm janelas de contexto limitadas). * Limitação de taxa (para evitar sobrecarga do Ollama). * Tratamento de erros. 5. **Próximos Passos:** * Instalar o Ollama. * Baixar um modelo Ollama. * Escolher uma biblioteca Minecraft. * Implementar a leitura do chat do Minecraft. * Implementar o envio de mensagens para o Minecraft. * Testar e iterar. This is a complex project, but hopefully, this detailed explanation and the code snippets will give you a good starting point. Good luck! Remember to break down the problem into smaller, manageable tasks.

Gmail MCP Server

Mirror of

Fiberflow MCP Gateway

Run Fiberflow MCP SSE Server over stdio.

Supergateway

Run MCP stdio servers over SSE and SSE over stdio. AI gateway.

NSAF MCP Server

Espelho de

MCP Server Playwright

MCP Server Playwright - Um serviço de automação de navegador para o Claude Desktop

generator-mcp

Yeoman Generator to quickly create a new MCP Server