Discover Awesome MCP Servers

Looping Agent MCP

Turns a manager's plain-English goal into a verified, looped, watchable build run driven by the IDE's agent, without SDK.

ProductPilot MCP

An MCP server that helps digital product creators go from idea to a zipped, listing-ready product — including market research, product generation, SEO, listing copy, pricing, and Gumroad/Etsy preparation.

appmetrica-mcp

MCP server for Yandex AppMetrica analytics, enabling Claude to access reports, raw event logs, crash data, and push notification campaigns.

Gadget MCP Server

A read-only MCP server that enables querying and introspection of any Gadget app via GraphQL. It allows users to list models, inspect fields, and fetch records directly within AI tools like Claude and Cursor.

Cherry Studio Task Board

Provides Kanban, Gantt, list views, multi-project management, and archiving for task management via MCP protocol, enabling Cherry Studio Agent to create, update, query, and organize tasks.

PaperPilot-AI

MCP server for semantic research: search arXiv, fetch papers, and answer questions grounded in the actual paper text via RAG tools, resources, and prompts.

HaiveControl MCP Server

Enables AI clients to view screens, run commands, and transfer files across a fleet of LAN-connected devices through a single MCP interface.

vm-forgeyard MCP

HTTP MCP adapter for requesting VMs and inspecting state. Part of the vm-forgeyard KVM control plane for test and development virtual machines.

mcp-kroger

Enables AI agents to search products, manage shopping carts, clip digital coupons, check fuel points, schedule delivery/pickup, and place grocery orders with Kroger.

opensearch-mcp-server-py

MCP server for OpenSearch that enables AI assistants to interact with OpenSearch clusters through a standardized interface for search, index management, and cluster operations.

industry4-mcp

MCP server that bridges industrial IoT data with conversational AI, enabling natural language queries to machine health telemetry through ChatGPT.

dwolla-mcp

Enables AI agents to retrieve and analyze Dwolla payment platform data using natural language, with read-only access to accounts, transfers, customers, and compliance information.

cadloop-openscad

Enables parametric CAD modeling using OpenSCAD via MCP, supporting syntax checking, rendering, measuring, and previewing within a sandboxed workspace.

parley

Enables token-efficient browser automation for AI chats like ChatGPT, Gemini, and Claude, allowing reading responses, sending messages, waiting for streaming replies, and bridging conversations between tabs via Chrome DevTools Protocol.

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.

UnoPim MCP Server

Enables Claude to manage the UnoPim Product Information Management system through natural language, supporting product creation, attribute management, and media uploads. It features full API integration, including support for configurable products and automatic OAuth2 token management.

Malware Analysis MCP Server

Enables AI assistants to access real-time threat intelligence, malware sample metadata, and security analysis tools via integration with MalwareBazaar, VirusTotal, and Telegram.

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.

Jobs MCP Server

A Node.js and TypeScript server that enables searching for job listings and accessing job market statistics via the Model Context Protocol. It provides tools for job queries and arithmetic operations alongside resources for featured listings and market data.

indie-metrics-mcp

MCP server that gives AI assistants real-time access to Stripe business metrics like MRR, churn, and revenue forecasts via natural language queries.

Now MCP

Provides time-related tools including current time retrieval, timezone conversion, time formatting, and timezone info via MCP.

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.

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.

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.

mcp-server-robinhood-chain

An MCP server providing EVM-native on-chain trading intelligence for Robinhood Chain (chain id 4663), including real-time KOL trades, DEX trade tape, token discovery, and deployer reputation.

GitHub Style Markdown Preview MCP App

Enables the previewing of GitHub Flavored Markdown (GFM) as an MCP application. It provides a tool to render and visualize Markdown content using authentic GitHub styling and CSS.

WSO2 Docs MCP Server

Enables AI assistants to semantically search WSO2 documentation across multiple products using retrieval-augmented generation, with support for local or cloud embeddings.

MCP Learning Server

A beginner-friendly MCP server built in plain Node.js/JavaScript that exposes five tools (calculator, UUID generator, read notes, get weather, password generator) to teach how the Model Context Protocol works under the hood.