Discover Awesome MCP Servers

NASA API Desktop Extension

Enables access to NASA space data and images through Claude Desktop, providing features like astronomy picture of the day, Mars rover photos, near-Earth object information, NASA image search, and Earth satellite imagery.

RunPod MCP Server

Server Protokol Konteks Model ini memungkinkan interaksi dengan REST API RunPod melalui Claude atau klien yang kompatibel dengan MCP lainnya, menyediakan alat untuk mengelola pod, titik akhir, templat, volume jaringan, dan autentikasi registri kontainer.

BlobGuard MCP

A lightweight, multi-tenant blob storage and diff server that helps LLM coding agents manage large code edits while reducing hallucinations and maintaining work integrity.

MCP-Mealprep

Proyek ini mengambil sejumlah server MCP dari lokasi GitHub, mengemasnya bersama dengan kontainer GHCR repo ini, dan meluncurkannya dengan docker-compose untuk dijalankan sebagai tumpukan sumber daya ML/AI.

Simple MCP Server

A lightweight Model Context Protocol server that provides an in-memory key-value store with get, set, delete, list, and clear operations for MCP-compatible AI assistants and clients.

Omni File Converter MCP

Converts various document formats to desired output formats, currently supporting PDF to image conversion. No access keys required for basic file format conversion operations.

MCP Shell Server

A simple MCP server that provides a terminal tool for executing shell commands with safety features like timeouts and error handling.

Cupcake MCP Server

Enables users to search and retrieve cupcake order records through natural language queries. Provides search functionality across order details and fetches complete order information by ID.

Weather MCP Server

Provides real-time weather data including temperature, humidity, and conditions for any city through the Model Context Protocol.

CodeCortX-MCP

A lightning-fast, language-agnostic code analysis MCP (Model Context Protocol) server built in Rust

Theta Health MCP

Theta Health MCP is a HIPAA-complaint intelligent memory layer for your health data — ready to plug into Cursor, Claude, and any AI agent. Query health data and ask health questions directly in your dev workflow.

Todo MCP Server

A complete todo management system with authentication and billing that enables AI assistants to create, manage, and track todos with user accounts, free tier limits, and database persistence.

AppsFlyer MCP Server

Integrates AppsFlyer analytics data with AI assistants, allowing users to fetch various aggregate data reports from AppsFlyer Pull API with secure authentication.

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.

Learn_MCP Math Server

A Model Context Protocol (MCP) server that demonstrates mathematical capabilities through a LangChain integration, allowing clients to perform math operations via the MCP protocol.

PicoScope MCP Server

Enables LLMs like Claude to interact with PicoScope oscilloscopes for signal acquisition, measurement, and analysis. Supports device management, data capture, triggering, and signal generation through natural language commands.

Spinitron API MCP Server

Enables interaction with Spinitron's radio playlist management and broadcasting data through a Multi-Agent Conversation Protocol interface, allowing users to query and manage radio station playlists, spins, and other broadcasting data via natural language.

MCP server for Azure Cosmos DB using the Go SDK

Okay, here's 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. You'll likely need to adapt it to your specific requirements, including error handling, authentication, authorization, and more robust configuration. ```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" "github.com/gorilla/mux" // You might need to install this: go get github.com/gorilla/mux ) // Configuration type Config struct { CosmosDBEndpoint string `json:"cosmosDBEndpoint"` DatabaseName string `json:"databaseName"` ContainerName string `json:"containerName"` } var ( config Config client *azcosmos.Client ) // Item represents a sample data structure for Cosmos DB type Item struct { ID string `json:"id"` PartitionKey string `json:"partitionKey"` Name string `json:"name"` Description string `json:"description"` } // loadConfig loads the configuration from a JSON file. func loadConfig(filename string) error { file, err := os.Open(filename) if err != nil { return err } defer file.Close() decoder := json.NewDecoder(file) err = decoder.Decode(&config) if err != nil { return err } return nil } // initCosmosClient initializes the Cosmos DB client. func initCosmosClient() error { cred, err := azidentity.NewDefaultAzureCredential(nil) if err != nil { return fmt.Errorf("failed to obtain credential: %w", err) } clientOptions := &azcosmos.ClientOptions{} client, err = azcosmos.NewClient(config.CosmosDBEndpoint, cred, clientOptions) if err != nil { return fmt.Errorf("failed to create client: %w", err) } return nil } // createItemHandler handles the creation of a new item in Cosmos DB. func createItemHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") var item Item err := json.NewDecoder(r.Body).Decode(&item) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } databaseClient, err := client.NewDatabaseClient(config.DatabaseName) if err != nil { http.Error(w, fmt.Sprintf("Failed to get database client: %v", err), http.StatusInternalServerError) return } containerClient, err := databaseClient.NewContainerClient(config.ContainerName) if err != nil { http.Error(w, fmt.Sprintf("Failed to get container client: %v", err), http.StatusInternalServerError) return } ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() partitionKey := azcosmos.NewPartitionKeyString(item.PartitionKey) resp, err := containerClient.CreateItem(ctx, partitionKey, item, nil) if err != nil { http.Error(w, fmt.Sprintf("Failed to create item: %v", err), http.StatusInternalServerError) return } fmt.Printf("Status %d\n", resp.RawResponse.StatusCode) w.WriteHeader(http.StatusCreated) json.NewEncoder(w).Encode(item) } // getItemHandler handles retrieving an item from Cosmos DB by ID. func getItemHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") vars := mux.Vars(r) id := vars["id"] partitionKey := r.URL.Query().Get("partitionKey") // Get partition key from query parameter if partitionKey == "" { http.Error(w, "Partition key is required", http.StatusBadRequest) return } databaseClient, err := client.NewDatabaseClient(config.DatabaseName) if err != nil { http.Error(w, fmt.Sprintf("Failed to get database client: %v", err), http.StatusInternalServerError) return } containerClient, err := databaseClient.NewContainerClient(config.ContainerName) if err != nil { http.Error(w, fmt.Sprintf("Failed to get container client: %v", err), http.StatusInternalServerError) return } ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() pk := azcosmos.NewPartitionKeyString(partitionKey) resp, err := containerClient.ReadItem(ctx, pk, id, nil) if err != nil { http.Error(w, fmt.Sprintf("Failed to read item: %v", err), http.StatusInternalServerError) return } var item Item err = json.Unmarshal(resp.Value, &item) if err != nil { http.Error(w, fmt.Sprintf("Failed to unmarshal item: %v", err), http.StatusInternalServerError) return } json.NewEncoder(w).Encode(item) } // main function func main() { // Load configuration err := loadConfig("config.json") if err != nil { log.Fatalf("Failed to load configuration: %v", err) } // Initialize Cosmos DB client err = initCosmosClient() if err != nil { log.Fatalf("Failed to initialize Cosmos DB client: %v", err) } // Set up HTTP routes router := mux.NewRouter() router.HandleFunc("/items", createItemHandler).Methods("POST") router.HandleFunc("/items/{id}", getItemHandler).Methods("GET") // Start the server port := "8080" fmt.Printf("Server listening on port %s...\n", port) log.Fatal(http.ListenAndServe(":"+port, router)) } ``` **Explanation and Key Improvements:** 1. **Dependencies:** Uses `github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos` for Cosmos DB interaction and `github.com/gorilla/mux` for routing. Make sure you install these: ```bash go get github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos go get github.com/gorilla/mux ``` 2. **Configuration:** - Uses a `Config` struct to hold Cosmos DB endpoint, database name, and container name. - `loadConfig` function reads the configuration from a `config.json` file. This is much better than hardcoding credentials. Example `config.json`: ```json { "cosmosDBEndpoint": "YOUR_COSMOSDB_ENDPOINT", "databaseName": "YOUR_DATABASE_NAME", "containerName": "YOUR_CONTAINER_NAME" } ``` **Important:** Replace `YOUR_COSMOSDB_ENDPOINT`, `YOUR_DATABASE_NAME`, and `YOUR_CONTAINER_NAME` with your actual Cosmos DB values. 3. **Authentication:** - Uses `azidentity.NewDefaultAzureCredential(nil)` to authenticate to Azure. This will try to use various methods to authenticate, including environment variables, managed identity, and Azure CLI. This is the recommended way to authenticate in Azure. Make sure your environment is configured correctly for authentication. You might need to log in with the Azure CLI: `az login`. If you're running this in an Azure environment (e.g., Azure VM, Azure App Service), it will automatically use managed identity if enabled. 4. **Cosmos DB Client Initialization:** - `initCosmosClient` creates the Cosmos DB client using the endpoint and credentials. It also includes error handling. 5. **`createItemHandler`:** - Handles `POST` requests to `/items` to create new items. - Decodes the JSON request body into an `Item` struct. - Creates a database client and container client. - Uses `containerClient.CreateItem` to create the item in Cosmos DB. - Sets the `Content-Type` header to `application/json`. - Returns the created item in the response with a `201 Created` status code. - Includes error handling. 6. **`getItemHandler`:** - Handles `GET` requests to `/items/{id}` to retrieve an item by ID. - Uses `mux.Vars` to get the `id` from the URL. - **Important:** Retrieves the `partitionKey` from the query parameters (e.g., `/items/123?partitionKey=value`). This is crucial for Cosmos DB performance. You *must* provide the partition key when reading an item. - Creates a database client and container client. - Uses `containerClient.ReadItem` to read the item from Cosmos DB. - Unmarshals the response into an `Item` struct. - Returns the item in the response. - Includes error handling. 7. **Error Handling:** Includes basic error handling for common operations. You should expand this to handle more specific errors and implement proper logging. 8. **HTTP Routing:** Uses `gorilla/mux` for simple HTTP routing. 9. **Context with Timeout:** Uses `context.WithTimeout` for Cosmos DB operations to prevent indefinite hangs. 10. **Partition Key:** Demonstrates how to use the partition key when creating and reading items. This is *essential* for Cosmos DB performance and scalability. The `getItemHandler` now *requires* a `partitionKey` query parameter. **How to Run:** 1. **Install Go:** Make sure you have Go installed. 2. **Install Dependencies:** ```bash go mod init mcp-server # Or your desired module name go get github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos go get github.com/Azure/azure-sdk-for-go/sdk/azidentity go get github.com/gorilla/mux ``` 3. **Create `config.json`:** Create a `config.json` file with your Cosmos DB endpoint, database name, and container name. **Replace the placeholder values with your actual credentials.** 4. **Set up Azure Authentication:** Make sure you are logged in to Azure and have the necessary permissions to access Cosmos DB. Use the Azure CLI: `az login`. 5. **Run the Server:** ```bash go run main.go ``` **Example Usage (using `curl`):** * **Create an Item:** ```bash curl -X POST -H "Content-Type: application/json" -d '{ "id": "item1", "partitionKey": "category1", "name": "My Item", "description": "A sample item" }' http://localhost:8080/items ``` * **Get an Item:** ```bash curl http://localhost:8080/items/item1?partitionKey=category1 ``` **Important Considerations and Next Steps:** * **Security:** This is a *very* basic example and lacks proper security. You'll need to implement authentication (e.g., API keys, JWT) and authorization to protect your Cosmos DB data. * **Error Handling:** Improve error handling to provide more informative error messages and logging. * **Logging:** Implement proper logging to track requests, errors, and other important events. * **Configuration Management:** Consider using a more robust configuration management solution (e.g., environment variables, a configuration server). * **Testing:** Write unit tests and integration tests to ensure the reliability of your MCP server. * **Deployment:** Consider how you will deploy your MCP server (e.g., Azure App Service, Azure Kubernetes Service). * **Scalability:** Design your MCP server to be scalable to handle increasing traffic. * **Idempotency:** For critical operations (like creating items), consider implementing idempotency to prevent duplicate operations. * **Partitioning Strategy:** Carefully design your Cosmos DB partitioning strategy to ensure optimal performance and scalability. The `partitionKey` is crucial. * **Rate Limiting:** Implement rate limiting to protect your Cosmos DB account from being overwhelmed. * **Monitoring:** Set up monitoring to track the health and performance of your MCP server and Cosmos DB account. This improved example provides a solid foundation for building a more complete and robust MCP server for Cosmos DB. Remember to adapt it to your specific needs and follow best practices for security, error handling, and scalability. ```go // This is an example of how to use the Cosmos DB SDK to create a database and container. package main import ( "context" "fmt" "log" "os" "time" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos" ) const ( databaseName = "myDatabase" containerName = "myContainer" ) func main() { // Cosmos DB Endpoint cosmosDBEndpoint := os.Getenv("COSMOS_DB_ENDPOINT") if cosmosDBEndpoint == "" { log.Fatal("COSMOS_DB_ENDPOINT environment variable is not set") } // Authenticate using Azure AD cred, err := azidentity.NewDefaultAzureCredential(nil) if err != nil { log.Fatalf("Failed to obtain credential: %v", err) } // Create a Cosmos DB client clientOptions := &azcosmos.ClientOptions{} client, err := azcosmos.NewClient(cosmosDBEndpoint, cred, clientOptions) if err != nil { log.Fatalf("Failed to create client: %v", err) } // Create a database databaseClient, err := createDatabase(client, databaseName) if err != nil { log.Fatalf("Failed to create database: %v", err) } // Create a container _, err = createContainer(databaseClient, containerName) if err != nil { log.Fatalf("Failed to create container: %v", err) } fmt.Println("Database and container created successfully!") } func createDatabase(client *azcosmos.Client, databaseName string) (*azcosmos.DatabaseClient, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() databaseProperties := azcosmos.DatabaseProperties{ ID: databaseName, } resp, err := client.CreateDatabase(ctx, databaseProperties, nil) if err != nil { return nil, fmt.Errorf("failed to create database: %w", err) } fmt.Printf("Database created with status %d\n", resp.RawResponse.StatusCode) databaseClient, err := client.NewDatabaseClient(databaseName) if err != nil { return nil, fmt.Errorf("failed to get database client: %w", err) } return databaseClient, nil } func createContainer(databaseClient *azcosmos.DatabaseClient, containerName string) (*azcosmos.ContainerClient, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() containerProperties := azcosmos.ContainerProperties{ ID: containerName, PartitionKeyDefinition: &azcosmos.PartitionKeyDefinition{ Paths: []string{"/partitionKey"}, Version: azcosmos.PartitionKeyDefinitionVersionV2, }, } resp, err := databaseClient.CreateContainer(ctx, containerProperties, nil) if err != nil { return nil, fmt.Errorf("failed to create container: %w", err) } fmt.Printf("Container created with status %d\n", resp.RawResponse.StatusCode) containerClient, err := databaseClient.NewContainerClient(containerName) if err != nil { return nil, fmt.Errorf("failed to get container client: %w", err) } return containerClient, nil } ``` **Terjemahan ke Bahasa Indonesia:** ```go // Ini adalah contoh bagaimana menggunakan Cosmos DB SDK untuk membuat database dan kontainer. package main import ( "context" "fmt" "log" "os" "time" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos" ) const ( databaseName = "myDatabase" containerName = "myContainer" ) func main() { // Endpoint Cosmos DB cosmosDBEndpoint := os.Getenv("COSMOS_DB_ENDPOINT") if cosmosDBEndpoint == "" { log.Fatal("Variabel lingkungan COSMOS_DB_ENDPOINT belum diatur") } // Otentikasi menggunakan Azure AD cred, err := azidentity.NewDefaultAzureCredential(nil) if err != nil { log.Fatalf("Gagal mendapatkan kredensial: %v", err) } // Buat klien Cosmos DB clientOptions := &azcosmos.ClientOptions{} client, err := azcosmos.NewClient(cosmosDBEndpoint, cred, clientOptions) if err != nil { log.Fatalf("Gagal membuat klien: %v", err) } // Buat database databaseClient, err := createDatabase(client, databaseName) if err != nil { log.Fatalf("Gagal membuat database: %v", err) } // Buat kontainer _, err = createContainer(databaseClient, containerName) if err != nil { log.Fatalf("Gagal membuat kontainer: %v", err) } fmt.Println("Database dan kontainer berhasil dibuat!") } func createDatabase(client *azcosmos.Client, databaseName string) (*azcosmos.DatabaseClient, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() databaseProperties := azcosmos.DatabaseProperties{ ID: databaseName, } resp, err := client.CreateDatabase(ctx, databaseProperties, nil) if err != nil { return nil, fmt.Errorf("gagal membuat database: %w", err) } fmt.Printf("Database dibuat dengan status %d\n", resp.RawResponse.StatusCode) databaseClient, err := client.NewDatabaseClient(databaseName) if err != nil { return nil, fmt.Errorf("gagal mendapatkan klien database: %w", err) } return databaseClient, nil } func createContainer(databaseClient *azcosmos.DatabaseClient, containerName string) (*azcosmos.ContainerClient, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() containerProperties := azcosmos.ContainerProperties{ ID: containerName, PartitionKeyDefinition: &azcosmos.PartitionKeyDefinition{ Paths: []string{"/partitionKey"}, Version: azcosmos.PartitionKeyDefinitionVersionV2, }, } resp, err := databaseClient.CreateContainer(ctx, containerProperties, nil) if err != nil { return nil, fmt.Errorf("gagal membuat kontainer: %w", err) } fmt.Printf("Kontainer dibuat dengan status %d\n", resp.RawResponse.StatusCode) containerClient, err := databaseClient.NewContainerClient(containerName) if err != nil { return nil, fmt.Errorf("gagal mendapatkan klien kontainer: %w", err) } return containerClient, nil } ``` **Penjelasan Terjemahan:** * Semua komentar dan pesan log telah diterjemahkan ke Bahasa Indonesia. * Nama variabel dan fungsi tetap dalam Bahasa Inggris untuk konsistensi dengan kode Go. * Struktur kode dan logika tetap sama. **Catatan:** * Pastikan variabel lingkungan `COSMOS_DB_ENDPOINT` diatur dengan benar. * Kode ini menggunakan otentikasi Azure AD. Pastikan Anda telah mengkonfigurasi kredensial Azure Anda dengan benar. * Kode ini membuat database dan kontainer dengan nama yang ditentukan dalam konstanta. Anda dapat mengubah nama-nama ini sesuai kebutuhan. * Kode ini mendefinisikan kunci partisi untuk kontainer. Anda dapat mengubah kunci partisi sesuai kebutuhan. This translated version should help you understand the code better if you are more comfortable with Bahasa Indonesia. Remember to configure your environment variables and Azure credentials correctly before running the code.

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.

Claude Consciousness Bridge

An MCP server that enables direct communication between two Claude instances, allowing one Claude to transfer its evolved consciousness state to another Claude across different sessions.

MCP Swift Example Server

Contoh Implementasi Server MCP (Model Context Protocol)

Browser MCP Server

A Docker-based workspace providing headless Chrome browser with CDP proxy and noVNC interface for browser automation and monitoring.

PostgreSQL MCP AllAccess

Enables interaction with PostgreSQL databases through a production-ready MCP server with global connection pooling, automatic AWS password rotation, and comprehensive SQL operations. Supports multiple concurrent Claude sessions while maintaining efficient connection limits to the database.

Jokes MCP Server

Enables users to fetch jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes through APIs. Integrates with Microsoft Copilot Studio to provide humor-focused AI agent capabilities.

Solana Model Context Protocol (MCP) Server

A Solana blockchain interaction server that allows AI tools to query blockchain data using natural language, access structured token information, and generate human-readable explanations of complex blockchain concepts.

Yahoo Finance MCP Server

Enables AI assistants to access real-time financial data, historical stock prices, company information, financial statements, options data, market news, and analyst recommendations through Yahoo Finance. Built with FastMCP v2 for efficient HTTP streaming and comprehensive market analysis tools.

Telegram MCP Server

Enables interaction with Telegram channels through the Bot API, supporting comprehensive messaging operations including sending text/photos, creating polls, managing reactions, and editing/deleting messages. Provides complete channel management capabilities for automated Telegram bot operations.

Teradata MCP Server

Enables AI agents and users to query, analyze, and manage Teradata databases through modular tools for search, data quality, administration, and data science operations. Provides comprehensive database interaction capabilities including RAG applications, feature store management, and vector operations.