Discover Awesome MCP Servers

MySQL-Performance-Tuner-Mcp

MySQL MCP Performance Tuning Server - AI-powered MySQL performance tuning capabilities

Gemini Flash Image MCP Server

Enables text-to-image generation, image editing, and multi-image composition using Google's Gemini 2.5 Flash Image API. Supports flexible aspect ratios and character consistency across generations.

Dify MCP Server

A TypeScript-based server that connects MCP Clients to Dify applications, dynamically exposing Dify applications as tools that can be used directly within the MCP Client.

Unified Auth0 MCP Server

An MCP server that enables Claude Code to access Auth0-protected APIs by handling OAuth authentication flows and securely proxying API requests with user credentials.

Crypto Price & Market Analysis MCP Server

Provides comprehensive cryptocurrency analysis using the CoinCap API, offering real-time price data, market analysis across exchanges, and historical price trends for any cryptocurrency.

float-mcp

A community MCP server for float.com.

Pokémcp

Sebuah server Protokol Konteks Model yang menyediakan informasi Pokémon dengan terhubung ke PokeAPI, memungkinkan pengguna untuk menanyakan data Pokémon yang detail, menemukan Pokémon secara acak, dan menemukan Pokémon berdasarkan wilayah atau tipe.

Tability MCP Server

Enables AI assistants to manage OKRs, track goals, and update progress on the Tability platform using natural language. It provides 27 tools for interacting with plans, objectives, outcomes, initiatives, and workspace memberships via the Tability API.

kubevirt-mcp-server

Server Protokol Konteks Model sederhana untuk KubeVirt

Glama MCP Server Search

An MCP server for searching and exploring MCP servers from the Glama MCP directory. This server provides tools to search for MCP servers, get detailed information about specific servers, and explore available server attributes using the Glama MCP API.

Aegis MCP Server

An enforcement layer that validates AI agent actions against governance policies, including path permissions and content scanning, at runtime. It enables secure, role-based execution of file operations and commands with zero token overhead by processing policies independently from the agent's context.

Document Intelligence MCP Server

Enables Claude to read and analyze PDF documents with automatic OCR processing for scanned files. Features intelligent text extraction, caching for performance, and secure file access with search capabilities.

MCP Server for EAI Services

Implements a Multi-Channel Platform Server that integrates with existing Enterprise Application Integration services, providing tools and endpoints to securely fetch network reports and access management features.

azure-devops-mcp

Okay, here's a breakdown of what you'd need to build a C# server and client application that interacts with Azure DevOps, along with code snippets to illustrate key concepts. This is a complex topic, so I'll focus on the core elements and provide guidance for further exploration. **Understanding the Architecture** 1. **Azure DevOps:** This is the platform providing the services (work items, builds, releases, etc.) you want to interact with. 2. **Server (C#):** This application will act as a middleman. It will: * Authenticate with Azure DevOps. * Receive requests from the client. * Make calls to the Azure DevOps REST APIs. * Process the data from Azure DevOps. * Send the processed data back to the client. 3. **Client (C#):** This application will: * Send requests to the server. * Receive data from the server. * Display the data to the user or perform other actions. **Key Technologies** * **C#:** The programming language for both the server and client. * **ASP.NET Core (Server):** A framework for building web APIs. This is a good choice for the server because it's cross-platform, performant, and well-suited for RESTful services. * **HttpClient (Client and Server):** Used to make HTTP requests to the Azure DevOps REST APIs and to communicate between the client and server. * **JSON Serialization/Deserialization:** Azure DevOps APIs use JSON for data exchange. You'll need to serialize C# objects to JSON for sending requests and deserialize JSON responses into C# objects. `System.Text.Json` (built-in) or `Newtonsoft.Json` (popular NuGet package) are common choices. * **Azure DevOps REST APIs:** The core of the interaction. You'll need to understand the specific APIs you want to use (e.g., work items, builds, releases). See the official documentation: [https://docs.microsoft.com/en-us/rest/api/azure/devops/?view=azure-devops-rest-6.0](https://docs.microsoft.com/en-us/rest/api/azure/devops/?view=azure-devops-rest-6.0) * **Authentication:** You'll need a way to authenticate with Azure DevOps. The most common methods are: * **Personal Access Tokens (PATs):** Simple to use for development and testing. Not recommended for production. * **OAuth 2.0:** More secure and suitable for production applications. Involves registering your application with Azure DevOps and handling authorization flows. * **Managed Identities (for Azure-hosted applications):** The most secure option when your server is running in Azure. **Example Code Snippets** **1. Server (ASP.NET Core Web API)** ```csharp using Microsoft.AspNetCore.Mvc; using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text.Json; using System.Threading.Tasks; namespace AzureDevOpsServer.Controllers { [ApiController] [Route("[controller]")] public class WorkItemsController : ControllerBase { private readonly string _organizationUrl = "YOUR_AZURE_DEVOPS_ORGANIZATION_URL"; // e.g., "https://dev.azure.com/yourorg" private readonly string _personalAccessToken = "YOUR_PERSONAL_ACCESS_TOKEN"; [HttpGet] public async Task<IActionResult> GetWorkItems() { using (var client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($":{_personalAccessToken}"))); string url = $"{_organizationUrl}/_apis/wit/workitems?\$top=5&api-version=7.1"; // Example: Get the top 5 work items HttpResponseMessage response = await client.GetAsync(url); if (response.IsSuccessStatusCode) { string responseBody = await response.Content.ReadAsStringAsync(); // Deserialize the JSON response into a C# object (you'll need to define a class to represent the work item data) // Example using System.Text.Json: try { JsonDocument jsonDocument = JsonDocument.Parse(responseBody); // You'll need to navigate the JSON structure to extract the work item data. // For example, if the response has a "value" array: JsonElement root = jsonDocument.RootElement; if (root.TryGetProperty("value", out JsonElement valueArray)) { // Iterate through the work items in the array foreach (JsonElement workItemElement in valueArray.EnumerateArray()) { // Extract properties from each work item // Example: if (workItemElement.TryGetProperty("id", out JsonElement idElement)) { int workItemId = idElement.GetInt32(); Console.WriteLine($"Work Item ID: {workItemId}"); } } } return Ok(responseBody); // Or return a more structured C# object } catch (JsonException ex) { Console.WriteLine($"JSON Exception: {ex.Message}"); return StatusCode(500, "Error parsing JSON response."); } } else { Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}"); return StatusCode((int)response.StatusCode, response.ReasonPhrase); } } } } } ``` **Explanation (Server):** * **`_organizationUrl` and `_personalAccessToken`:** Replace these with your actual Azure DevOps organization URL and a Personal Access Token. *Important: Never hardcode PATs in production code. Use environment variables or a secure configuration store.* * **`HttpClient`:** Creates an HTTP client to make requests. * **`DefaultRequestHeaders`:** Sets the `Accept` header to `application/json` to indicate that we want JSON responses. Sets the `Authorization` header using a Base64-encoded PAT. * **`GetAsync`:** Makes a GET request to the Azure DevOps REST API endpoint for work items. The `$top=5` query parameter limits the results to the top 5 work items. The `api-version` parameter specifies the version of the API to use. * **`response.IsSuccessStatusCode`:** Checks if the request was successful. * **`response.Content.ReadAsStringAsync()`:** Reads the JSON response from the API. * **JSON Deserialization:** This is the most complex part. The code uses `System.Text.Json` to parse the JSON response. You'll need to understand the structure of the JSON returned by the Azure DevOps API and create C# classes to represent the data. The example shows how to navigate the JSON structure and extract data. Consider using a tool like [https://json2csharp.com/](https://json2csharp.com/) to generate C# classes from a sample JSON response. * **Error Handling:** Includes basic error handling to check for unsuccessful responses and JSON parsing errors. **2. Client (Console Application)** ```csharp using System; using System.Net.Http; using System.Threading.Tasks; namespace AzureDevOpsClient { class Program { static async Task Main(string[] args) { string serverUrl = "YOUR_SERVER_URL"; // e.g., "https://localhost:5001/workitems" using (var client = new HttpClient()) { try { HttpResponseMessage response = await client.GetAsync(serverUrl); if (response.IsSuccessStatusCode) { string responseBody = await response.Content.ReadAsStringAsync(); Console.WriteLine(responseBody); // Display the JSON response from the server // Or, deserialize the JSON into C# objects and display the data in a more user-friendly way. } else { Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}"); } } catch (HttpRequestException ex) { Console.WriteLine($"Request exception: {ex.Message}"); } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } } Console.ReadKey(); } } } ``` **Explanation (Client):** * **`serverUrl`:** Replace this with the URL of your ASP.NET Core Web API. * **`HttpClient`:** Creates an HTTP client to make requests to the server. * **`GetAsync`:** Makes a GET request to the server. * **`response.IsSuccessStatusCode`:** Checks if the request was successful. * **`response.Content.ReadAsStringAsync()`:** Reads the JSON response from the server. * **Displaying the Data:** The example simply prints the JSON response to the console. In a real application, you would deserialize the JSON into C# objects and display the data in a more user-friendly way (e.g., in a GUI). * **Error Handling:** Includes basic error handling for HTTP request exceptions and other errors. **Important Considerations and Next Steps** * **Error Handling:** Implement robust error handling in both the server and client. Log errors, provide informative messages to the user, and handle exceptions gracefully. * **Security:** *Never* hardcode sensitive information like PATs in your code. Use environment variables, configuration files, or a secure configuration store. For production applications, use OAuth 2.0 or Managed Identities for authentication. * **Data Transfer Objects (DTOs):** Create C# classes to represent the data you're exchanging between the client and server. This will make your code more maintainable and easier to understand. * **Dependency Injection:** Use dependency injection in your ASP.NET Core Web API to manage dependencies and make your code more testable. * **Asynchronous Programming:** Use `async` and `await` throughout your code to avoid blocking the UI thread and improve performance. * **Pagination:** Azure DevOps APIs often return large amounts of data. Implement pagination to retrieve data in smaller chunks. * **Rate Limiting:** Be aware of Azure DevOps API rate limits. Implement retry logic with exponential backoff to handle rate limiting errors. * **Logging:** Implement logging to track requests, errors, and other important events. * **Testing:** Write unit tests and integration tests to ensure that your code is working correctly. * **UI Framework (Client):** For a more sophisticated client, consider using a UI framework like WPF, WinForms, or a web-based framework like Blazor or Angular. * **Azure DevOps SDKs:** While the REST API is the foundation, Microsoft provides .NET client libraries (SDKs) that can simplify some interactions. However, they don't cover *every* API endpoint, so you'll often need to use `HttpClient` directly. Look for NuGet packages like `Microsoft.TeamFoundationServer.Client`. **Example of Deserializing JSON (using `System.Text.Json`)** First, define a C# class that matches the structure of the JSON response from the Azure DevOps API. For example: ```csharp using System.Text.Json.Serialization; public class WorkItemResponse { [JsonPropertyName("count")] public int Count { get; set; } [JsonPropertyName("value")] public WorkItem[] Value { get; set; } } public class WorkItem { [JsonPropertyName("id")] public int Id { get; set; } [JsonPropertyName("url")] public string Url { get; set; } // Add other properties as needed based on the JSON structure } ``` Then, in your server code, you can deserialize the JSON like this: ```csharp using System.Text.Json; // ... inside your GetWorkItems method ... string responseBody = await response.Content.ReadAsStringAsync(); try { WorkItemResponse workItemResponse = JsonSerializer.Deserialize<WorkItemResponse>(responseBody); if (workItemResponse != null && workItemResponse.Value != null) { foreach (var workItem in workItemResponse.Value) { Console.WriteLine($"Work Item ID: {workItem.Id}, URL: {workItem.Url}"); } } return Ok(workItemResponse); // Return the deserialized object } catch (JsonException ex) { Console.WriteLine($"JSON Exception: {ex.Message}"); return StatusCode(500, "Error parsing JSON response."); } ``` **Indonesian Translation of Key Concepts** * **Azure DevOps:** Platform untuk layanan pengembangan perangkat lunak (item kerja, build, rilis, dll.). * **Server (C#):** Aplikasi yang bertindak sebagai perantara. * **Client (C#):** Aplikasi yang mengirim permintaan ke server dan menampilkan data. * **REST API:** Antarmuka pemrograman aplikasi berbasis web yang digunakan untuk berinteraksi dengan Azure DevOps. * **Personal Access Token (PAT):** Token akses pribadi untuk otentikasi. * **Otentikasi:** Proses verifikasi identitas pengguna atau aplikasi. * **Serialisasi/Deserialisasi JSON:** Mengubah objek C# menjadi format JSON dan sebaliknya. * **ASP.NET Core:** Kerangka kerja untuk membangun aplikasi web API. * **HttpClient:** Kelas untuk membuat permintaan HTTP. This is a starting point. You'll need to adapt the code to your specific requirements and the Azure DevOps APIs you want to use. Good luck!

DigitalOcean MCP Server

Provides access to all 471+ DigitalOcean API endpoints through an MCP server that dynamically extracts them from the OpenAPI specification, enabling search, filtering, and direct API calls with proper authentication.

GitHub MCP Server on Amazon Bedrock AgentCore

Provides a private, managed instance of the official GitHub MCP server hosted on Amazon Bedrock AgentCore with Okta authentication. It allows developers to securely interact with GitHub through MCP-compatible IDEs over a private AWS infrastructure.

SiteBay MCP Server

Enables management of WordPress sites hosted on SiteBay platform through natural language, including site creation, executing WP-CLI commands, file editing, and server operations.

MCP Fetch

Server Protokol Konteks Model yang memungkinkan Claude Desktop (atau klien MCP lainnya) untuk mengambil konten web dan memproses gambar dengan tepat.

ServiceNow MCP Server

A server that integrates Claude AI with ServiceNow, enabling incident creation, service request management, email handling, and catalog browsing through natural language.

Cryptocurrency Market Data Server

Menyediakan data pasar mata uang kripto secara waktu nyata dan historis melalui integrasi dengan bursa-bursa utama. Server ini memungkinkan LLM (Large Language Models) seperti Claude untuk mengambil harga terkini, menganalisis tren pasar, dan mengakses informasi perdagangan yang terperinci.

flompt

Visual AI prompt builder that decomposes any raw prompt into 12 semantic blocks and recompiles them into Claude-optimized XML. Exposes decompose_prompt and compile_prompt tools via MCP.

Talebook MCP Server

A simple FastAPI-based MCP server that provides book-related tools, currently supporting retrieval of book collection counts.

docdex

Docdex is a lightweight, local documentation indexer/search daemon. It runs per-project, keeps an on-disk index of your markdown/text docs, and serves top-k snippets over HTTP or CLI for any coding assistant or tool—no external services or uploads required.

TFT MCP Server

Server ini memungkinkan Claude untuk mengakses data game Team Fight Tactics (TFT), memungkinkan pengguna untuk mengambil riwayat pertandingan dan informasi pertandingan yang detail melalui Riot Games API.

Monad MCP Server

Enables interaction with the Monad testnet to check balances, examine transaction details, get gas prices, and retrieve block information.

simple-mcp-runner

Simple MCP Runner makes it effortless to safely expose system commands to language models via a lightweight MCP server—all configurable with a clean, minimal YAML file and zero boilerplate.

Code Search MCP

Enables LLMs to perform high-performance code search and analysis across multiple languages using symbol indexing, regex text search, and structural AST pattern matching. It also provides tools for technology stack detection and dependency analysis with persistent caching for optimized performance.

octo-mcp-server

A production-ready MCP server built with Node.js and Express that supports remote deployment via HTTP and SSE. It provides a modular framework for building and scaling tools while serving multiple clients concurrently.

Multi-Agent Tools Platform

A modular production-ready system that provides specialized agents for math, research, weather, and summarization tasks through a unified MCP toolbox with smart supervisor capabilities.

TradeX MCP Server

Enables AI agents to research, analyze, and trade Pokemon card perpetual futures on the TradeX platform. It supports market data retrieval, trading simulations, and secure transaction execution using local Solana keypairs.