Discover Awesome MCP Servers

vap-mcp-server

Execution control layer for AI agents - Reserve, execute, burn/refund pattern for media generation

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!

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.

MCP Server Demo

A simple demonstration project for the Model Control Protocol (MCP) server that provides tools for AI assistants to fetch news articles, perform calculations, retrieve weather data, and generate personalized greetings.

ROADrecon MCP Server

ROADreconデータの分析を実行するためのClaude MCPサーバー

basic-mcp

Provides a suite of deterministic tools for time calculations, math, and string manipulation that LLMs often struggle to perform accurately. It also includes utilities for secure randomness, data validation, and basic network operations like DNS lookups.

GPT OpenMemory MCP Server

Enables ChatGPT Desktop to save and manage conversation memories locally in SQLite, providing memory search, summarization, and markdown export capabilities to replace the built-in memory feature when in developer mode.

AWS Security Posture Advisor MCP Server

Orchestrates multiple AWS security services to provide comprehensive security assessments, threat analysis, and multi-framework compliance monitoring. It enables users to perform automated remediation recommendations and incident investigations through a unified Model Context Protocol interface.

mcp_search_images

複数の画像APIに基づいた検索サービスと、アイコン生成機能を備えており、特にCursor MCPサービスとの統合を目的として設計されています。画像検索、ダウンロード、AI生成アイコンをサポートします。

SMART-E2B

Enables secure execution of JavaScript and Python code in cloud-based E2B sandboxes with integrated file management capabilities, allowing Claude to run and test code safely in isolated environments.

Self-Hosted EdgeOne Pages MCP Server

Enables AI assistants to deploy and manage static websites directly on EdgeOne Pages through a self-hosted Model Context Protocol solution. It simplifies web hosting by allowing natural language commands to handle site deployment and KV storage management.

Alibaba Cloud RDS OpenAPI MCP Server

Alibaba Cloud RDS データベースサービスを OpenAPI 経由で管理・接続するためのサーバー。MCP との連携により、RDS インスタンスの作成、クエリ、変更をユーザーが可能にする。

DataMaker MCP Server

Enables AI models to generate synthetic data, manage templates and connections, push data to destinations, and execute Python scripts using DataMaker's data generation platform. Automatically handles large datasets by storing them to S3 with secure access links.

polydev-ai

Query multiple AI models (GPT-4, Claude, Gemini, Grok) in parallel for diverse perspectives. Get different expert viewpoints when stuck or need enhanced reasoning.

Pythagraph RED MCP Server

Enables retrieval and analysis of graph data from the Pythagraph RED API. Provides formatted tables, statistics, node/edge distributions, and comprehensive summaries for graph visualization and insights.

ComfyUI MCP Server

generate_image とその他のワークフロー

IOG Model Context Protocol (MCP) Server

初めてのモデルコンテキストプロトコルサーバーを構築しています。

mcp-labrat

An MCP server that enables interaction with CalDAV calendars to manage events and check availability through natural language or voice commands. It provides specific tools for listing, searching, and creating calendar entries using an OpenAI-compatible interface.

MCP User Data Enrichment Server

Enriches user data by generating and providing social media profile links (Instagram, Facebook, Twitter, LinkedIn) based on user information like name and birth date.

ABLESTACK MOLD MCP Server

Exposes ABLESTACK MOLD API through MCP tools with the mold_\* namespace, enabling direct CloudStack API calls, exploration, and debugging. Supports automatic API registration, async polling, parameter expansion, and signature debugging for comprehensive cloud infrastructure management.

feedback-loop-mcp

feedback-loop-mcp

Web-curl MCP Server

A powerful tool for fetching and extracting text content from web pages and APIs, supporting web scraping, REST API requests, and Google Custom Search integration.

macOS Simulator MCP Server

An MCP server that allows AI tools like Claude Desktop, Claude Code, and Cursor to visually interact with macOS applications by capturing screenshots and controlling the mouse and keyboard.

✨ Awesome Model Context Protocol (MCP) Servers

🧩 AIをファイル、API、データベースなどの現実世界のコンテキストで拡張する、モデルコンテキストプロトコル（MCP）サーバーの厳選されたリスト。

CoinMarketCap MCP Server

Provides access to cryptocurrency market data, exchange information, and blockchain metrics through the CoinMarketCap API. Supports price quotes, historical data, trending tokens, global metrics, and DEX information across different subscription tiers.

PostgreSQL MCP Server

AIエージェントがModel Context Protocolを通じてPostgreSQLデータベースとインタラクトすることを可能にし、データベーススキーマの探索、テーブル構造の検査、SQLクエリの実行機能を提供します。

Product Management MCP Server

Provides tools for managing a product catalog, including functions to list, add, and retrieve product statistics. It enables AI agents to perform inventory operations and data analysis through a standardized interface.

Mermaid-MCP

An MCP server that converts text inputs into visualized flowcharts, enabling AI clients to generate high-quality Mermaid diagrams directly from natural language descriptions or structured text.

Paymo MCP Server

An MCP server for the Paymo platform that enables AI assistants to manage time entries, projects, and tasks through natural language. It supports tracking unbilled revenue and generating detailed invoice timesheets for efficient project management.

FastMCP Quickstart

A simple example MCP server built with FastMCP and Python that provides a greeting tool, designed as a quickstart template for Smithery deployment.