Discover Awesome MCP Servers

ShipMCP

Enables LLMs to understand and work with shipbuilding terminology (Korean/English), including search, translation, and explanation of terms across 14 categories with 364 terms.

VibeCheck

An AI-powered MCP server that automates web testing workflows by enabling recording, execution, and discovery of tests through natural language prompts.

tuma250-mcp

Enables AI clients to search products, manage shopping carts, and browse order history on the Tuma 250 grocery site in Kigali, Rwanda.

node-opcua-modeler-mcp-server

Provides AI agents with offline access to OPC UA companion specification types, dependencies, and engineering units for industrial modeling.

mcp-arcgis-houston

This MCP server provides access to City of Houston GIS open geospatial data, enabling search, query, and schema retrieval of datasets like parcels and zoning through ArcGIS feature services.

livewire-flux-mcp

MCP server that provides access to Livewire Flux components and layouts documentation, enabling AI assistants to fetch and search through documentation on demand.

AndroidBuildMCP

Enables AI agents to build, deploy, drive, and debug Android apps — managing Gradle builds, emulators, adb deployment, logcat capture, and full UI automation.

Google Drive MCP Server

Enables interaction with Google Drive files and Google Sheets through search, read, and write operations. Supports automatic conversion of Google Workspace files to readable formats and direct spreadsheet cell updates.

R2 Bucket MCP

Enables file operations (upload, download, list, delete) on Cloudflare R2 (S3-compatible) storage, with dedicated APK upload tool.

MCPCloud

A self-hosted MCP gateway that lets you write Python functions and register them as skills to be used as tools by any MCP-compatible client like Claude Desktop or Claude API.

OpenWeb Ninja MCP

Official MCP server for OpenWeb Ninja: 40+ real-time web data and SERP APIs (Google Maps, Amazon, jobs, Zillow, Trustpilot, web search, news, finance) exposed as MCP tools.

ggui

Enables AI agents to generate and serve ephemeral, interactive user interfaces over MCP through natural language descriptions.

Lex: Luxembourg Law MCP Server

Point-in-time access to Luxembourg law and ten EU acts: what any law said on a given date, not just the current text. 1,409 consolidated works and 4,705 dated versions from the official Legilux and EUR-Lex sources. Ten read-only tools: as-of text, timelines, per-article history, diffs between dates, and hash-verifiable provenance. No key.

sql-assistant-mcp

A Model Context Protocol (MCP) server for SQL Server / Azure SQL that enables querying, monitoring, and analyzing databases directly from Claude.

xrpldashboard MCP

Read-only XRP Ledger analytics — signed snapshots, AMM pools, token volume, whale activity, NFT tracking. Proof-annotated. Public beta 2026-09.

nanobanana-mcp

MCP server for AI image generation supporting text-to-image and image-to-image editing via any OpenAI-compatible service, with configurable models, aspect ratios, and sizes.

MCP Maximo Server

Wraps IBM Maximo API services as MCP tools, enabling AI applications like Dify Agent to manage assets, work orders, and inventory through natural language interactions with enterprise asset management systems.

Flightradar24 MCP Server (Cloud Run)

Wraps the official Flightradar24 MCP Server to expose it over HTTP/SSE for remote access, enabling MCP-compatible clients to query flight tracking data with client-provided API keys.

narajangteo-pro

Integrates 6 Korean public procurement APIs to search, analyze, and manage procurement data using natural language.

furl-ctx

Furl folds repeated tool output into a hash-addressed marker, keeps the line that matters, and returns any original byte-exact the moment the agent asks for it. No summary. No guessing. Nothing thrown away.

code-context-mcp

Indexes codebases into a SQLite database to provide metadata, exports, dependency graphs, and change tracking for JS/TS projects. It enables users to search for symbols, map internal dependencies, and monitor file changes through MCP tools and a web dashboard.

MCP Standardized Tool Demo

A Node.js-based MCP server that extracts numbers from text and generates statistical chart data such as bar, pie, and line charts based on frequency. It enables AI agents to perform data extraction and visualization tasks through the Model Context Protocol.

Company Records

Exposes a fictional B2B CRM database (companies, contacts, deals) as callable MCP tools, enabling AI agents to answer natural-language questions about company records, contacts, and pipeline data.

nstbrowser-playwright-mcp

Combines NSTBrowser profile management with Playwright browser automation via CDP, enabling browser automation through NSTBrowser profiles.

keygenix-mcp

Non-custodial TEE key management and signing for AI agents, supporting multiple blockchains.

Web Search MCP Server

Provides web search capabilities using the Tavily API, enabling AI models to search the internet and retrieve up-to-date information.

arcgis-grandchute

Enables AI agents to search and query Town of Grand Chute, Wisconsin open geospatial datasets (parcels, zoning, public works) via ArcGIS Feature Services.

SQL MCP Server Demo

Provides read-only access to SQL Server databases via Data API Builder, with tools to describe entities, read records, and aggregate data through the Model Context Protocol.

MCP server for Azure Cosmos DB using the Go SDK

Okay, I will provide a sample implementation of an MCP (Management Control Plane) server for Cosmos DB built using the Go SDK. This is a simplified example to illustrate the core concepts. A production-ready MCP would require more robust error handling, authentication, authorization, monitoring, and configuration management. **Important Considerations:** * **Authentication/Authorization:** This example omits authentication and authorization for brevity. In a real-world scenario, you *must* implement secure authentication (e.g., using API keys, OAuth, or Azure Active Directory) and authorization to control access to your Cosmos DB resources. * **Error Handling:** The error handling is basic. You should implement more comprehensive error logging, retry mechanisms, and potentially circuit breakers. * **Configuration:** The Cosmos DB endpoint and key are hardcoded. Use environment variables or a configuration file for production. * **Idempotency:** MCP operations should ideally be idempotent. This means that if an operation is retried, it should have the same effect as if it were executed only once. Consider using unique request IDs to ensure idempotency. * **Monitoring:** Implement monitoring and logging to track the health and performance of your MCP. * **Rate Limiting:** Cosmos DB has rate limits. Implement appropriate retry logic and consider using request units (RUs) effectively. **Code Example (Go):** ```go package main import ( "context" "encoding/json" "fmt" "log" "net/http" "os" "time" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos" ) // Configuration (replace with environment variables or config file) const ( cosmosDBEndpoint = "YOUR_COSMOSDB_ENDPOINT" // e.g., "https://your-cosmosdb.documents.azure.com:443/" cosmosDBKey = "YOUR_COSMOSDB_KEY" // Replace with your Cosmos DB key databaseName = "MyDatabase" containerName = "MyContainer" ) // Item represents a sample Cosmos DB item. type Item struct { ID string `json:"id"` Name string `json:"name"` Description string `json:"description"` } // createCosmosClient creates a Cosmos DB client. func createCosmosClient() (*azcosmos.Client, error) { // Use Azure Identity for authentication (preferred in Azure environments) cred, err := azidentity.NewDefaultAzureCredential(nil) if err == nil { client, err := azcosmos.NewClient(cosmosDBEndpoint, cred, nil) if err != nil { return nil, fmt.Errorf("failed to create Cosmos DB client with Azure Identity: %w", err) } return client, nil } // Fallback to key-based authentication (less secure, use only for development/testing) client, err := azcosmos.NewClientWithKey(cosmosDBEndpoint, cosmosDBKey, nil) if err != nil { return nil, fmt.Errorf("failed to create Cosmos DB client with key: %w", err) } return client, nil } // createDatabase creates a Cosmos DB database if it doesn't exist. func createDatabase(ctx context.Context, client *azcosmos.Client, databaseName string) (*azcosmos.DatabaseClient, error) { databaseClient, err := client.NewDatabase(databaseName) if err != nil { return nil, fmt.Errorf("failed to get database client: %w", err) } _, err = databaseClient.Read(ctx, nil) if err != nil { if azcosmos.IsErrorStatusCode(err, http.StatusNotFound) { // Database doesn't exist, create it _, err = client.CreateDatabase(ctx, azcosmos.DatabaseProperties{ID: databaseName}, nil) if err != nil { return nil, fmt.Errorf("failed to create database: %w", err) } log.Printf("Database '%s' created.\n", databaseName) } else { return nil, fmt.Errorf("failed to read database: %w", err) } } else { log.Printf("Database '%s' already exists.\n", databaseName) } return databaseClient, nil } // createContainer creates a Cosmos DB container if it doesn't exist. func createContainer(ctx context.Context, databaseClient *azcosmos.DatabaseClient, containerName string) (*azcosmos.ContainerClient, error) { containerClient, err := databaseClient.NewContainer(containerName) if err != nil { return nil, fmt.Errorf("failed to get container client: %w", err) } _, err = containerClient.Read(ctx, nil) if err != nil { if azcosmos.IsErrorStatusCode(err, http.StatusNotFound) { // Container doesn't exist, create it containerProperties := azcosmos.ContainerProperties{ ID: containerName, PartitionKeyDefinition: azcosmos.PartitionKeyDefinition{ Paths: []string{"/id"}, // Use /id as the partition key Version: azcosmos.PartitionKeyDefinitionVersionV2, }, } _, err = databaseClient.CreateContainer(ctx, containerProperties, nil) if err != nil { return nil, fmt.Errorf("failed to create container: %w", err) } log.Printf("Container '%s' created.\n", containerName) } else { return nil, fmt.Errorf("failed to read container: %w", err) } } else { log.Printf("Container '%s' already exists.\n", containerName) } return containerClient, nil } // createItemHandler handles the creation of a new item. func createItemHandler(containerClient *azcosmos.ContainerClient) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } var item Item if err := json.NewDecoder(r.Body).Decode(&item); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } ctx := context.Background() partitionKey := azcosmos.NewPartitionKeyString(item.ID) // Use item.ID as the partition key value resp, err := containerClient.CreateItem(ctx, partitionKey, item, nil) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) log.Printf("Error creating item: %v\n", err) return } log.Printf("Created item with id: %s. Status code: %d\n", item.ID, resp.RawResponse.StatusCode) w.WriteHeader(http.StatusCreated) json.NewEncoder(w).Encode(item) // Return the created item } } // getItemHandler handles retrieving an item by ID. func getItemHandler(containerClient *azcosmos.ContainerClient) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } itemID := r.URL.Query().Get("id") if itemID == "" { http.Error(w, "Missing 'id' parameter", http.StatusBadRequest) return } ctx := context.Background() partitionKey := azcosmos.NewPartitionKeyString(itemID) // Use itemID as the partition key value resp, err := containerClient.ReadItem(ctx, partitionKey, itemID, nil) if err != nil { if azcosmos.IsErrorStatusCode(err, http.StatusNotFound) { http.Error(w, "Item not found", http.StatusNotFound) return } http.Error(w, err.Error(), http.StatusInternalServerError) log.Printf("Error reading item: %v\n", err) return } var item Item if err := json.Unmarshal(resp.Value, &item); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) log.Printf("Error unmarshaling item: %v\n", err) return } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(item) } } func main() { // Initialize Cosmos DB client client, err := createCosmosClient() if err != nil { log.Fatalf("Failed to create Cosmos DB client: %v", err) } ctx := context.Background() // Create database and container if they don't exist databaseClient, err := createDatabase(ctx, client, databaseName) if err != nil { log.Fatalf("Failed to create/get database: %v", err) } containerClient, err := createContainer(ctx, databaseClient, containerName) if err != nil { log.Fatalf("Failed to create/get container: %v", err) } // Set up HTTP handlers http.HandleFunc("/items", createItemHandler(containerClient)) http.HandleFunc("/items/get", getItemHandler(containerClient)) // Use /items/get?id=... for GET requests // Start the server port := os.Getenv("PORT") if port == "" { port = "8080" // Default port } log.Printf("Server listening on port %s...\n", port) server := &http.Server{ Addr: ":" + port, ReadHeaderTimeout: 3 * time.Second, } log.Fatal(server.ListenAndServe()) } ``` **Explanation:** 1. **Dependencies:** Make sure you have the Azure Cosmos DB Go SDK installed: ```bash go get github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos go get github.com/Azure/azure-sdk-for-go/sdk/azidentity ``` 2. **Configuration:** The `cosmosDBEndpoint`, `cosmosDBKey`, `databaseName`, and `containerName` constants need to be replaced with your actual Cosmos DB account details. *Never* hardcode your key in production code. Use environment variables or a configuration file. 3. **Authentication:** The code attempts to use `azidentity.NewDefaultAzureCredential(nil)` first. This is the preferred method when running in an Azure environment (e.g., Azure VM, Azure App Service, Azure Kubernetes Service) because it automatically uses managed identities or other Azure credentials. If that fails, it falls back to using the `cosmosDBKey`. Key-based authentication is less secure and should only be used for development/testing. 4. **`createCosmosClient()`:** Creates a Cosmos DB client using either Azure Identity or a key. 5. **`createDatabase()` and `createContainer()`:** These functions create the database and container if they don't already exist. They use `Read` operations to check for existence before attempting to create. 6. **`Item` struct:** Defines the structure of the data you'll be storing in Cosmos DB. The `json:"id"` tag is important for serialization and deserialization. 7. **`createItemHandler()`:** * Handles `POST` requests to `/items`. * Decodes the JSON request body into an `Item` struct. * Creates a new item in the Cosmos DB container using `containerClient.CreateItem()`. * Uses the `item.ID` as the partition key. This is crucial for performance and scalability. *Choose a partition key that distributes your data evenly.* * Returns the created item in the response. 8. **`getItemHandler()`:** * Handles `GET` requests to `/items/get?id={item_id}`. * Extracts the `id` parameter from the query string. * Retrieves the item from Cosmos DB using `containerClient.ReadItem()`. * Uses the `itemID` as the partition key value. * Returns the item in the response. 9. **`main()`:** * Initializes the Cosmos DB client. * Creates the database and container. * Sets up the HTTP handlers. * Starts the HTTP server. **How to Run:** 1. **Set Environment Variables:** Set the `YOUR_COSMOSDB_ENDPOINT` and `YOUR_COSMOSDB_KEY` environment variables. (Or replace the constants directly in the code for testing, but *don't* commit that change.) ```bash export YOUR_COSMOSDB_ENDPOINT="your_endpoint" export YOUR_COSMOSDB_KEY="your_key" ``` 2. **Run the Go program:** ```bash go run main.go ``` 3. **Test the API:** * **Create an item (POST):** ```bash curl -X POST -H "Content-Type: application/json" -d '{"id": "item1", "name": "My Item", "description": "A sample item"}' http://localhost:8080/items ``` * **Get an item (GET):** ```bash curl http://localhost:8080/items/get?id=item1 ``` **Important Notes:** * **Partitioning:** The choice of partition key is critical for Cosmos DB performance. In this example, I'm using the `id` field as the partition key. This is suitable for simple scenarios where you frequently query by ID. For more complex scenarios, you might need to choose a different partition key that better distributes your data. * **Request Units (RUs):** Cosmos DB charges based on request units (RUs). Be mindful of the RUs consumed by your operations. You can monitor RU consumption in the Azure portal. Optimize your queries and data model to minimize RU costs. * **Error Handling:** The error handling in this example is very basic. You should implement more robust error handling, including logging, retry mechanisms, and potentially circuit breakers. * **Security:** This example lacks authentication and authorization. You *must* implement security measures to protect your Cosmos DB data. * **Scalability:** For production deployments, consider using a load balancer and running multiple instances of your MCP server. This example provides a starting point for building an MCP server for Cosmos DB using the Go SDK. Remember to adapt it to your specific requirements and implement the necessary security, error handling, and monitoring features. Good luck!

Firewalla MCP Server

A production-ready server that connects Claude Desktop to Firewalla network management capabilities, allowing users to monitor devices, analyze network traffic, manage security alerts, and configure firewall rules through natural language.