Discover Awesome MCP Servers

Remote MCP Server (Authless)

A template for deploying unauthenticated MCP servers on Cloudflare Workers that can be accessed remotely via SSE from clients like Claude Desktop or the Cloudflare AI Playground.

Sola MCP Server

A stateless HTTP server implementing the Model Context Protocol (MCP) that enables applications to interact with Social Layer platform data including events, groups, profiles, and venues via standardized endpoints.

mcp-perfex-crm

High-performance MCP server for Perfex CRM that provides direct MySQL access for managing customers, invoices, leads, projects, and more, with 10-100x faster performance than REST API.

z-code-mcp

Enables orchestration of multiple Claude Code sessions for complex multi-task coding projects with HEAD/SUB coordination and dependency-based task execution.

Profiles MCP Server

Enables building RudderStack Profiles projects using natural language through AI assistants, supporting data discovery, identity resolution, feature engineering, and propensity modeling.

smhi-mcp

MCP server that provides real-time weather data, forecasts, and historical weather information from SMHI (Swedish Meteorological and Hydrological Institute) for any location in Sweden.

Vercel MCP Server

A Model Control Protocol server template deployed on Vercel that demonstrates MCP implementation with a dice rolling tool, serving as a foundation for building custom MCP servers.

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.

test-data-mocking-mcp

An MCP server that mocks payments, third-party API responses, and test data to enable QA flows for donation, checkout, SIP, and subscription pages without depending on a live gateway.

MCP MySQL Server

Enables Claude Desktop to interact with MySQL databases through secure query execution, schema discovery, and multi-database support with configurable read/write permissions and built-in SQL injection protection.

googlenews-mcp

Enables AI agents to read Google News without internet access, providing tools for top headlines, topic search, and news searches.

autocad-mcp

Enables AI agents to automate AutoCAD LT and create DXF files headless, with tools for drawing, entity, layer, block, annotation, PID, and system operations.

hut-reservation-mcp

Enables searching SAC huts, checking availability, and preparing booking or cancellation handoffs on hut-reservation.org with a safety model for writes.

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.

TPLCP Reference MCP

Turns the 2026 CLCP orientation corpus into a searchable, citation-preserving reference source for TPLCP report work.

Luxembourgish Competition MCP

Enables querying Luxembourgish competition data, including regulations, decisions, and requirements from the Conseil de la concurrence, directly from MCP-compatible clients.

Aden Aggregates MCP Server

Exposes Aden Aggregates submittal data as tools callable by Claude, enabling retrieval of location, material, pricing, and lab report information to build submittal packages.

Canvas AIGC

A MCP server that bridges web canvas with local Codex/Claude, exposing 23 tools for reading, creating, modifying, connecting, and generating canvas content via local HTTP bridge and stdio MCP.

Agentic Travel Recommendations Service

Enables agents to discover and invoke travel recommendations with partner-specific caps and exclusions via MCP JSON-RPC.

Semantic Mesh Memory (SEM) MCP Server

Provides a coherent memory layer for LLM agents that models beliefs as nodes in a constraint network to detect and surface semantic contradictions. It uses local embeddings and a hybrid geometric-logical energy model to identify conflicting information that requires review.

duplicacy-mcp

MCP server that reads Duplicacy backup metrics from a Prometheus exporter and exposes them to LLMs for monitoring backup status, progress, and health.

globus-mcp

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

TradingView-MCP

Enables AI to analyze and manipulate TradingView charts via Chrome DevTools Protocol, and access market data through public scanner API.

freshrss-mcp-server

MCP server for interacting with FreshRSS via the Google Reader API, enabling subscription management, content reading, and item operations.

odoo-mcp-uvx

A read-only MCP server that enables AI assistants to query Odoo instances via XML-RPC, supporting search, read, count, and field inspection without requiring custom modules.

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!

Calendar MCP Server

A production-quality MCP server for calendar management with robust timezone handling, recurrence support, and idempotency guarantees.

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.

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.