Discover Awesome MCP Servers

Brave Real Browser MCP Server

Enables advanced browser automation using real Brave Browser with 49 tools for web scraping, content extraction, video downloads, CAPTCHA solving, and anti-detection features. Includes automatic Brave installation, built-in ad-blocking with uBlock Origin, and support for complex scenarios like bypassing Cloudflare protection.

mcp-server-diceroll

fumievalさんのパクリ

Rippling MCP Server

Connects AI agents to the Rippling HR/IT/Finance platform to query employees, manage leave requests, and view organizational structures. It provides eighteen tools for accessing company data, employee details, and administrative activities through the Rippling API.

paperless-mcp-go

Search, read, (bulk) edit the documents and metadata in your Paperless NGX instance.

TenderAI

An MCP server that automates government and enterprise tender workflows, including RFP parsing, proposal generation, and compliance tracking. It provides 18 specialized tools for technical and financial proposal assembly, partner coordination, and hybrid search across past proposal archives.

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.

MCPSora

OpenAI Sora AI video generation with text-to-video, image-to-video, character reuse across scenes, and async webhook callbacks.

Brokerage-MCP

A Model Context Protocol server built with the mcp-framework designed to provide brokerage-related tools and functionality. It allows users to integrate financial brokerage services and data into the MCP ecosystem.

Local MCP Test Server

A local testing MCP server that provides weather information for L'Hospitalet de Llobregat using the Open-Meteo API, accessible from mobile devices via SSE transport on local networks.

contentstack-mcp

contentstack-mcp

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.

cortex-mcp

Calendar MCP server with atomic booking, conflict prevention, deterministic RRULE expansion, and TOON token compression for AI agents.

MCP Server F1Data

Enables interaction with Formula 1 data through LLM interfaces like Claude. Provides access to F1 information including circuits, constructors, drivers, grand prix, manufacturers, races, and seasons.

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.

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.

librarian

An MCP server that enables LLMs to search, summarize, and retrieve detailed information from Wikipedia across multiple languages. It supports automated fact-checking by allowing models to proactively verify factual claims using Wikipedia's database.

mcp-scholar

"mcp\_scholar" es una herramienta basada en Python para buscar y analizar artículos de Google Scholar, que admite funciones como búsquedas basadas en palabras clave e integración con clientes MCP y Cherry Studio. Proporciona funcionalidades como obtener los artículos más citados de los perfiles de Scholar y resumir las principales investigaciones.

LINE Bot MCP Server

Servidor MCP que integra la API de mensajería de LINE para conectar un Agente de IA a la Cuenta Oficial de LINE.

CodeGraphContext

Indexes local Python code into a Neo4j graph database to provide AI assistants with deep code understanding and relationship analysis. Enables querying code structure, dependencies, and impact analysis through natural language interactions.

MCP Memory

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

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

Date and Time MCP Server

A simple Model Context Protocol (MCP) server that provides date and time functionality in any timezone, along with user profiles and personalized greeting resources.

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

Un servidor de Protocolo de Contexto de Modelo diseñado para facilitar el desarrollo y las pruebas de Nextflow, proporcionando herramientas para construir desde el código fuente, ejecutar pruebas y gestionar el entorno de desarrollo de 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.