Discover Awesome MCP Servers

Kubecost MCP Server

An implementation that enables AI assistants to interact with Kubecost cost management platform through natural language, providing access to budget management and cost analysis features.

Agentic Commerce MCP Demo

Enables interactive restaurant discovery and ordering through a synthetic commerce flow with rich HTML UI. Demonstrates agentic commerce UX with tools to find restaurants, view menus, place mock orders, and generate receipts.

mcp-bauplan

Um servidor MCP para interagir com dados e executar pipelines usando Bauplan.

Graphiti Knowledge Graph MCP Server

Enables AI assistants to build and query temporally-aware knowledge graphs from conversations and data. Supports adding episodes, searching entities and facts, and maintaining persistent memory across interactions.

MCP OpenAPI Proxy

A tool that accelerates MCP protocol adoption by automatically generating MCP-compatible server components from OpenAPI specifications, enabling seamless integration with existing services as a sidecar.

Neva

SDK do servidor MCP para Rust

MCP-LinkedIn

Dynamic tools to automate tasks on LinkedIn website.

Grasp

An open-source self-hosted browser agent that provides a dockerized browser environment for AI automation, allowing other AI apps and agents to perform human-like web browsing tasks through natural language instructions.

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.

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.

PhonePi MCP

O PhonePi MCP permite uma integração perfeita entre as ferramentas de IA do seu computador e seu smartphone, oferecendo mais de 23 ações diretas, incluindo mensagens SMS, chamadas telefônicas, gerenciamento de contatos, criação e pesquisa de snippets, compartilhamento de área de transferência, notificações, verificações de status da bateria e controles remotos do dispositivo.

Model Context Protocol Python Server

A Python implementation of the Model Context Protocol (MCP) server that enables searching and extracting information from arXiv papers, designed to be extensible with additional MCP tools.

Random Number MCP

Production-ready MCP server that provides LLMs with essential random generation abilities, including random integers, floats, choices, shuffling, and cryptographically secure tokens.

OpenAlex MCP Server

Um servidor MCP (Protocolo de Contexto de Modelo) que se conecta à API OpenAlex.

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.

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.

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.

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.**

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.

All-in-One Dev

Protocolo de Contexto de Modelo Tudo-Em-Um: qdrant, Google Suite (Gmail, Agenda, ...), Jira, GitLab, CLI, ...

Terminally MCP

An MCP server that gives AI assistants the ability to create, manage, and control terminal sessions through a safe, isolated tmux environment.

MCP Documentation Server

Um servidor MCP personalizado que permite a integração entre aplicações LLM e fontes de documentação, fornecendo acesso assistido por IA à documentação do LangGraph e do Protocolo de Contexto de Modelo (MCP).

🔍 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.

File System Explorer MCP Server

A beginner-friendly MCP server that enables AI to explore file systems through tools for listing directories, reading files, searching with wildcards, and getting file metadata. Perfect for learning MCP development while providing practical file system interaction capabilities.

BCRP-MCP

Model Context Protocol server that provides access to economic and financial time series data from Peru's Central Reserve Bank, enabling AI agents to search, explore, and analyze Peru's economic indicators through a standardized interface.

Superstore MCP Server

Enables interaction with Real Canadian Superstore to extract order history, browse products, and export purchase data. Supports authentication via bearer token and provides comprehensive order management and product discovery capabilities.

Memory Bank MCP

Um servidor MCP que ajuda equipes a criar, gerenciar e acessar documentação de projeto estruturada através de seis tipos de documentos principais, utilizando IA para gerar um gerenciamento abrangente do conhecimento do projeto.

Web Browser

Habilita capacidades de navegação na web usando BeautifulSoup4.