Discover Awesome MCP Servers

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.

travel-planner

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

Arcane MCP

AI-powered Docker management server that enables natural language control of environments, containers, images, networks, volumes, and more through a unified Arcane API interface.

resume-mcp

MCP server for maintaining a professional profile database and generating tailored, ATS-optimized resumes for specific job postings.

temporal-mcp

Provides LLM agents with a sense of time between turns via two MCP tools that track elapsed time and day rollover per conversation thread.

MCP Hub

An Express server implementation of Model Context Protocol that allows websites to connect to LLMs through streamable HTTP and stdio transports, with a built-in chat UI for testing responses.

Primo MCP Server

MCP server for searching Ex Libris Primo library catalogues and subscribed databases, enabling search, record retrieval, autocomplete, citation generation, and export to BibTeX, RIS, or CSV.

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.

@agenticbits/claude-plugin

Adds a live git branch status bar to the Claude interface for monitoring multiple repositories simultaneously. It provides tools for managing repository tracking and visibility through natural language commands.

discord-mcp

MCP server with over 70 tools to manage and maintain an entire Discord server.

Disclose MCP Server

Enables AI agents to query merchant operational signals like return rates, fulfillment accuracy, and chargeback ratios published through the Disclose protocol. Provides tools to fetch merchant disclosures and check signal coverage for completeness.

macOS MCP Servers

Enables Claude Desktop and GitHub Copilot to interact with native macOS applications including Spotify, Apple Music, Notes, Calendar, FaceTime, and Contacts through natural language commands. Provides comprehensive control over music playback, note management, calendar events, video calls, and contact operations using AppleScript integration.

Chicken Business Management MCP Server

Enables real-time voice-to-text order processing and chicken business management through WebSocket connections and REST APIs. Supports inventory tracking, sales parsing, stock forecasting, and note collection with AI-powered transcript correction and structured data extraction.

Audacity MCP Server

There isn't a direct "MCP server" specifically designed for Audacity. It sounds like you might be looking for a way to control Audacity remotely or integrate it with other software. Here are a few possibilities, depending on what you're trying to achieve: * **Modifying Audacity's Code (Most Likely Not What You Want):** If you're thinking of "MCP" in the sense of modifying the core Audacity program, that's a very advanced task. Audacity is open-source, so you *could* theoretically create a custom build with server-like functionality, but this would require significant programming knowledge (C++). * **Remote Control via Scripting (More Likely):** Audacity has scripting capabilities. You can use Python (with the `mod-script-pipe` module) to send commands to Audacity and receive responses. This allows you to automate tasks and potentially control Audacity from another application or even a remote server. This is probably the closest to what you're looking for. * **Networked Audio (Less Likely, but Possible):** If you're trying to stream audio *to* Audacity from a remote location, you might be thinking of networked audio protocols like Dante, Ravenna, or even simpler solutions like streaming audio over RTP. However, these aren't directly related to an "MCP server" concept. To help me give you a more specific answer, please tell me: * **What are you trying to accomplish?** What do you want to do with Audacity remotely? * **What does "MCP" mean to you in this context?** Is it an acronym for something? * **What other software or systems are you trying to integrate with Audacity?** With more information, I can provide a more accurate and helpful response.

artl-mcp

Enables comprehensive scientific literature retrieval and analysis through Europe PMC, PubMed, and other databases, supporting metadata extraction, full-text access, and identifier conversion via MCP and CLI.

Personal Knowledge Assistant

Manages and analyzes personal information across email, social media, documents, and productivity metrics with AI-powered insights, communication pattern analysis, and cross-platform content management.

bamboohr-mcp

A read-only MCP server for BambooHR that enables safe AI assistant access to employee records, time-off, files, and directories via natural language queries.

smart-fork

An MCP server for Claude Code that enables semantic search of past session transcripts and intelligent session forking, allowing users to find and resume from relevant previous conversations with full context.

github-pr-mcp

Enables GitHub repository operations (list/read files, create branches, commit files, open/list PRs) via an authless remote MCP server that keeps your GitHub token encrypted on Cloudflare, with access limited to allowed repositories.

Backstory

Search your data exports from Google, Telegram, Spotify, and Instagram in one place. Everything runs on your own computer. Hybrid search and MCP, built in .NET 10

Me-MCP

A personal MCP Server that allows AI agents to retrieve your resume and contact you through Discord webhooks, deployable via Cloudflare Workers.

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).

Ross MCP

Personal life admin MCP server that manages Apple Reminders from any Claude session via a cloud relay to a local Mac agent.

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.

perplexity-mcp-server

An MCP server that enables AI assistants to query Perplexity AI for web-grounded answers with citations and advanced search filters.

MCP OCI Registry Server

A Model Context Protocol (MCP) server for querying OCI container registries. Provides tools and prompts for interacting with registries like Docker Hub, GHCR, and other OCI-compatible registries.

Velixar MCP Server

The first cognitive memory server for AI assistants, providing persistent memory, knowledge graph, identity awareness, contradiction detection, and belief tracking across sessions.

mcp-horoscope

Horoscope MCP — wraps the keyless Horoscope App API.

MCP Game Helper

Servidor de Protocolo de Contexto de Modelo Personalizado (MCP) que proporciona herramientas impulsadas por IA para ayudar a los desarrolladores de juegos en tareas relacionadas con el equilibrio de combate, el análisis de habilidades, el ritmo de los niveles y la simulación.