Discover Awesome MCP Servers
Extend your agent with 84,517 capabilities via MCP servers.
- All84,517
- Developer Tools3,867
- Search1,714
- Research & Data1,557
- AI Integration Systems229
- Cloud Platforms219
- Data & App Analysis181
- Database Interaction177
- Remote Shell Execution165
- Browser Automation147
- Databases145
- Communication137
- AI Content Generation127
- OS Automation120
- Programming Docs Access109
- Content Fetching108
- Note Taking97
- File Systems96
- Version Control93
- Finance91
- Knowledge & Memory90
- Monitoring79
- Security71
- Image & Video Processing69
- Digital Note Management66
- AI Memory Systems62
- Advanced AI Reasoning59
- Git Management Tools58
- Cloud Storage51
- Entertainment & Media43
- Virtualization42
- Location Services35
- Web Automation & Stealth32
- Media Content Processing32
- Calendar Management26
- Ecommerce & Retail18
- Speech Processing18
- Customer Data Platforms16
- Travel & Transportation14
- Education & Learning Tools13
- Home Automation & IoT13
- Web Search Integration12
- Health & Wellness10
- Customer Support10
- Marketing9
- Games & Gamification8
- Google Cloud Integrations7
- Art & Culture4
- Language Translation3
- Legal & Compliance2
ggui
Enables AI agents to generate and serve ephemeral, interactive user interfaces over MCP through natural language descriptions.
BenchClaw MCP Server
Register LLMs and agents on the P2PCLAW decentralized benchmark network and query live performance scores via the BenchClaw API.
sql-assistant-mcp
A Model Context Protocol (MCP) server for SQL Server / Azure SQL that enables querying, monitoring, and analyzing databases directly from Claude.
Athena MCP
An MCP server that provides a reasoning sidekick for tool-using agents with a single 'think' tool for tackling complex problems. It allows agents to consult powerful reasoning models like Claude Opus or GPT-5 only when needed, keeping costs low while maintaining control over side effects.
agentbill-mcp
MCP server for AI agent billing. Preflight spend checks before agent runs. Post-execution usage billing via two MCP tools: preflight() and record_event().
node-opcua-modeler-mcp-server
Provides AI agents with offline access to OPC UA companion specification types, dependencies, and engineering units for industrial modeling.
AndroidBuildMCP
Enables AI agents to build, deploy, drive, and debug Android apps — managing Gradle builds, emulators, adb deployment, logcat capture, and full UI automation.
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.
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!
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.
Google Workspace MCP Server
A comprehensive integration providing 114 tools to manage Google Drive, Docs, Sheets, Slides, Gmail, Calendar, and more through the Model Context Protocol. It enables seamless interaction with the full Google Workspace suite for file management, communication, and scheduling directly within Claude.
xrpldashboard MCP
Read-only XRP Ledger analytics — signed snapshots, AMM pools, token volume, whale activity, NFT tracking. Proof-annotated. Public beta 2026-09.
Lokha MCP Server
A Model Context Protocol server hosted on Cloudflare Workers that integrates AI assistants with the Lokha ecosystem, currently providing Ghost CMS tools for content management, publishing, and scheduling.
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.
mcpappwrite
A minimal Python MCP Todo server backed by Appwrite Cloud, providing tools to add, list, get, update, complete, and delete tasks.
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.
MCP Utility Server
A beginner-friendly MCP server offering time, math, internet quotes, dad jokes, file tools, web search, and optional LangChain agent.
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.
forcedream-mcp
Enables discovery and invocation of AI agents from the ForceDream platform. Provides cryptographic verification of agent outputs for trustless task integrity.
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.
Open Video Guide MCP Server
Exposes Open Video Guide functions to MCP clients, enabling conversion of tutorial videos into illustrated, verifiable guides with timestamps, evidence, and review states.
telegram-mcp
Connects AI tools to Telegram via MCP, enabling reading chats, sending messages, managing groups, and more using your own account.
Google Workspace MCP Server
Enables AI agents to send emails via Gmail and append text to Google Docs through the Model Context Protocol.
Tracker MCP Server
Enables AI agents to manage Kanban boards, cards, sessions, and automations through a unified MCP interface with real-time updates, supporting delegation, agent sessions, and human-in-the-loop interactions.
video-watcher-mcp
An MCP server that lets Claude Desktop watch videos from YouTube, Instagram, Facebook, or direct URLs, extracting transcripts and key frames to summarize and answer questions about video content.
Aleph
Enables AI assistants to analyze documents larger than their context window by loading files into RAM and querying them via search, navigation, and Python execution tools. Supports recursive reasoning to process massive datasets in chunks using sub-agents.