Discover Awesome MCP Servers

zotero-mcp-lite

A lightweight and customizable MCP server for Zotero that enables AI research tools to access and manage references through a simple API.

Mail MCP

MCP server for any IMAP mailbox that lets AI models read, search, send, and manage email, including processing attachments as images.

ms-graph-mcp

Exposes Azure Entra ID user and license management as MCP tools over HTTP-SSE, enabling operations such as user creation, group assignment, and license management via Microsoft Graph API.

travel-planner

Enables travel planning through natural language, providing weather forecasts, attraction search, itinerary generation, and distance calculations using free APIs.

Onde Inference MCP Server

Enables managing Onde Inference accounts and model catalog operations through MCP tools such as login, app management, model registration, and assignment. Returns structured JSON over stdio for use with any MCP client.

Gemini Code Context MCP

Provides persistent codebase context caching via Gemini API, enabling fast, cost-effective repeat queries for MCP hosts like Claude Code.

Argo Workflow MCP Server

Enables AI agents to manage Argo Workflows through REST API, supporting workflow template and instance operations including creation, submission, monitoring, and deletion with token authentication.

Azure Model Context Protocol (MCP) Hub

Okay, here are some resources, tools, and potential starting points for building and integrating Model Context Protocol (MCP) servers on Azure using multiple languages. Keep in mind that MCP is relatively new, so the ecosystem is still developing. I'll focus on providing general guidance and tools that can be adapted. **Understanding Model Context Protocol (MCP)** Before diving into specific languages, make sure you have a solid understanding of MCP itself. Key aspects include: * **Purpose:** MCP aims to standardize the way models receive contextual information, making it easier to integrate models into various applications and workflows. * **Protocol:** It defines a standard interface for providing context to models, typically using HTTP or gRPC. * **Context:** This includes data, metadata, and other relevant information that helps the model make better predictions or decisions. **General Azure Resources & Tools (Language Agnostic)** These resources are useful regardless of the programming language you choose: * **Azure App Service:** A platform-as-a-service (PaaS) for hosting web applications, including MCP servers. It supports multiple languages (Node.js, Python, Java, .NET, etc.). [https://azure.microsoft.com/en-us/services/app-service/](https://azure.microsoft.com/en-us/services/app-service/) * **Azure Functions:** A serverless compute service that allows you to run code without managing servers. Ideal for smaller MCP server implementations or specific context providers. Supports multiple languages. [https://azure.microsoft.com/en-us/services/functions/](https://azure.microsoft.com/en-us/services/functions/) * **Azure Kubernetes Service (AKS):** A managed Kubernetes service for deploying and managing containerized applications, including MCP servers. Provides maximum flexibility and scalability. [https://azure.microsoft.com/en-us/services/kubernetes-service/](https://azure.microsoft.com/en-us/services/kubernetes-service/) * **Azure API Management:** A fully managed service that enables you to publish, secure, transform, monitor, and manage APIs. Useful for exposing your MCP server as a well-defined API. [https://azure.microsoft.com/en-us/services/api-management/](https://azure.microsoft.com/en-us/services/api-management/) * **Azure Container Registry (ACR):** A private registry for storing and managing container images. Essential if you're using AKS or deploying containerized MCP servers. [https://azure.microsoft.com/en-us/services/container-registry/](https://azure.microsoft.com/en-us/services/container-registry/) * **Azure Monitor:** Collects and analyzes telemetry data from your Azure resources, including your MCP servers. Helps you monitor performance, identify issues, and gain insights. [https://azure.microsoft.com/en-us/services/monitor/](https://azure.microsoft.com/en-us/services/monitor/) * **Azure Key Vault:** A secure store for secrets, keys, and certificates. Use it to protect sensitive information used by your MCP server. [https://azure.microsoft.com/en-us/services/key-vault/](https://azure.microsoft.com/en-us/services/key-vault/) **Language-Specific Guidance & Examples** Since MCP is a protocol, you can implement it in various languages. Here's a breakdown with potential approaches: **1. Python** * **Frameworks:** * **Flask:** A lightweight web framework for building APIs. Easy to learn and use. * **FastAPI:** A modern, high-performance web framework for building APIs with Python 3.6+ based on standard Python type hints. Excellent for data validation and serialization. * **gRPC (Python):** If MCP uses gRPC, use the `grpcio` package. * **Libraries:** * `requests`: For making HTTP requests to other services. * `pydantic`: For data validation and serialization. * `azure-identity`, `azure-storage-blob`, etc.: Azure SDKs for accessing other Azure services. * **Example (Conceptual - Flask):** ```python from flask import Flask, request, jsonify import json app = Flask(__name__) @app.route('/context', methods=['POST']) def provide_context(): try: data = request.get_json() # Get the request body as JSON # Process the data (context request) # ... your logic to fetch or generate context ... context_data = {"relevant_info": "example context", "source": "my_context_provider"} # Example context return jsonify(context_data), 200 # Return the context as JSON except Exception as e: return jsonify({"error": str(e)}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=80) ``` * **Deployment:** Deploy to Azure App Service, Azure Functions (using a custom handler), or AKS (using a Docker container). **2. Node.js (JavaScript/TypeScript)** * **Frameworks:** * **Express.js:** A popular web framework for Node.js. * **NestJS:** A framework for building efficient, scalable Node.js server-side applications. Uses TypeScript. * **gRPC (Node.js):** If MCP uses gRPC, use the `@grpc/grpc-js` package. * **Libraries:** * `axios`: For making HTTP requests. * `body-parser`: For parsing request bodies. * `@azure/identity`, `@azure/storage-blob`, etc.: Azure SDKs. * **Example (Conceptual - Express.js):** ```javascript const express = require('express'); const bodyParser = require('body-parser'); const app = express(); const port = 80; app.use(bodyParser.json()); app.post('/context', (req, res) => { try { const requestData = req.body; // Process the requestData (context request) // ... your logic to fetch or generate context ... const contextData = { relevant_info: "example context", source: "my_context_provider" }; res.json(contextData); } catch (error) { console.error(error); res.status(500).json({ error: error.message }); } }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` * **Deployment:** Deploy to Azure App Service, Azure Functions, or AKS. **3. Java** * **Frameworks:** * **Spring Boot:** A popular framework for building Java applications, including REST APIs. * **Micronaut:** A modern, full-stack framework for building modular, easily testable microservice applications. * **gRPC (Java):** If MCP uses gRPC, use the `io.grpc` libraries. * **Libraries:** * `RestTemplate` (Spring): For making HTTP requests. * `azure-identity`, `azure-storage-blob`, etc.: Azure SDKs. * **Example (Conceptual - Spring Boot):** ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import java.util.Map; import java.util.HashMap; @SpringBootApplication @RestController public class ContextProviderApplication { public static void main(String[] args) { SpringApplication.run(ContextProviderApplication.class, args); } @PostMapping("/context") public Map<String, String> provideContext(@RequestBody Map<String, Object> requestData) { // Process the requestData (context request) // ... your logic to fetch or generate context ... Map<String, String> contextData = new HashMap<>(); contextData.put("relevant_info", "example context"); contextData.put("source", "my_context_provider"); return contextData; } } ``` * **Deployment:** Deploy to Azure App Service, Azure Functions (using a custom handler), or AKS. **4. .NET (C#)** * **Frameworks:** * **ASP.NET Core:** A cross-platform, high-performance framework for building web APIs. * **gRPC (.NET):** If MCP uses gRPC, use the `Grpc.AspNetCore` package. * **Libraries:** * `HttpClient`: For making HTTP requests. * `Azure.Identity`, `Azure.Storage.Blobs`, etc.: Azure SDKs. * **Example (Conceptual - ASP.NET Core):** ```csharp using Microsoft.AspNetCore.Mvc; using System.Collections.Generic; namespace ContextProvider.Controllers { [ApiController] [Route("[controller]")] public class ContextController : ControllerBase { [HttpPost("/context")] public ActionResult<Dictionary<string, string>> ProvideContext([FromBody] Dictionary<string, object> requestData) { // Process the requestData (context request) // ... your logic to fetch or generate context ... var contextData = new Dictionary<string, string> { { "relevant_info", "example context" }, { "source", "my_context_provider" } }; return contextData; } } } ``` * **Deployment:** Deploy to Azure App Service, Azure Functions, or AKS. **Key Considerations for Implementation** * **Data Format:** Determine the data format for the context (JSON, Protobuf, etc.) and use appropriate libraries for serialization and deserialization. * **Authentication/Authorization:** Secure your MCP server using Azure Active Directory (Azure AD) or other authentication mechanisms. * **Error Handling:** Implement robust error handling and logging. * **Scalability:** Design your MCP server to handle the expected load. Consider using caching, load balancing, and autoscaling. * **Monitoring:** Use Azure Monitor to track the performance and health of your MCP server. * **Context Sources:** Identify the sources of context data (databases, APIs, files, etc.) and implement the logic to retrieve and transform the data. * **MCP Specification:** Carefully review the MCP specification (if available) to ensure your implementation is compliant. If there isn't a formal specification, work with the model providers to define a clear contract. * **gRPC vs. REST:** Decide whether to use gRPC or REST (HTTP) for your MCP server. gRPC is generally more efficient for high-performance scenarios, but REST is often simpler to implement. **Steps to Get Started** 1. **Choose a Language:** Select the language you're most comfortable with or that best fits your requirements. 2. **Set up Azure Resources:** Create an Azure account and provision the necessary resources (App Service, Functions, AKS, etc.). 3. **Implement the MCP Server:** Write the code to handle context requests, retrieve context data, and return it in the appropriate format. 4. **Deploy to Azure:** Deploy your MCP server to Azure. 5. **Test and Monitor:** Thoroughly test your MCP server and monitor its performance. **Important Notes:** * **MCP is Evolving:** The Model Context Protocol is a relatively new concept, so the specific details and best practices may change over time. Stay up-to-date with the latest developments. * **No Official Azure MCP SDK:** As of now, there isn't a dedicated Azure SDK specifically for MCP. You'll need to use general-purpose web frameworks and Azure SDKs to implement the protocol. * **Focus on the Interface:** The key is to implement the MCP interface correctly, regardless of the underlying language or framework. I hope this comprehensive guide helps you get started with building and integrating MCP servers on Azure! Let me know if you have any more specific questions.

mockscreenshots-mcp

Compose fake chat conversations and receive deep links to a pre-filled generator for preview, parody, and design mockups.

garmin-raw-mcp

Provides raw Garmin Connect data access for training analysis, enabling retrieval of activity summaries, lap data, time-series streams, comments with lactate, wellness metrics, and personal records through an MCP interface.

postlayer-connect

A local MCP server that enables AI assistants to post to social media platforms (LinkedIn, X, Bluesky, Mastodon, Reddit, etc.) using your own app credentials, with encrypted token storage and no middleman.

ClickHouse Cloud API MCP Server

A Multi-Agent Conversation Protocol server that enables interaction with the ClickHouse Cloud API, providing programmatic access to ClickHouse Cloud services through natural language.

Android Project MCP Server

Enables building, running unit tests, and instrumented tests for Android projects through the MCP protocol.

Time MCP Server

Provides current time and timezone conversion using IANA timezone names, enabling LLMs to get time information and convert times between timezones.

Vivado MCP Native

Enables AI clients to directly launch, control, and analyze AMD/Xilinx Vivado on Windows and Linux, supporting project management, synthesis, implementation, bitstream generation, timing/resource analysis, and simulation through a persistent Tcl session.

AI-SDLC-MCP-Server

Local MCP server for static Python/TypeScript code audits, Playwright test generation, and SDLC health checks with a 0-100 quality score.

MCP-Coinglass

Provides futures market analytics (Open Interest, Liquidations, Long/Short Ratio, Funding Rates) via the CoinGlass API v4, enabling natural language queries for crypto derivatives data.

Pi-hole MCP Server

Enables management of Pi-hole DNS servers through natural language commands, including enabling/disabling blocking, viewing statistics, and configuration.

Vertica MCP Server

A Model Context Protocol server that enables AI assistants to interact with Vertica databases through SQL queries, schema inspection, database documentation, and data export capabilities.

argus

Reverse engineering against a running Windows process instead of the file on disk: memory reads, pattern and value scanning, disassembly of the code that actually executed, resolved IAT thunks, caller-chain tracing, and structure recovery. Complements the Ghidra and IDA servers rather than replacing them — correlate_addr maps a runtime address back to a module and RVA.

serpdive

Provides AI coding agents with a live web search tool that returns extracted, answer-ready text from web pages. Enables real-time information retrieval without any local installation or maintenance.

sre-toolkit-mcp

Enables LLM agents to perform SRE reliability calculations like error budgets and burn rates using deterministic tools, integrating with Prometheus and Loki for real data.

AI List My Business

Country-agnostic MCP-callable directory for AI agents to find local SMBs — realtors, insurance agents, medical practitioners — by category, location, or natural-language query. Returns business catalog data and UTM-tagged booking URLs (zero PII).

openrouter-mcp

Enables AI assistants to consult other AI models via OpenRouter for help with coding tasks.

Sonarr MCP Server

Enables AI assistants to manage TV series collections through Sonarr's API using natural language interactions. Supports searching, adding, updating, and deleting TV series with detailed control over quality profiles, season monitoring, and episode downloads.

touchdesigner-mcp

Lets Codex inspect, build, wire, tune, sample, and visually verify running TouchDesigner projects for generative visuals, audio-reactive systems, and fast agent-assisted prototyping.

MCP X++ Server

An MCP server for Microsoft Dynamics 365 Finance & Operations that enables the creation, modification, and analysis of D365 objects like classes, tables, and forms. It integrates with Visual Studio 2022 to provide tools for X++ code extraction, codebase search, and safe object deletion with dependency validation.

persistenceone-bridgekitty

Cross-chain bridge aggregator MCP server for AI agents. Compares routes across LI.FI, deBridge, Relay, Across and Squid to find the best rate. Use when an agent needs to bridge or swap tokens between EVM chains, Solana, or Cosmos. The aggregator of aggregators.

mcp-horoscope

Horoscope MCP — wraps the keyless Horoscope App API.