Discover Awesome MCP Servers

Tailscale MCP Server

Enables interaction with the Tailscale API to manage devices, ACLs, keys, and DNS configurations directly from MCP clients like Claude Desktop or Raycast.

DALL-E MCP Server

An MCP (Model Context Protocol) server that allows generating, editing, and creating variations of images using OpenAI's DALL-E APIs.

OmniDocs MCP

An intelligent MCP server that enables AI agents to crawl, index, and semantically search official framework documentation using local RAG. It prevents hallucinations by providing precise, up-to-date documentation excerpts directly into the AI's context window.

iai-mcp

A local MCP server that gives AI assistants a long-term memory by capturing sessions verbatim and surfacing relevant context automatically.

Google Services MCP Server

Enables interaction with multiple Google services including Maps, Finance, Flights, Gmail, and Calendar through a unified interface. Provides comprehensive access to geocoding, stock data, flight information, email management, and calendar operations.

Azure DevOps MCP Server

Integrates Azure DevOps with GitHub Copilot Chat, enabling natural language queries of sprint work items, ticket summaries, and status tracking directly from VS Code without switching contexts.

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.

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.

fs-mcp

Hosted filesystem MCP server over HTTP with auth. Enables reading, writing, editing, searching, and listing files via MCP tools like grep, glob, and tree.

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.

Devops AI MCP

Devops AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

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.

MCP Server

Provides SMTP integration for sending HTML emails and specialized prompts for intent detection and client information extraction. It enables LLMs to automate personalized email workflows and structure user communication data.

globus-mcp

MCP server enabling LLMs to manage Globus data transfers and compute tasks.

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.

MiniMax Unified MCP

Unifies MiniMax's multimodal generation, web search, image understanding, audio, video, and music tools into a single MCP server for use with Claude and other clients.

qb-mcp

An MCP server that enables AI agents to interact with QuickBooks Online accounts to manage invoices, customers, payments, and financial reports. It provides 20 tools to automate accounting workflows and retrieve financial data through natural language interfaces.

neko-mcp

Enables AI agents to control a neko virtual browser via WebSocket and REST APIs, while allowing live viewing through a WebRTC stream.

DeepClaude MCP Server

This server integrates DeepSeek and Claude AI models to provide enhanced AI responses, featuring a RESTful API, configurable parameters, and robust error handling.

MySQL MCP Server

An MCP server that allows working with MySQL databases by providing tools for executing read-only SQL queries, getting table schemas, and listing database tables.

mcp-uspto

An MCP server for searching and retrieving USPTO data, including patents, trademarks, assignments, and PTAB decisions. It allows users to research IP landscapes, track prosecution histories, and analyze inventor or assignee portfolios through integrated tools.

Remote MCP Server on Cloudflare

Cermin dari

Node Terminal MCP

Enables AI agents to interact with terminal environments through multiple concurrent PTY sessions. Supports cross-platform terminal operations including command execution, session management, and real-time communication.

MCP ComfyUI Flux

Enables AI image generation using FLUX models through ComfyUI with GPU acceleration, supporting image generation, 4x upscaling, and background removal with optimized Docker deployment.

mcp-server-chart

mcp-server-chart