Discover Awesome MCP Servers

Apple Shortcut Maker MCP

Enables AI assistants to create, duplicate, list, and run Apple Shortcuts using Cherri code via the Model Context Protocol.

Notebook MCP Server

Enables to create notebooks and notes with tags, and perform full-text search across notes using FTS5 syntax, all stored locally in SQLite.

odoo-mcp

Enables LLM agents to interact with Odoo 17 ERP via external API, providing tools for inventory management, sales order processing, and customer 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

Now MCP

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

OpenAlex MCP Server

Un servidor MCP (Protocolo de Contexto de Modelo) que se conecta a la API de OpenAlex.

Hello Golang MCP

Aquí tienes una implementación mínima de un servidor MCP en 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" "google.golang.org/grpc" ) var ( grpcPort = flag.Int("grpc-port", 18000, "grpc port") httpPort = flag.Int("http-port", 18001, "http port") ) // SimpleCallbacks is a simple implementation of the Callbacks interface. type SimpleCallbacks struct{} func (cb *SimpleCallbacks) OnStreamOpen(ctx context.Context, streamID int64, typ string) error { log.Printf("Stream opened with ID: %d, Type: %s\n", streamID, typ) return nil } func (cb *SimpleCallbacks) OnStreamClosed(streamID int64, typ string) { log.Printf("Stream closed with ID: %d, Type: %s\n", streamID, typ) } func (cb *SimpleCallbacks) OnStreamRequest(streamID int64, req *envoy.DiscoveryRequest) error { log.Printf("Request received on stream ID: %d, Type: %s, Resource Names: %v\n", streamID, req.GetTypeUrl(), req.GetResourceNames()) return nil } func (cb *SimpleCallbacks) OnStreamResponse(streamID int64, req *envoy.DiscoveryRequest, resp *envoy.DiscoveryResponse) { log.Printf("Response sent on stream ID: %d, Type: %s, Version: %s\n", streamID, req.GetTypeUrl(), resp.GetVersionInfo()) } func (cb *SimpleCallbacks) OnFetchRequest(ctx context.Context, req *envoy.DiscoveryRequest) error { log.Printf("Fetch request received, Type: %s, Resource Names: %v\n", req.GetTypeUrl(), req.GetResourceNames()) return nil } func (cb *SimpleCallbacks) OnFetchResponse(req *envoy.DiscoveryRequest, resp *envoy.DiscoveryResponse) { log.Printf("Fetch response sent, Type: %s, Version: %s\n", req.GetTypeUrl(), resp.GetVersionInfo()) } func main() { flag.Parse() // Create a cache snapshotCache := cache.NewSnapshotCache(true, cache.IDHash{}, nil) // Create a new MCP server srv := server.NewServer(context.Background(), snapshotCache, &SimpleCallbacks{}) // Create a gRPC server grpcServer := grpc.NewServer() envoy.RegisterAggregatedDiscoveryServiceServer(grpcServer, srv) // Start the gRPC server grpcListener, err := net.Listen("tcp", fmt.Sprintf(":%d", *grpcPort)) if err != nil { log.Fatalf("failed to listen: %v", err) } log.Printf("gRPC server listening on port %d\n", *grpcPort) go func() { if err := grpcServer.Serve(grpcListener); err != nil { log.Fatalf("failed to serve: %v", err) } }() // Create an HTTP server for health checks (optional) http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte("OK")) }) httpServer := &http.Server{Addr: fmt.Sprintf(":%d", *httpPort)} log.Printf("HTTP server listening on port %d\n", *httpPort) go func() { if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatalf("HTTP server failed: %v", err) } }() // Handle shutdown signals signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) <-signalChan log.Println("Shutting down...") // Gracefully stop the gRPC server grpcServer.GracefulStop() // Gracefully stop the HTTP server if err := httpServer.Shutdown(context.Background()); err != nil { log.Printf("HTTP server shutdown error: %v", err) } log.Println("Server stopped") } ``` **Explanation:** 1. **Imports:** Imports necessary packages, including `mcp-go` (specifically `github.com/envoyproxy/go-control-plane/pkg/cache/v3` and `github.com/envoyproxy/go-control-plane/pkg/server/v3`) and the Envoy protobuf definitions (`envoy`). Also includes standard Go packages for networking, logging, and signal handling. 2. **Flags:** Defines command-line flags for the gRPC and HTTP ports. 3. **`SimpleCallbacks`:** This struct implements the `server.Callbacks` interface. It's crucial for logging and potentially for more complex logic like authorization or request modification. The provided implementation simply logs events. You'll likely need to customize this for your specific needs. 4. **`main` function:** - **Parse Flags:** Parses the command-line flags. - **Create Cache:** Creates a `cache.SnapshotCache`. This cache holds the configuration data that the MCP server will serve to clients. The `cache.IDHash{}` is a simple ID hashing function. The `nil` is for a logger (you can provide a custom logger here). - **Create Server:** Creates a new MCP server using `server.NewServer`. It takes the context, the cache, and the callbacks as arguments. - **Create gRPC Server:** Creates a gRPC server and registers the MCP service with it. - **Start gRPC Server:** Starts the gRPC server in a goroutine. - **Create HTTP Server (Optional):** Creates a simple HTTP server for health checks. This is useful for monitoring and deployment. - **Start HTTP Server:** Starts the HTTP server in a goroutine. - **Signal Handling:** Sets up signal handling to gracefully shut down the server when it receives a SIGINT or SIGTERM signal. - **Graceful Shutdown:** Gracefully stops the gRPC and HTTP servers. **How to use it:** 1. **Install dependencies:** ```bash go get github.com/envoyproxy/go-control-plane@latest go get google.golang.org/grpc ``` 2. **Save the code:** Save the code as `main.go`. 3. **Run the server:** ```bash go run main.go ``` You can also specify the ports: ```bash go run main.go --grpc-port=9000 --http-port=9001 ``` **Important Considerations:** * **Configuration:** This is a *minimal* implementation. It doesn't actually *serve* any configuration. You'll need to add code to populate the `snapshotCache` with the configuration data you want to serve. This typically involves: * Defining the Envoy resources (e.g., listeners, routes, clusters) as protobuf messages. * Creating a `cache.Snapshot` containing these resources. * Calling `snapshotCache.SetSnapshot(context.Background(), nodeID, snapshot)` to update the cache. You'll need to determine the `nodeID` based on the client's identity. * **Node ID:** The `nodeID` is how the MCP server identifies the client. You'll need to implement a mechanism to determine the `nodeID` from the incoming requests. This might involve inspecting the `DiscoveryRequest` or using authentication. * **Error Handling:** The example has basic error handling, but you should add more robust error handling for production use. * **Security:** This example doesn't include any security measures (e.g., authentication, authorization, TLS). You'll need to add these for a production environment. * **Callbacks:** The `SimpleCallbacks` implementation is very basic. You'll likely need to customize it to handle events like request validation, authorization, and logging. * **mcp-go vs. xDS:** MCP is a superset of xDS. While this example uses the `envoy.RegisterAggregatedDiscoveryServiceServer` which is technically an xDS endpoint, you can extend it to support MCP-specific features like resource groups and selectors. **Example of setting a snapshot (Illustrative - requires defining Envoy resources):** ```go // ... inside the main function, after creating the snapshotCache import ( cluster "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3" core "github.com/envoyproxy/go-control-plane/envoy/config/core/v3" endpoint "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3" listener "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3" route "github.com/envoyproxy/go-control-plane/envoy/config/route/v3" hcm "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/network/http_connection_manager/v3" "github.com/envoyproxy/go-control-plane/pkg/cache/types" "github.com/envoyproxy/go-control-plane/pkg/cache/v3" "github.com/envoyproxy/go-control-plane/pkg/resource/v3" "github.com/envoyproxy/go-control-plane/pkg/wellknown" "google.golang.org/protobuf/types/known/anypb" ) // Helper function to create an Any protobuf func toAny(pb proto.Message) (*anypb.Any, error) { a := &anypb.Any{} err := a.MarshalFrom(pb) if err != nil { return nil, err } return a, nil } // Example resource definitions (replace with your actual configuration) clusterName := "my-cluster" listenerName := "my-listener" routeName := "my-route" // Create a cluster myCluster := &cluster.Cluster{ Name: clusterName, ConnectTimeout: ptypes.DurationProto(5 * time.Second), ClusterDiscoveryType: &cluster.Cluster_Type{Type: cluster.Cluster_STATIC}, LbPolicy: cluster.Cluster_ROUND_ROBIN, LoadAssignment: &endpoint.ClusterLoadAssignment{ ClusterName: clusterName, Endpoints: []*endpoint.LocalityLbEndpoints{{ LbEndpoints: []*endpoint.LbEndpoint{{ Endpoint: &endpoint.Endpoint{ Address: &core.Address{ Address: &core.Address_SocketAddress{ SocketAddress: &core.SocketAddress{ Protocol: core.SocketAddress_TCP, Address: "127.0.0.1", // Replace with your backend address PortSpecifier: &core.SocketAddress_PortValue{ PortValue: 8080, // Replace with your backend port }, }, }, }, }, }}, }}, }, } // Create a route myRoute := &route.RouteConfiguration{ Name: routeName, VirtualHosts: []*route.VirtualHost{{ Name: "my-virtual-host", Domains: []string{"*"}, Routes: []*route.Route{{ Match: &route.RouteMatch{ PathSpecifier: &route.RouteMatch_Prefix{ Prefix: "/", }, }, Action: &route.Route_Route{ Route: &route.RouteAction{ ClusterSpecifier: &route.RouteAction_Cluster{ Cluster: clusterName, }, }, }, }}, }}, } // Create an HTTP connection manager httpConnectionManager := &hcm.HttpConnectionManager{ CodecType: hcm.HttpConnectionManager_AUTO, StatPrefix: "ingress_http", RouteSpecifier: &hcm.HttpConnectionManager_RouteConfig{ RouteConfig: myRoute, }, HttpFilters: []*hcm.HttpFilter{{ Name: wellknown.Router, }}, } // Convert the HTTP connection manager to an Any protobuf httpConnectionManagerAny, err := toAny(httpConnectionManager) if err != nil { log.Fatalf("Error converting HTTP connection manager to Any: %v", err) } // Create a listener myListener := &listener.Listener{ Name: listenerName, Address: &core.Address{ Address: &core.Address_SocketAddress{ SocketAddress: &core.SocketAddress{ Protocol: core.SocketAddress_TCP, Address: "0.0.0.0", PortSpecifier: &core.SocketAddress_PortValue{ PortValue: 8081, // Replace with your desired listener port }, }, }, }, FilterChains: []*listener.FilterChain{{ Filters: []*listener.Filter{{ Name: wellknown.HTTPConnectionManager, ConfigType: &listener.Filter_TypedConfig{ TypedConfig: httpConnectionManagerAny, }, }}, }}, } nodeID := "my-node-id" // Replace with the actual node ID // Create a snapshot snapshot, err := cache.NewSnapshot( nodeID, map[resource.Type][]types.Resource{ resource.ClusterType: {myCluster}, resource.RouteType: {myRoute}, resource.ListenerType: {myListener}, }, ) if err != nil { log.Fatalf("Error creating snapshot: %v", err) } // Set the snapshot in the cache if err := snapshotCache.SetSnapshot(context.Background(), nodeID, snapshot); err != nil { log.Fatalf("Error setting snapshot: %v", err) } log.Printf("Snapshot set for node ID: %s\n", nodeID) ``` This example creates a simple cluster, route, and listener and sets them in the cache. **You'll need to adapt this to your specific configuration needs.** Remember to install the `google.golang.org/protobuf` and `github.com/golang/protobuf/ptypes` packages. This more complete example provides a starting point for building a functional MCP server. Remember to thoroughly understand the Envoy configuration model and the `mcp-go` library to create a robust and secure solution.

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.

Pinterest MCP Server

Enables image search and information retrieval from Pinterest using the Model Context Protocol. Supports searching by keywords, getting similar pins, and downloading images directly.

mcp-ensembl

Enables querying Ensembl genomic data including gene lookup, sequence retrieval, homology, variation, and variant effect prediction via MCP tools.

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.

kompa-mcp-server

Exposes Kompa social-listening data as callable MCP tools, enabling natural language queries for buzzes, sentiment trends, hot topics, and unique authors from any MCP client.

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.

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.

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

PhonePi MCP permite una integración perfecta entre las herramientas de IA de escritorio y tu teléfono inteligente, proporcionando más de 23 acciones directas que incluyen mensajería SMS, llamadas telefónicas, gestión de contactos, creación y búsqueda de fragmentos, uso compartido del portapapeles, notificaciones, comprobaciones del estado de la batería y controles remotos del 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.

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.