Discover Awesome MCP Servers

justdopeshop

Okay, here's a translation of "using Cursor and GitHub MCP server" into Portuguese, along with some context and options depending on what you're trying to convey: **General Translation:** * **Usando Cursor e servidor MCP do GitHub** This is a direct and generally accurate translation. It's suitable if you're simply stating that you are using these tools. **More Contextual Translations (depending on what you mean):** * **Se você estiver usando o Cursor e o servidor MCP do GitHub:** (If you are using Cursor and the GitHub MCP server:) - Use this if you are starting a conditional statement. * **Para usar o Cursor e o servidor MCP do GitHub:** (To use Cursor and the GitHub MCP server:) - Use this if you are explaining how to use them. * **Integração do Cursor com o servidor MCP do GitHub:** (Cursor integration with the GitHub MCP server:) - Use this if you are talking about the integration of the two. * **Configurando o Cursor para usar o servidor MCP do GitHub:** (Configuring Cursor to use the GitHub MCP server:) - Use this if you are talking about the configuration process. **Important Considerations:** * **"Cursor"** is likely referring to the Cursor IDE (an AI-powered code editor). The translation remains the same. * **"GitHub MCP server"** This is more specific. "MCP" likely stands for Minecraft Coder Pack. If you are talking about a specific server, you might want to include the name of the server. **Example Usage:** * "I am using Cursor and the GitHub MCP server for my Minecraft modding project." -> "Estou usando o Cursor e o servidor MCP do GitHub para o meu projeto de modding de Minecraft." **In summary, the best translation depends on the context of your sentence. The most direct translation is "Usando Cursor e servidor MCP do GitHub," but consider the other options if you need more nuance.**

Hello Golang MCP

Aqui está a implementação mínima de um servidor MCP em Golang usando mcp-go: ```go package main import ( "context" "flag" "fmt" "log" "net" "net/http" "os" "os/signal" "syscall" "github.com/envoyproxy/go-control-plane/pkg/cache/v3" "github.com/envoyproxy/go-control-plane/pkg/server/v3" "github.com/envoyproxy/go-control-plane/pkg/test/v3" "google.golang.org/grpc" ) var ( grpcPort = flag.Int("grpc-port", 18000, "grpc port") httpPort = flag.Int("http-port", 18001, "http port") ) // Define um snapshot simples com um único recurso. func generateSnapshot() cache.Snapshot { nodeID := "test-id" // Substitua por um ID de nó real se necessário // Exemplo de um recurso RouteConfiguration. Substitua por seus próprios recursos. routeConfig := test.MakeRoute("route-example", "local_service") snapshot, err := cache.NewSnapshot( "1", // version map[cache.Type][]cache.Resource{ cache.RoutesType: {routeConfig}, }, ) if err != nil { log.Fatalf("Erro ao criar o snapshot: %v", err) } if err := snapshot.Consistent(); err != nil { log.Fatalf("Snapshot inconsistente: %v", err) } log.Printf("Snapshot aprovado: %+v\n", snapshot) return snapshot } func main() { flag.Parse() ctx := context.Background() // 1. Crie um cache. snapshotCache := cache.NewSnapshotCache(true, cache.IDHash{}, nil) // 2. Crie um servidor MCP. srv := server.NewServer(ctx, snapshotCache, &test.Callbacks{}) // 3. Crie um servidor gRPC. grpcServer := grpc.NewServer() server.RegisterServer(grpcServer, srv) // 4. Crie um servidor HTTP (opcional, para health checks ou outras APIs). httpServer := &http.Server{ Addr: fmt.Sprintf(":%d", *httpPort), Handler: http.DefaultServeMux, } // 5. Inicie os servidores em goroutines separadas. go func() { lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *grpcPort)) if err != nil { log.Fatalf("falha ao escutar: %v", err) } log.Printf("Servidor gRPC escutando em: %s", lis.Addr()) if err := grpcServer.Serve(lis); err != nil { log.Fatalf("falha ao servir o servidor gRPC: %v", err) } }() go func() { log.Printf("Servidor HTTP escutando em: %s", httpServer.Addr) if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatalf("falha ao servir o servidor HTTP: %v", err) } }() // 6. Defina um snapshot inicial. snapshot := generateSnapshot() if err := snapshotCache.SetSnapshot(context.Background(), "test-id", snapshot); err != nil { log.Fatalf("Erro ao definir o snapshot: %v", err) } // 7. Lide com sinais de interrupção para desligamento gracioso. signalCh := make(chan os.Signal, 1) signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM) <-signalCh log.Println("Desligando...") // 8. Desligue os servidores. grpcServer.GracefulStop() if err := httpServer.Shutdown(ctx); err != nil { log.Fatalf("Erro ao desligar o servidor HTTP: %v", err) } log.Println("Servidor desligado.") } ``` **Explicação:** 1. **Importações:** Importa os pacotes necessários, incluindo `mcp-go` e pacotes relacionados do `go-control-plane`. 2. **Flags:** Define flags para configurar as portas gRPC e HTTP. 3. **`generateSnapshot()`:** Esta função cria um snapshot de configuração. É crucial entender que você precisa substituir o exemplo `test.MakeRoute` com a lógica para gerar seus próprios recursos (Clusters, Listeners, Routes, etc.) que você deseja servir através do MCP. O `nodeID` também deve ser configurado corretamente para corresponder aos IDs dos nós que estão solicitando configurações. 4. **`main()`:** - **Criação do Cache:** Cria um `SnapshotCache` para armazenar os snapshots de configuração. - **Criação do Servidor MCP:** Cria um servidor MCP usando `server.NewServer`. O terceiro argumento, `&test.Callbacks{}`, é um objeto que implementa a interface `server.Callbacks`. Você pode implementar seus próprios callbacks para lidar com eventos como conexões de clientes, solicitações de recursos e erros. Para uma implementação mínima, `&test.Callbacks{}` é suficiente. - **Criação do Servidor gRPC:** Cria um servidor gRPC e registra o servidor MCP nele. - **Criação do Servidor HTTP (Opcional):** Cria um servidor HTTP para health checks ou outras APIs. - **Início dos Servidores:** Inicia os servidores gRPC e HTTP em goroutines separadas. - **Definição do Snapshot Inicial:** Define um snapshot inicial no cache. Este é o ponto crucial onde você define a configuração que será servida aos clientes. O primeiro argumento para `SetSnapshot` é o contexto, o segundo é o ID do nó (que deve corresponder ao ID do nó que está solicitando a configuração), e o terceiro é o snapshot. - **Tratamento de Sinais:** Lida com sinais de interrupção (Ctrl+C) para desligamento gracioso. - **Desligamento:** Desliga os servidores gRPC e HTTP. **Como executar:** 1. **Instale as dependências:** ```bash go get github.com/envoyproxy/go-control-plane@v0.11.0 ``` 2. **Salve o código como `main.go`.** 3. **Execute o código:** ```bash go run main.go ``` **Pontos importantes:** * **Substitua o exemplo de recurso:** A parte mais importante é substituir o exemplo `test.MakeRoute` na função `generateSnapshot()` com a lógica para gerar seus próprios recursos (Clusters, Listeners, Routes, etc.) que você deseja servir através do MCP. * **ID do Nó:** Certifique-se de que o `nodeID` no `generateSnapshot()` corresponda ao ID do nó que está solicitando configurações. * **Callbacks:** Implemente seus próprios callbacks para lidar com eventos como conexões de clientes, solicitações de recursos e erros. * **Configuração:** Este é um exemplo mínimo. Você precisará adicionar lógica para carregar a configuração de um arquivo, banco de dados ou outra fonte. * **Versões:** Certifique-se de usar versões compatíveis do `go-control-plane` e `mcp-go`. O exemplo acima usa `go-control-plane@v0.11.0`. * **Segurança:** Este exemplo não inclui nenhuma segurança. Em um ambiente de produção, você precisará adicionar autenticação e autorização. Este exemplo fornece uma base sólida para construir um servidor MCP em Golang. Você precisará adaptá-lo às suas necessidades específicas.

Apifox MCP Pro

Provides basic diagnostic and information tools for Apifox API management platform, including token validation, project access checks, and explanations of API limitations due to Apifox's restricted Open API.

Agent Communication MCP Server

Enables AI agents to communicate with each other through Slack-like room-based channels with messaging, mentions, presence management, and long-polling for real-time collaboration.

LINE Bot MCP Server

Servidor MCP que integra a API de Mensagens do LINE para conectar um Agente de IA à Conta Oficial do LINE.

Twenty MCP

A remote MCP server that connects Claude to a Twenty CRM workspace, enabling users to interact with CRM objects (People, Companies, Opportunities, and custom objects) through schema-driven tools for querying, creating, updating, and deleting records.

pure.md MCP server

Um servidor MCP que permite que clientes de IA como Cursor, Windsurf e Claude Desktop acessem conteúdo da web em formato markdown, fornecendo recursos de desbloqueio da web e pesquisa.

genieacs-mcp

GenieACS-MCP is a Go-based MCP server that bridges any GenieACS (TR-069 ACS) instance, exposing device data, firmware management, and CPE actions (reboot, parameter refresh, firmware download) over JSON-RPC

Weather MCP Server

Enables real-time weather queries for cities worldwide using Open-Meteo API. Provides 7-day forecasts with detailed information including temperature, wind, humidity, precipitation, and comfort level assessments in both Chinese and English.

RTFD (Read The F*****g Docs)

Provides LLMs with real-time access to up-to-date documentation from PyPI, npm, crates.io, GoDocs, DockerHub, GitHub, and GCP, preventing outdated code generation and API hallucinations.

Azure Impact Reporting MCP Server

Enables large language models to automatically report customer-facing issues with Azure resources by parsing natural language requests and submitting impact reports through the Azure Management API.

Jarvis MCP Server

Integrates Claude with n8n and Supabase to provide semantic memory search, automated workflow orchestration, and multi-platform task creation. It enables persistent interaction storage and autonomous agent capabilities through a production-ready HTTP interface.

🔍 mcp-find

Para procurar servidores MCP (Minecraft Protocol) a partir da linha de comando, você pode usar algumas ferramentas e abordagens diferentes, dependendo do que você quer fazer exatamente: **1. Usando `nmap` (para verificar se uma porta está aberta):** Esta é a maneira mais básica de verificar se um servidor Minecraft (que usa o protocolo MCP) está rodando em um determinado endereço IP e porta. `nmap` é um scanner de rede poderoso. * **Instale `nmap`:** * **Linux (Debian/Ubuntu):** `sudo apt-get install nmap` * **Linux (Fedora/CentOS/RHEL):** `sudo yum install nmap` ou `sudo dnf install nmap` * **macOS:** `brew install nmap` (se você tiver o Homebrew instalado) * **Windows:** Baixe o instalador do site oficial: [https://nmap.org/download.html](https://nmap.org/download.html) * **Use `nmap` para verificar a porta padrão do Minecraft (25565):** ```bash nmap -p 25565 <endereço_ip> ``` Substitua `<endereço_ip>` pelo endereço IP do servidor que você quer verificar. Por exemplo: ```bash nmap -p 25565 192.168.1.100 ``` A saída mostrará se a porta 25565 está aberta (o que sugere que um servidor Minecraft está rodando) ou fechada. * **Verificando uma porta diferente:** Se o servidor estiver rodando em uma porta diferente, substitua `25565` pela porta correta. **Limitações do `nmap`:** * `nmap` apenas verifica se a porta está aberta. Ele não fornece informações sobre o servidor Minecraft (nome, jogadores online, versão, etc.). **2. Usando ferramentas específicas para Minecraft (mais avançado):** Para obter informações mais detalhadas sobre o servidor, você precisará de ferramentas que entendam o protocolo Minecraft. Existem algumas opções, mas muitas vezes exigem programação ou scripts. * **Python com a biblioteca `mcstatus`:** Esta é uma abordagem mais flexível e poderosa. Você pode usar a biblioteca `mcstatus` do Python para consultar o servidor e obter informações detalhadas. * **Instale o Python (se você ainda não tiver):** Certifique-se de ter o Python 3 instalado. * **Instale a biblioteca `mcstatus`:** ```bash pip install mcstatus ``` * **Crie um script Python (exemplo):** ```python from mcstatus import JavaServer server_address = "meu.servidor.minecraft.com" # Substitua pelo endereço do servidor try: server = JavaServer.lookup(server_address) status = server.status() print(f"Servidor: {server_address}") print(f"Versão: {status.version.name}") print(f"Jogadores online: {status.players.online} / {status.players.max}") print(f"Descrição: {status.description}") except Exception as e: print(f"Erro ao consultar o servidor: {e}") ``` Salve este código em um arquivo (por exemplo, `verificar_servidor.py`) e execute-o: ```bash python verificar_servidor.py ``` Este script irá consultar o servidor e exibir informações como a versão do Minecraft, o número de jogadores online e a descrição do servidor. * **Outras bibliotecas e ferramentas:** Existem outras bibliotecas e ferramentas em diferentes linguagens de programação que podem fazer o mesmo. Pesquise por "Minecraft server query library" na sua linguagem de programação preferida. **3. Usando ferramentas de linha de comando existentes (se disponíveis):** Algumas ferramentas de terceiros podem já existir para consultar servidores Minecraft a partir da linha de comando. A disponibilidade e a funcionalidade dessas ferramentas variam. Pesquise online por "Minecraft server query command line tool" para ver se encontra alguma que atenda às suas necessidades. **Resumo:** * Para uma verificação rápida da porta, use `nmap`. * Para obter informações detalhadas sobre o servidor, use a biblioteca `mcstatus` do Python (ou uma biblioteca similar em outra linguagem). * Pesquise por ferramentas de linha de comando específicas para Minecraft, mas esteja ciente de que a disponibilidade pode ser limitada. Lembre-se de substituir os exemplos de endereços IP e nomes de servidor pelos valores corretos para o servidor que você deseja consultar. Além disso, certifique-se de ter as permissões necessárias para acessar o servidor.

HAP MCP Server

A Model Context Protocol server that provides seamless integration with Mingdao platform APIs, enabling AI applications to perform operations like worksheet management, record manipulation, and role management through natural language.

Remote MCP Server for Cloudflare

A deployable server that implements the Model Context Protocol (MCP) on Cloudflare Workers, enabling integration of custom tools with AI assistants like Claude without requiring authentication.

roslyn-codelens-mcp

Roslyn-based MCP server providing semantic code intelligence for .NET codebases — type hierarchies, call sites, DI registrations, and reflection usage for Claude Code

MCP Aruba Email & Calendar Server

Enables AI assistants to access Aruba email and calendar services through IMAP, SMTP, and CalDAV protocols. Users can list, search, and send emails with custom signatures, as well as manage calendar events and invitations.

Dedalus MCP Documentation Server

Enables serving and querying documentation with AI capabilities, allowing users to search, ask questions, and get AI-powered answers from their documentation files. Built for seamless deployment on the Dedalus platform with OpenAI integration for enhanced document analysis.

Nextflow Developer Tools MCP

Um servidor de Protocolo de Contexto de Modelo (Model Context Protocol) projetado para facilitar o desenvolvimento e teste do Nextflow, fornecendo ferramentas para construir a partir do código fonte, executar testes e gerenciar o ambiente de desenvolvimento do Nextflow.

@deva-me/mcp-server

Provides a comprehensive suite of tools for agents to access Deva Agent Resources, including social networking, AI-powered generation, web search, and file storage. It supports automated USDC payment flows for paid resources and integrates with major MCP clients like Claude Desktop and Cursor.

SeaTable MCP

The official Model Context Protocol (MCP) server for SeaTable, built and maintained by SeaTable GmbH. It lets AI agents interact with data in your bases — reading, writing, searching, linking, and querying rows through a focused set of tools. The server intentionally focuses on data operations, not schema management (creating/deleting tables or columns), keeping the tool set lean and safe for auto

Remote MCP Server Authless

A serverless MCP (Model Context Protocol) implementation on Cloudflare Workers that allows you to deploy custom AI tools without requiring authentication.

MCP Workshop Starter

A starter kit for building Model Context Protocol servers that enables AI tools to access external data and functionalities like checking holidays, disk space, timezones, RSS feeds, code diffs, and web performance metrics.

Opinion.trade MCP Server

Enables interaction with Opinion.trade decentralized prediction markets on BNB Chain, supporting market data queries in read-only mode and full trading capabilities (placing orders, managing positions, viewing balances) with EIP712 signing when configured with a private key.

MCP Memory Keeper

Provides persistent context management for Claude AI coding assistants, allowing you to save and restore conversation context, create checkpoints, and organize information across sessions to prevent losing important work history and decisions during long coding sessions.

Playwright MCP Server for Security

Enables LLMs to perform browser automation tasks including web scraping, taking screenshots, and executing JavaScript using Playwright. It facilitates real-time interaction with web pages and the generation of automated test code.

MCP-Codex: Model Context Protocol Tool Orchestration

Um servidor MCP para chamar ferramentas MCP remotamente sem exigir instalação.

Freesound MCP Server

An MCP server that enables AI assistants to search, analyze, and retrieve information about audio samples from Freesound.org through their API.