Discover Awesome MCP Servers

open-meteo-mcp-lite

A lightweight MCP server for Open-Meteo weather API, providing current weather, forecasts, location search, and more without requiring an API key.

Pirog MCP Server

Provides Pokemon data access through MCP tools like get_pokemon, list_pokemon, and evolution chains via PokeAPI.

MySQL-Performance-Tuner-Mcp

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

lightwave-mcp

Enables AI agents to discover and control LightwaveRF Smart Series devices (lights, switches, sockets) via the official REST API, using natural language commands like 'turn off the kitchen light'.

Cryptocurrency Market Data Server

主要な取引所との連携を通じて、リアルタイムおよび過去の暗号通貨市場データを提供します。このサーバーにより、ClaudeのようなLLMは、現在の価格を取得し、市場のトレンドを分析し、詳細な取引情報にアクセスできます。

codebase-memory-mcp

Local-first repository memory for AI coding agents that indexes codebases into SQLite and exposes it through MCP tools, with a browser dashboard for architecture inspection.

Ninja MCP

MCP server for AI agents to interact with the Ninja/AnaNinja mobile API, enabling mobile-compatible auth, address management, retail/grocery product search, draft order validation, and checkout/payment flows.

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.

project-mcp

A FastMCP server that exposes predefined artifacts as Resources and project lifecycle operations as Tools for creating, updating, deploying, debugging, testing, monitoring, and configuring projects with minimal token usage.

VictoriaTraces MCP Server

Provides access to your VictoriaTraces instance and seamless integration with VictoriaTraces APIs and documentation for querying traces, services, and operations.

ahshare-mcp

Provides access to Chinese A-share market financial data, including historical K-line, real-time quotes, financial statements, shareholder information, and technical indicators, via MCP protocol.

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, I understand you're looking for Azure DevOps code examples, specifically using C#, for both a server (presumably interacting with the Azure DevOps API) and a client (likely consuming data from the server or directly from Azure DevOps). Providing a complete, ready-to-run application without knowing the specific functionality you need is impossible. However, I can give you a solid foundation with code snippets and explanations to get you started. I'll break it down into server-side and client-side examples, focusing on common tasks. **Important Considerations Before You Start:** * **Azure DevOps Organization and Project:** You'll need an Azure DevOps organization and a project within that organization to test these examples. * **Personal Access Token (PAT):** You'll need a PAT with the appropriate scopes to access the Azure DevOps API. **Treat your PAT like a password! Do not hardcode it directly into your code.** Use environment variables, configuration files, or Azure Key Vault to store it securely. The scopes you need will depend on the specific API calls you're making (e.g., `vso.work`, `vso.code`, `vso.release`). * **NuGet Packages:** You'll need to install the necessary NuGet packages. The primary one is `Microsoft.TeamFoundationServer.Client`. You might also need `Microsoft.VisualStudio.Services.Client` and potentially others depending on your specific needs. **1. Server-Side (C# - ASP.NET Core Web API Example)** This example demonstrates how to retrieve work items from Azure DevOps using the REST API. ```csharp using Microsoft.AspNetCore.Mvc; using Microsoft.TeamFoundation.WorkItemTracking.WebApi; using Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models; using Microsoft.VisualStudio.Services.Common; using Microsoft.VisualStudio.Services.WebApi; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace AzureDevOpsApi.Controllers { [ApiController] [Route("[controller]")] public class WorkItemsController : ControllerBase { private readonly string _organizationUrl; private readonly string _personalAccessToken; private readonly string _project; public WorkItemsController(IConfiguration configuration) // Use IConfiguration to read settings { _organizationUrl = configuration["AzureDevOps:OrganizationUrl"]; _personalAccessToken = configuration["AzureDevOps:PersonalAccessToken"]; _project = configuration["AzureDevOps:Project"]; } [HttpGet] public async Task<IActionResult> GetWorkItems() { try { // Create connection to Azure DevOps var connection = new VssConnection(new Uri(_organizationUrl), new VssBasicCredential(string.Empty, _personalAccessToken)); // Get the WorkItemTrackingHttpClient using (var workItemClient = connection.GetClient<WorkItemTrackingHttpClient>()) { // Construct WIQL (Work Item Query Language) query var wiql = new Wiql() { Query = $"Select [Id], [Title], [State] From WorkItems Where [Team Project] = '{_project}' AND [Work Item Type] = 'Task' AND [State] <> 'Closed' ORDER BY [Id]" }; // Execute the query to get work item IDs var result = await workItemClient.QueryByWiqlAsync(wiql); if (result == null || result.WorkItems == null || result.WorkItems.Count == 0) { return NotFound("No work items found."); } // Get the full work items based on the IDs List<int> workItemIds = result.WorkItems.Select(wi => wi.Id).ToList(); var workItems = await workItemClient.GetWorkItemsAsync(workItemIds); return Ok(workItems); } } catch (Exception ex) { // Log the exception properly! Console.WriteLine(ex.ToString()); return StatusCode(500, "An error occurred while retrieving work items."); } } } } ``` **Explanation:** 1. **Dependencies:** Requires `Microsoft.AspNetCore.Mvc`, `Microsoft.TeamFoundationServer.Client`, `Microsoft.VisualStudio.Services.Client`. 2. **Configuration:** The code reads the Azure DevOps organization URL, PAT, and project name from the application's configuration (e.g., `appsettings.json`). **This is crucial for security!** 3. **`VssConnection`:** Creates a connection to your Azure DevOps organization using the URL and PAT. `VssBasicCredential` is used for PAT authentication. 4. **`WorkItemTrackingHttpClient`:** Gets an instance of the Work Item Tracking HTTP client, which allows you to interact with work items. 5. **WIQL Query:** Constructs a WIQL query to select work items. WIQL is similar to SQL but specifically designed for querying work items in Azure DevOps. **Important:** Adjust the query to match your specific needs. This example retrieves all open tasks. 6. **`QueryByWiqlAsync`:** Executes the WIQL query and returns a list of work item references (IDs). 7. **`GetWorkItemsAsync`:** Retrieves the full work item details based on the IDs obtained from the query. 8. **Error Handling:** Includes basic error handling. **In a production environment, you should implement robust logging and error handling.** 9. **Return Value:** Returns an `IActionResult`. `Ok()` returns a 200 OK with the work items, and `NotFound()` returns a 404 if no work items are found. `StatusCode(500)` returns a 500 Internal Server Error in case of an exception. **appsettings.json (Example):** ```json { "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*", "AzureDevOps": { "OrganizationUrl": "https://dev.azure.com/your-organization", "PersonalAccessToken": "your-personal-access-token", "Project": "YourProjectName" } } ``` **Important:** Replace `"https://dev.azure.com/your-organization"`, `"your-personal-access-token"`, and `"YourProjectName"` with your actual values. Consider using environment variables instead of storing the PAT directly in `appsettings.json`. **2. Client-Side (C# - Console Application Example)** This example demonstrates how to consume the API endpoint created in the server-side example. ```csharp using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text.Json; using System.Threading.Tasks; namespace AzureDevOpsClient { class Program { private static readonly HttpClient client = new HttpClient(); static async Task Main(string[] args) { // Replace with the actual URL of your API endpoint string apiUrl = "https://localhost:7000/WorkItems"; // Or your deployed API URL try { // Call the API string json = await GetAsync(apiUrl); // Deserialize the JSON response if (!string.IsNullOrEmpty(json)) { // Assuming the API returns a JSON array of WorkItem objects // You'll need to define a WorkItem class that matches the structure of the JSON // For example: // public class WorkItem { public int Id { get; set; } public string Title { get; set; } public string State { get; set; } } // List<WorkItem> workItems = JsonSerializer.Deserialize<List<WorkItem>>(json); // For demonstration purposes, let's just print the raw JSON Console.WriteLine(json); } else { Console.WriteLine("No data received from the API."); } } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } Console.ReadKey(); } static async Task<string> GetAsync(string uri) { HttpResponseMessage response = await client.GetAsync(uri); response.EnsureSuccessStatusCode(); return await response.Content.ReadAsStringAsync(); } } } ``` **Explanation:** 1. **`HttpClient`:** Creates an `HttpClient` to make HTTP requests to the API. 2. **`apiUrl`:** Replace `"https://localhost:7000/WorkItems"` with the actual URL of your deployed API endpoint. 3. **`GetAsync`:** Sends an HTTP GET request to the API endpoint. 4. **`Deserialize`:** Deserializes the JSON response from the API into a C# object. **You'll need to define a C# class (`WorkItem` in the example) that matches the structure of the JSON returned by the API.** The example shows a basic `WorkItem` class; you'll need to adjust it based on the actual fields returned by your API. 5. **Error Handling:** Includes basic error handling. 6. **Output:** Prints the deserialized work item data to the console. **Important Notes:** * **JSON Serialization/Deserialization:** The `System.Text.Json` namespace is used for JSON serialization and deserialization. You can also use `Newtonsoft.Json` if you prefer (install the `Newtonsoft.Json` NuGet package). * **`WorkItem` Class:** You'll need to define a `WorkItem` class (or a class that represents the data structure returned by your API) to properly deserialize the JSON response. The properties of the class should match the names and data types of the fields in the JSON. * **API URL:** Make sure to replace `"https://localhost:7000/WorkItems"` with the correct URL of your API endpoint. If you're running the API locally, it might be a different port number. If you've deployed the API to Azure or another hosting environment, use the deployed URL. * **Authentication (Client-Side):** If your API requires authentication (e.g., an API key or bearer token), you'll need to add the appropriate headers to the `HttpClient` request. For example, to add a bearer token: ```csharp client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your-api-token"); ``` **Further Development:** * **Error Handling:** Implement comprehensive error handling in both the server-side and client-side code. Log errors to a file or database for debugging. * **Dependency Injection:** Use dependency injection to manage dependencies (e.g., the `WorkItemTrackingHttpClient`) in a more testable and maintainable way. * **Asynchronous Operations:** Use `async` and `await` for all I/O-bound operations (e.g., API calls) to prevent blocking the UI thread. * **Data Validation:** Validate the data received from the API to ensure it's in the expected format. * **Unit Testing:** Write unit tests to verify the functionality of your code. * **Security:** Implement proper security measures to protect your application and data. This includes using HTTPS, validating user input, and protecting against common web vulnerabilities. * **Authentication/Authorization:** Implement proper authentication and authorization mechanisms to control access to your API. * **Configuration Management:** Use a robust configuration management system to manage your application's settings. * **Logging:** Implement comprehensive logging to track application behavior and diagnose problems. * **Deployment:** Use a proper deployment pipeline to deploy your application to a production environment. **Key Improvements and Best Practices:** * **Configuration:** Use `IConfiguration` to read settings from `appsettings.json` or environment variables. This is much better than hardcoding values. * **Error Handling:** Include `try-catch` blocks and log exceptions. Don't just swallow exceptions. * **Asynchronous Operations:** Use `async` and `await` for all network operations. * **Resource Management:** Use `using` statements to ensure that resources (like `HttpClient` and `WorkItemTrackingHttpClient`) are properly disposed of. * **Security:** Never hardcode your PAT. Store it securely in environment variables or Azure Key Vault. * **WIQL:** Learn WIQL to create more complex and efficient queries. * **Data Transfer Objects (DTOs):** Consider using DTOs to represent the data that is transferred between the server and the client. This can help to decouple the client from the server and make it easier to change the server-side implementation without breaking the client. This comprehensive example provides a strong starting point for building your Azure DevOps integration with C#. Remember to adapt the code to your specific requirements and follow best practices for security, error handling, and maintainability. 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.

RetireGolden MCP

Headless MCP server for the RetireGolden retirement-planning calculator, providing typed tools to build/validate plans, run projections, Monte Carlo simulations, and optimization via stdio.

Ultimath

Stop hallucinating numbers. An MCP server that runs every math expression through four independent numeric engines in parallel and returns all four results side by side — so when they disagree, you know the answer is numerically unreliable.