Discover Awesome MCP Servers

Stock Price MCP Server

Provides real-time stock price information from Yahoo Finance API for global markets with multi-currency support, market state tracking, and no rate limits.

Ollama-MCP Bridge WebUI

Sebuah antarmuka web yang menghubungkan LLM Ollama lokal ke server Model Context Protocol (MCP). Memungkinkan model sumber terbuka untuk menggunakan operasi file, pencarian web, dan alat penalaran yang mirip dengan asisten AI komersial - semuanya berjalan secara pribadi di perangkat keras Anda sendiri.

JADX-MCP-SERVER

A Model Context Protocol server that connects to a custom JADX fork (JADX-AI) and enables local LLMs to interact with decompiled Android app code for live reverse engineering assistance.

MCP Learning Server

A comprehensive educational server demonstrating Model Context Protocol capabilities for tools, resources, and prompts, allowing AI assistants to connect to external data and functionality.

mcp-server-springaidemo

Demo mcp-server Spring AI

VibeCheck

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

Hyperbrowser MCP Server

Enables web scraping, crawling, structured data extraction, and browser automation through multiple AI agents including OpenAI's CUA, Anthropic's Claude Computer Use, and Browser Use.

神岛地图数据统计

Menyediakan akses ke data pengguna, informasi peta, dan statistik platform Shendao.

小记（AI记账）

Catatan Kecil adalah alat pencatatan keuangan pribadi cerdas berbasis AI yang memungkinkan "pencatatan dan pengecekan keuangan secepat kilat dalam satu kalimat" melalui interaksi bahasa alami. Anda hanya perlu mengatakan "Sarapan 25 yuan, bayar dengan Alipay" atau "Gaji masuk ke rekening bank 18.000 yuan", sistem akan secara otomatis mengurai jumlah, kategori, metode pembayaran, dan mencatatnya ke dalam buku besar. Selain itu, mendukung penggunaan klien 🔥MCP.

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.

MiniMax MCP JS

Implementasi JavaScript dari MiniMax MCP yang memungkinkan interaksi dengan layanan AI MiniMax untuk pembuatan gambar, pembuatan video, text-to-speech, dan kloning suara melalui klien yang kompatibel dengan MCP.

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.

Ghost MCP Server

An implementation of the Model Context Protocol Server that allows AI clients like Cursor or Claude Desktop to manage Ghost CMS blogs by exposing capabilities like creating posts, adding tags, and uploading images.

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 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

Server Claude MCP untuk melakukan analisis pada data ROADrecon

WoT Blitz MCP Server

Provides AI assistants with access to authentic World of Tanks Blitz game data including tank statistics, armor values, map terrain features, equipment, crew skills, and camouflages parsed directly from local game files.

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.

Research Tracker MCP Server

Enables discovery and analysis of research ecosystems by extracting metadata from paper URLs, GitHub repositories, and research names. Automatically finds related papers, code repositories, models, datasets, and authors across platforms like arXiv, HuggingFace, and GitHub.

getmcp - MCP Server Management Tool

getmcp: Cara mudah dan cepat untuk menemukan server MCP sumber terbuka

X.com MCP Server

Model Context Protocol server that enables LLMs to interact with X.com (formerly Twitter) through OAuth 2.0 authentication, supporting major Post-related operations including reading, writing, searching, and managing posts, likes, retweets, and bookmarks.

Tinder API MCP Server

A Model Context Protocol server that provides a standardized interface for interacting with the Tinder API, handling authentication, request processing, rate limiting, caching, and error handling.

MCP Server Kalshi

Sebuah server MCP untuk berinteraksi dengan pasar prediksi Kalshi.

JSR MCP

Model Context Protocol server for the JSR (JavaScript Registry)

MCP Ollama Consult Server

Enables consulting with local Ollama models for reasoning from alternative viewpoints. Supports sending prompts to Ollama models and listing available models on your local Ollama instance.

Tradingview Chart MCP

Tradingview Chart MCP

AgilePlace MCP Server

Enables AI assistants to interact with AgilePlace for comprehensive project management tasks including board management, card operations, dependency tracking, and bulk updates. Supports natural language queries for managing AgilePlace boards, cards, and team workflows.