Discover Awesome MCP Servers

Airtable MCP

Permite que aplicações com tecnologia de IA acessem e manipulem dados do Airtable diretamente do seu IDE, suportando operações como consultar, criar, atualizar e excluir registros através de comandos em linguagem natural.

OpenRPC MCP Server

Um servidor de Protocolo de Contexto de Modelo (MCP) que fornece funcionalidade JSON-RPC através de OpenRPC.

Lens Protocol MCP Server

Enables AI tools to interact with the Lens Protocol decentralized social network ecosystem. Supports fetching profiles, posts, followers, searching content, and accessing social graph data through standardized MCP interfaces.

Hiworks Mail MCP

A Model Context Protocol server that allows integration with Hiworks mail system to search, read, and send emails with support for text, HTML, and attachments.

Keka MCP Server

Integrates with Keka HR platform to manage employee profiles, attendance, leave applications, payslips, and holidays through OAuth2-authenticated API tools.

MCP Chart Server

A Model Context Protocol server that generates TradingView chart visualizations with real-time updates, enabling AI assistants to create and display financial charts through an integration with Chart-IMG API.

Imagician

Enables comprehensive image editing operations including resizing, format conversion, cropping, compression, rotation, flipping, and batch processing. Supports JPEG, PNG, WebP, and AVIF formats with quality control and metadata extraction.

PocketBase MCP Server

A comprehensive server that enables interaction with PocketBase databases through the Model Context Protocol, providing authentication, collection management, record operations, file handling, and administrative functionality.

MCPfinder Server

Enables AI assistants to discover, retrieve details about, and manage MCP (Model Context Protocol) servers that provide additional tools and capabilities on demand.

Remote MCP Server on Cloudflare

Um servidor para hospedar ferramentas do Protocolo de Contexto de Modelo (MCP) no Cloudflare Workers com autenticação OAuth, permitindo que o Claude AI e outros clientes MCP acessem capacidades estendidas.

MCP Example

Servidor de demonstração MCP

OpenAI Agents MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite aos usuários do Claude acessar agentes especializados da OpenAI (pesquisa na web, pesquisa de arquivos, ações no computador) e um orquestrador multi-agente através do protocolo MCP.

Cloud Filestore API MCP Server

An MCP server that enables interaction with Google Cloud Filestore API, allowing management of Filestore instances, backups, and shares through natural language commands.

MCP Server

A configurable server implementation that provides MCP (Model-Controller-Protocol) functionality, supporting both Node.js and Docker environments with automated setup and configuration options.

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.

Neva

SDK do servidor MCP para Rust

mcp-bauplan

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

MCP-LinkedIn

Dynamic tools to automate tasks on LinkedIn website.

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.

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-server-diceroll

fumievalさんのパクリ

Public MCP Server

A basic Model Context Protocol (MCP) server implementation that provides a foundation for MCP server development. The README doesn't specify particular functionality, suggesting it may be a template or starting point for building custom MCP servers.

Aptly MCP Server

Enables AI assistants to manage Debian package repositories through natural language using the Aptly package management tool. Supports repository creation, package operations, snapshot management, publishing, and mirror synchronization.

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.

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.

mcp-scholar

"mcp\_scholar" é uma ferramenta baseada em Python para pesquisar e analisar artigos do Google Scholar, com suporte a recursos como buscas baseadas em palavras-chave e integração com clientes MCP e Cherry Studio. Ela oferece funcionalidades como buscar os artigos mais citados de perfis do Scholar e resumir as principais pesquisas.

LINE Bot MCP Server

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

MCP Memory

A server that gives MCP clients (Cursor, Claude, Windsurf, etc.) the ability to remember user information across conversations using vector search technology.