Discover Awesome MCP Servers

vscode-mcp-server

VSCode MCP Server for managing VSCode settings, extensions, snippets, and more

gomcptest: Proof of Concept for MCP with Custom Host

Uma prova de conceito demonstrando um host construído sob medida que implementa uma API compatível com OpenAI usando o Google Vertex AI, chamada de função e interação com servidores MCP.

Solana MCP Server 🌱

Um servidor que permite a interação com a blockchain Solana usando sua própria chave privada, suportando operações como obter informações da carteira, verificar saldos e transferir SOL.

Bear MCP Server

Mirror of

NYT MCP Server

Um servidor de Protocolo Concentrador de Mensagens (MCP) que fornece uma interface unificada e simples para as APIs do New York Times. Este servidor simplifica a interação com múltiplas APIs do NYT através de um único ponto de acesso.

Filesystem MCP Server

Mirror of

GenAIScript MCP Demo 🚀

Demonstração das capacidades do Servidor MCP do GenAIScript.

spring-mcp-server-sample

MCP Server Sample

MCP_claude

This is to demonstrate how an MCP server can be built for Claude Desktop MCP Client

Symbol MCP Server (REST API tools)

Symbol MCP Server. (REST API tools)

MCP LLM Bridge

A Simple bridge from Ollama to a fetch url mcp server

Binance MCP Server

Espelho de

mcp-edge-search

Um servidor de Protocolo de Contexto de Modelo que habilita capacidades de pesquisa na web para clientes MCP como o Claude Desktop.

MCP Host Project

Showcases how to integrate Spring AI's support for MCP (Model Context Protocol) within Spring Boot applications, covering both server-side and client-side implementations.

XACHE - Crypto Trader Website

Goose AI com Servidores MCP

cursor_agents

Okay, I understand. You want to integrate a team of human experts into your agent flow using an MCP (presumably, you mean a platform like Microsoft Copilot Studio, formerly Power Virtual Agents, or a similar conversational AI platform). Here's a breakdown of how you can achieve this, along with considerations and best practices: **General Approach: Hand-off to Human Agents** The core idea is to detect when the agent cannot adequately handle a user's request and then seamlessly transfer the conversation to a team of human experts. This is often called "escalation" or "hand-off." **Steps Involved (Conceptual):** 1. **Detection of Hand-off Need:** The agent needs to determine when it's appropriate to hand off the conversation. 2. **Routing to the Correct Team:** Based on the user's request, the conversation should be routed to the most relevant team of experts. 3. **Context Transfer:** Crucially, the agent needs to pass along the conversation history and any relevant user data to the human agent. This avoids the user having to repeat themselves. 4. **Notification and Availability:** The system needs to notify the available human agents that a new conversation is waiting. 5. **Agent Takeover:** A human agent claims the conversation and takes over from the bot. 6. **Seamless Transition (User Perspective):** The user should experience a smooth transition from interacting with the bot to interacting with a human. 7. **Post-Conversation Analysis:** After the human agent finishes, the conversation data should be analyzed to identify areas where the bot can be improved. **Implementation using a Platform like Microsoft Copilot Studio (Example):** While the exact steps will vary depending on the specific MCP you're using, here's a general outline using Microsoft Copilot Studio as an example: * **1. Identify Scenarios for Hand-off:** * **Low Confidence:** If the bot's natural language understanding (NLU) engine has low confidence in understanding the user's intent, trigger a hand-off. * **Specific Keywords/Phrases:** If the user says things like "I need to talk to a person," "Speak to an agent," or uses specific keywords related to complex issues, trigger a hand-off. * **Escalation Topic:** Create a dedicated "Escalation" topic that users can explicitly trigger. * **Loop Detection:** If the bot gets stuck in a loop (e.g., asking the same question repeatedly), trigger a hand-off. * **Unresolved Intent:** If the bot cannot match the user's input to any known topic after a certain number of attempts, trigger a hand-off. * **2. Configure Hand-off to a Live Agent System:** * **Integration with Live Agent Platforms:** Microsoft Copilot Studio (and similar platforms) typically integrate with popular live agent platforms like: * Microsoft Dynamics 365 Customer Service * Salesforce Service Cloud * Zendesk * Other custom solutions via APIs. * **Configure the Hand-off Topic:** In your Copilot Studio bot, create a topic specifically for handling hand-offs. * **Transfer Conversation:** Within the hand-off topic, use the platform's built-in functionality to transfer the conversation to the configured live agent system. This usually involves selecting the appropriate queue or agent group. * **3. Context Transfer (Critical):** * **Variables:** Before the hand-off, store relevant information from the conversation in variables. This might include: * User's name * User's email address * User's account number * The topic the user was trying to address * The conversation history (if the platform supports it) * **Pass Variables to Live Agent System:** Configure the hand-off action to pass these variables to the live agent system. The live agent system needs to be configured to receive and display this information to the human agent. This is often done through custom fields or attributes in the live agent platform. * **4. Live Agent System Configuration:** * **Queues and Routing:** Set up queues in your live agent system to route conversations to the appropriate teams (e.g., sales, support, technical support). Use the information passed from the bot (e.g., the topic the user was trying to address) to determine the correct queue. * **Agent Notifications:** Configure the live agent system to notify agents when a new conversation is waiting in their queue. * **Agent Workspace:** Ensure that the agent workspace in the live agent system displays the context information passed from the bot. * **5. User Experience:** * **Clear Communication:** When the bot is handing off the conversation, clearly inform the user that they are being transferred to a human agent. Provide an estimated wait time if possible. * **Seamless Transition:** The transition should be as seamless as possible. Avoid requiring the user to re-enter information they have already provided to the bot. * **6. Analytics and Improvement:** * **Monitor Hand-off Rate:** Track the number of conversations that are handed off to human agents. A high hand-off rate may indicate that the bot needs improvement in certain areas. * **Analyze Hand-off Reasons:** Identify the reasons why conversations are being handed off. This can help you prioritize areas for bot improvement. * **Review Transcripts:** Review transcripts of conversations that were handled by human agents to identify areas where the bot could have handled the conversation more effectively. * **Feedback Loop:** Use the insights gained from analytics to improve the bot's knowledge base, NLU, and conversation flows. **Example Scenario (Simplified):** 1. **User:** "I want to cancel my subscription." 2. **Bot:** "I can help with that. What is your account number?" 3. **User:** (Provides account number) 4. **Bot:** "I'm sorry, I'm having trouble processing your request. I'm going to transfer you to a human agent who can assist you." 5. **Bot (Hand-off Topic):** * Stores the user's account number in a variable. * Transfers the conversation to the "Cancellation" queue in the live agent system. * Passes the user's account number to the live agent system. 6. **Live Agent System:** * Notifies an agent in the "Cancellation" queue. * Displays the user's account number to the agent. 7. **Human Agent:** "Hello, I see you'd like to cancel your subscription. I have your account number here. Can you please confirm your name and address?" **Key Considerations:** * **Cost:** Integrating with a live agent system can incur additional costs. * **Agent Availability:** Ensure that you have enough human agents available to handle the volume of hand-offs. * **Training:** Train your human agents on how to handle conversations that have been transferred from the bot. * **Security:** Ensure that sensitive information is handled securely during the hand-off process. * **Compliance:** Comply with all relevant regulations and privacy policies. * **Platform Limitations:** Be aware of the limitations of your chosen MCP and live agent system. **In summary, integrating a team of experts into your agent flow requires careful planning and configuration. By following the steps outlined above, you can create a seamless and efficient experience for your users.** To give you more specific guidance, please tell me: * **Which MCP are you using?** (e.g., Microsoft Copilot Studio, Dialogflow, Amazon Lex, Rasa, etc.) * **Which live agent system are you using (or planning to use)?** (e.g., Dynamics 365 Customer Service, Salesforce Service Cloud, Zendesk, etc.) * **What are the specific scenarios where you want to hand off to a human agent?** With more information, I can provide more tailored instructions.

Prometheus Alertmanager MCP Server

A Model Context Protocol (MCP) server that integrates with Prometheus Alertmanager

Modes MCP Server

Mirror of

Confluence Communication Server MCP Server

Espelho de

Postgers_MCP_for_AWS_RDS

É um servidor MCP para acessar o banco de dados PostgreSQL no AWS RDS.

Hello, MCP server.

Um servidor MCP básico.

Malaysia Prayer Time for Claude Desktop

Um servidor de Protocolo de Contexto de Modelo (MCP) para dados de Horários de Oração da Malásia.

Weather MCP Server

```python import socket import json import random import time # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) UPDATE_INTERVAL = 5 # Seconds between weather updates def generate_weather_data(): """Generates random weather data.""" temperature = round(random.uniform(10, 35), 1) # Temperature in Celsius humidity = random.randint(40, 90) # Humidity percentage wind_speed = random.randint(5, 25) # Wind speed in km/h conditions = random.choice(['Sunny', 'Cloudy', 'Rainy', 'Windy']) weather_data = { 'temperature': temperature, 'humidity': humidity, 'wind_speed': wind_speed, 'conditions': conditions } return weather_data def main(): """Main function to run the weather server.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Weather server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: weather_data = generate_weather_data() weather_json = json.dumps(weather_data) try: conn.sendall(weather_json.encode('utf-8')) print(f"Sent weather data: {weather_json}") except BrokenPipeError: print("Client disconnected.") break # Exit the loop if the client disconnects time.sleep(UPDATE_INTERVAL) if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** - `socket`: For network communication (creating a server). - `json`: For encoding Python dictionaries into JSON strings (for sending data). - `random`: For generating random weather data. - `time`: For pausing execution between weather updates. 2. **Configuration:** - `HOST`: The IP address the server will listen on. `'127.0.0.1'` is the loopback address (localhost), meaning the server will only be accessible from the same machine it's running on. - `PORT`: The port number the server will listen on. Choose a port number greater than 1023 to avoid needing special permissions. - `UPDATE_INTERVAL`: How often (in seconds) the server will generate and send new weather data. 3. **`generate_weather_data()` function:** - Creates a dictionary containing random weather information: - `temperature`: A random floating-point number between 10 and 35 (Celsius). - `humidity`: A random integer between 40 and 90 (percentage). - `wind_speed`: A random integer between 5 and 25 (km/h). - `conditions`: A random choice from a list of weather conditions. - Returns the dictionary. 4. **`main()` function:** - **Socket Creation:** - `with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:`: Creates a socket object. - `socket.AF_INET`: Specifies the IPv4 address family. - `socket.SOCK_STREAM`: Specifies a TCP socket (for reliable, connection-oriented communication). The `with` statement ensures the socket is properly closed when the block is finished. - **Binding:** - `s.bind((HOST, PORT))`: Associates the socket with the specified IP address and port. This tells the operating system that this server will listen for connections on that address and port. - **Listening:** - `s.listen()`: Puts the socket into listening mode, waiting for incoming connections. - **Accepting Connections:** - `conn, addr = s.accept()`: Accepts an incoming connection. This blocks until a client connects. - `conn`: A new socket object representing the connection to the client. You'll use this socket to send and receive data with the client. - `addr`: The address of the client (IP address and port). - **Communication Loop:** - `with conn:`: Ensures the client socket is closed when the loop finishes. - `while True:`: An infinite loop that continuously generates and sends weather data. - `weather_data = generate_weather_data()`: Generates new weather data. - `weather_json = json.dumps(weather_data)`: Converts the Python dictionary to a JSON string. - `conn.sendall(weather_json.encode('utf-8'))`: Sends the JSON string to the client. - `.encode('utf-8')`: Encodes the string into bytes using UTF-8 encoding (a common and widely compatible encoding). Sockets send and receive bytes, not strings. - `print(f"Sent weather data: {weather_json}")`: Prints the sent data to the console (for debugging). - `time.sleep(UPDATE_INTERVAL)`: Pauses execution for `UPDATE_INTERVAL` seconds before sending the next update. - **Error Handling:** The `try...except BrokenPipeError` block handles the case where the client disconnects unexpectedly. If the client disconnects, `conn.sendall()` will raise a `BrokenPipeError`. The `except` block catches this error, prints a message, and breaks out of the `while` loop, effectively stopping the server's attempt to send data to the disconnected client. - **`if __name__ == "__main__":`:** - This is a standard Python idiom. It ensures that the `main()` function is only called when the script is run directly (not when it's imported as a module into another script). **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `weather_server.py`). 2. **Run:** Open a terminal or command prompt and run the script: `python weather_server.py` 3. **Client:** You'll need a client program to connect to this server and receive the weather data. A simple client example (in Python) is provided below. **Example Client (Python):** ```python import socket import json HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) while True: try: data = s.recv(1024) # Receive up to 1024 bytes of data if not data: break # Server disconnected weather_json = data.decode('utf-8') weather_data = json.loads(weather_json) print(f"Received weather data: {weather_data}") except ConnectionResetError: print("Server disconnected.") break ``` **Client Explanation:** 1. **Imports:** `socket` and `json` (same as the server). 2. **Configuration:** `HOST` and `PORT` must match the server's configuration. 3. **Socket Creation and Connection:** - `s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)`: Creates a TCP socket. - `s.connect((HOST, PORT))`: Connects to the server at the specified address and port. 4. **Receiving Data:** - `while True:`: An infinite loop to continuously receive data. - `data = s.recv(1024)`: Receives up to 1024 bytes of data from the server. This blocks until data is received. - `if not data:`: Checks if `recv()` returned an empty byte string (`b''`). This indicates that the server has closed the connection. - `weather_json = data.decode('utf-8')`: Decodes the received bytes into a string using UTF-8. - `weather_data = json.loads(weather_json)`: Parses the JSON string into a Python dictionary. - `print(f"Received weather data: {weather_data}")`: Prints the received weather data. - **Error Handling:** The `try...except ConnectionResetError` block handles the case where the server disconnects unexpectedly. If the server disconnects, `s.recv()` will raise a `ConnectionResetError`. The `except` block catches this error, prints a message, and breaks out of the `while` loop. **To run the client:** 1. Save the client code as a Python file (e.g., `weather_client.py`). 2. Open a separate terminal or command prompt. 3. Run the client: `python weather_client.py` **Important Considerations:** * **Error Handling:** The server and client examples include basic error handling (checking for disconnections). In a real-world application, you'd want to add more robust error handling to deal with various network issues. * **Data Format:** JSON is a good choice for sending structured data over a network because it's human-readable and easy to parse. * **Threading/Asynchronous Programming:** For a more scalable server, consider using threads or asynchronous programming (e.g., `asyncio`) to handle multiple client connections concurrently. The simple example above only handles one client at a time. * **Security:** For production environments, consider security measures like encryption (e.g., using SSL/TLS) to protect the data being transmitted. * **MCP (Minecraft Protocol):** This example *simulates* a server. To actually integrate with Minecraft, you would need to implement the Minecraft protocol, which is significantly more complex. Libraries like `mcpi` (for Raspberry Pi) or `python-minecraft-protocol` can help with this, but they are beyond the scope of a simple example. This example provides the *data* that a Minecraft mod or plugin might use. **Portuguese Translation of the Explanation:** ``` Um exemplo de servidor MCP de clima em Python ```python import socket import json import random import time # Configuração HOST = '127.0.0.1' # Endereço de interface de loopback padrão (localhost) PORT = 65432 # Porta para escutar (portas não privilegiadas são > 1023) UPDATE_INTERVAL = 5 # Segundos entre as atualizações do clima def generate_weather_data(): """Gera dados climáticos aleatórios.""" temperature = round(random.uniform(10, 35), 1) # Temperatura em Celsius humidity = random.randint(40, 90) # Porcentagem de umidade wind_speed = random.randint(5, 25) # Velocidade do vento em km/h conditions = random.choice(['Sunny', 'Cloudy', 'Rainy', 'Windy']) weather_data = { 'temperature': temperature, 'humidity': humidity, 'wind_speed': wind_speed, 'conditions': conditions } return weather_data def main(): """Função principal para executar o servidor de clima.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor de clima escutando em {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Conectado por {addr}") while True: weather_data = generate_weather_data() weather_json = json.dumps(weather_data) try: conn.sendall(weather_json.encode('utf-8')) print(f"Dados climáticos enviados: {weather_json}") except BrokenPipeError: print("Cliente desconectado.") break # Sai do loop se o cliente desconectar time.sleep(UPDATE_INTERVAL) if __name__ == "__main__": main() ``` **Explicação:** 1. **Imports:** - `socket`: Para comunicação de rede (criação de um servidor). - `json`: Para codificar dicionários Python em strings JSON (para enviar dados). - `random`: Para gerar dados climáticos aleatórios. - `time`: Para pausar a execução entre as atualizações do clima. 2. **Configuração:** - `HOST`: O endereço IP que o servidor irá escutar. `'127.0.0.1'` é o endereço de loopback (localhost), o que significa que o servidor só estará acessível a partir da mesma máquina em que está sendo executado. - `PORT`: O número da porta que o servidor irá escutar. Escolha um número de porta maior que 1023 para evitar a necessidade de permissões especiais. - `UPDATE_INTERVAL`: Com que frequência (em segundos) o servidor irá gerar e enviar novos dados climáticos. 3. **Função `generate_weather_data()`:** - Cria um dicionário contendo informações climáticas aleatórias: - `temperature`: Um número de ponto flutuante aleatório entre 10 e 35 (Celsius). - `humidity`: Um inteiro aleatório entre 40 e 90 (porcentagem). - `wind_speed`: Um inteiro aleatório entre 5 e 25 (km/h). - `conditions`: Uma escolha aleatória de uma lista de condições climáticas. - Retorna o dicionário. 4. **Função `main()`:** - **Criação do Socket:** - `with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:`: Cria um objeto socket. - `socket.AF_INET`: Especifica a família de endereços IPv4. - `socket.SOCK_STREAM`: Especifica um socket TCP (para comunicação confiável e orientada à conexão). A instrução `with` garante que o socket seja fechado corretamente quando o bloco terminar. - **Vinculação (Binding):** - `s.bind((HOST, PORT))`: Associa o socket ao endereço IP e à porta especificados. Isso informa ao sistema operacional que este servidor irá escutar conexões nesse endereço e porta. - **Escuta (Listening):** - `s.listen()`: Coloca o socket no modo de escuta, aguardando conexões de entrada. - **Aceitação de Conexões:** - `conn, addr = s.accept()`: Aceita uma conexão de entrada. Isso bloqueia até que um cliente se conecte. - `conn`: Um novo objeto socket representando a conexão com o cliente. Você usará este socket para enviar e receber dados com o cliente. - `addr`: O endereço do cliente (endereço IP e porta). - **Loop de Comunicação:** - `with conn:`: Garante que o socket do cliente seja fechado quando o loop terminar. - `while True:`: Um loop infinito que continuamente gera e envia dados climáticos. - `weather_data = generate_weather_data()`: Gera novos dados climáticos. - `weather_json = json.dumps(weather_data)`: Converte o dicionário Python em uma string JSON. - `conn.sendall(weather_json.encode('utf-8'))`: Envia a string JSON para o cliente. - `.encode('utf-8')`: Codifica a string em bytes usando a codificação UTF-8 (uma codificação comum e amplamente compatível). Sockets enviam e recebem bytes, não strings. - `print(f"Dados climáticos enviados: {weather_json}")`: Imprime os dados enviados no console (para depuração). - `time.sleep(UPDATE_INTERVAL)`: Pausa a execução por `UPDATE_INTERVAL` segundos antes de enviar a próxima atualização. - **Tratamento de Erros:** O bloco `try...except BrokenPipeError` lida com o caso em que o cliente se desconecta inesperadamente. Se o cliente se desconectar, `conn.sendall()` lançará um `BrokenPipeError`. O bloco `except` captura esse erro, imprime uma mensagem e sai do loop `while`, efetivamente interrompendo a tentativa do servidor de enviar dados para o cliente desconectado. - **`if __name__ == "__main__":`:** - Este é um idioma Python padrão. Ele garante que a função `main()` seja chamada apenas quando o script for executado diretamente (não quando for importado como um módulo em outro script). **Como Executar:** 1. **Salvar:** Salve o código como um arquivo Python (por exemplo, `weather_server.py`). 2. **Executar:** Abra um terminal ou prompt de comando e execute o script: `python weather_server.py` 3. **Cliente:** Você precisará de um programa cliente para se conectar a este servidor e receber os dados climáticos. Um exemplo de cliente simples (em Python) é fornecido abaixo. **Exemplo de Cliente (Python):** ```python import socket import json HOST = '127.0.0.1' # O nome do host ou endereço IP do servidor PORT = 65432 # A porta usada pelo servidor with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) while True: try: data = s.recv(1024) # Recebe até 1024 bytes de dados if not data: break # Servidor desconectado weather_json = data.decode('utf-8') weather_data = json.loads(weather_json) print(f"Dados climáticos recebidos: {weather_data}") except ConnectionResetError: print("Servidor desconectado.") break ``` **Explicação do Cliente:** 1. **Imports:** `socket` e `json` (o mesmo que o servidor). 2. **Configuração:** `HOST` e `PORT` devem corresponder à configuração do servidor. 3. **Criação e Conexão do Socket:** - `s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)`: Cria um socket TCP. - `s.connect((HOST, PORT))`: Conecta-se ao servidor no endereço e porta especificados. 4. **Recebimento de Dados:** - `while True:`: Um loop infinito para receber dados continuamente. - `data = s.recv(1024)`: Recebe até 1024 bytes de dados do servidor. Isso bloqueia até que os dados sejam recebidos. - `if not data:`: Verifica se `recv()` retornou uma string de bytes vazia (`b''`). Isso indica que o servidor fechou a conexão. - `weather_json = data.decode('utf-8')`: Decodifica os bytes recebidos em uma string usando UTF-8. - `weather_data = json.loads(weather_json)`: Analisa a string JSON em um dicionário Python. - `print(f"Dados climáticos recebidos: {weather_data}")`: Imprime os dados climáticos recebidos. - **Tratamento de Erros:** O bloco `try...except ConnectionResetError` lida com o caso em que o servidor se desconecta inesperadamente. Se o servidor se desconectar, `s.recv()` lançará um `ConnectionResetError`. O bloco `except` captura esse erro, imprime uma mensagem e sai do loop `while`. **Para executar o cliente:** 1. Salve o código do cliente como um arquivo Python (por exemplo, `weather_client.py`). 2. Abra um terminal ou prompt de comando separado. 3. Execute o cliente: `python weather_client.py` **Considerações Importantes:** * **Tratamento de Erros:** Os exemplos de servidor e cliente incluem tratamento de erros básico (verificação de desconexões). Em uma aplicação do mundo real, você gostaria de adicionar um tratamento de erros mais robusto para lidar com vários problemas de rede. * **Formato de Dados:** JSON é uma boa escolha para enviar dados estruturados por uma rede porque é legível por humanos e fácil de analisar. * **Threading/Programação Assíncrona:** Para um servidor mais escalável, considere usar threads ou programação assíncrona (por exemplo, `asyncio`) para lidar com várias conexões de cliente simultaneamente. O exemplo simples acima lida apenas com um cliente por vez. * **Segurança:** Para ambientes de produção, considere medidas de segurança como criptografia (por exemplo, usando SSL/TLS) para proteger os dados que estão sendo transmitidos. * **MCP (Minecraft Protocol):** Este exemplo *simula* um servidor. Para realmente integrar com o Minecraft, você precisaria implementar o protocolo Minecraft, que é significativamente mais complexo. Bibliotecas como `mcpi` (para Raspberry Pi) ou `python-minecraft-protocol` podem ajudar com isso, mas estão além do escopo de um exemplo simples. Este exemplo fornece os *dados* que um mod ou plugin do Minecraft pode usar. ``` This provides a complete, runnable example with both server and client code, along with detailed explanations and considerations for real-world use. The Portuguese translation is also included. Remember to run the server *before* running the client.

GitHub MCP Server for Cursor IDE

GitHub MCP server for Cursor IDE

MCP-Forge

Uma ferramenta de scaffolding útil para servidores MCP (Minecraft Coder Pack).

Effect CLI - Model Context Protocol

MCP Servers, exposed as a CLI tool