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.

mcp-flyin

A server that handles messaging or commands over a custom protocol

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.

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.

ClinicalTrials.gov MCP Server

Empowers AI agents with direct access to the official ClinicalTrials.gov database, enabling programmatic searching, retrieval, and analysis of clinical study data through a Model Context Protocol interface.

Blogger MCP Server

Enables AI assistants to interact with the Google Blogger API v3 to manage blog posts and metadata. It supports the full post lifecycle including creating, updating, publishing, and deleting content through natural language.

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.

Expo MCP Server

A Model Context Protocol server designed to streamline Expo and React Native development for AI assistants like Cursor and Claude. It provides a comprehensive suite of tools for project initialization, EAS builds, OTA updates, and development server management.

Confluence-Based Code Review MCP Server

An MCP server that performs code reviews by comparing local source code against design documents stored in Confluence. It integrates with Atlassian MCP servers to analyze documentation and provide suggestions for quality improvement based on design specifications.

OrigeneMCP

An advanced integrated MCP server platform that combines 600+ tools and multiple biomedical databases to enable comprehensive information retrieval across molecules, proteins, genes, and diseases for accelerating therapeutic research.

Fizzy MCP Server

Enables AI assistants to interact with Fizzy project management boards, cards, and tasks through natural language. It provides full API coverage for managing project workflows, comments, and notifications across multiple transport protocols and IDEs.

Expo Docs MCP Server

Enables AI-powered semantic search through Expo SDK documentation across multiple versions (v51-v53 and latest), allowing developers to quickly find relevant documentation with configurable similarity scoring.

macOS Automator MCP Server

A Model Context Protocol server that enables execution of AppleScript and JavaScript for Automation scripts on macOS, allowing programmatic control of applications and system functions through a rich knowledge base of pre-defined scripts.

Reddit MCP Server

Enables AI agents to search Reddit for posts, comments, and users or monitor for high-intent leads and brand mentions. It functions by delegating scraping tasks to high-performance Apify cloud actors.

Weather MCP Server

Connects Claude Desktop to the Open-Meteo API to retrieve real-time weather data for cities worldwide without requiring an API key.

Hyperbrowser MCP Server

Provides tools to scrape, extract structured data, and crawl webpages, with access to browser automation agents like OpenAI's CUA, Anthropic's Claude Computer Use, and Browser Use for complex web tasks.

mcp-calendly

Enables interaction with Calendly to manage event types, scheduled events, and invitees. It provides tools for checking user availability and canceling appointments directly through the Calendly API.

obsidian-self-mcp

An MCP server providing direct programmatic access to Obsidian vaults through CouchDB, the database used by Obsidian LiveSync. It enables AI agents to read, write, and manage notes and metadata in headless environments without requiring the Obsidian desktop app.

mcp-servers-experiments

Este repositorio contiene mis experimentos con servidores MCP.

MCP Bear

A Python-based MCP server that provides read and write access to Bear Notes on macOS using SQLite for data retrieval and x-callback-url for modifications. It enables users to search, create, archive, and manage notes and tags directly through a Model Context Protocol interface.

MCP RAG Server

Enables retrieval-augmented generation (RAG) by indexing and searching through documents (Markdown, text, PowerPoint, PDF) using vector embeddings with multilingual-e5-large model and PostgreSQL pgvector. Supports contextual chunk retrieval and incremental indexing for efficient document management.

Laboratory Inventory HTTP Server

Provides a RESTful API to query laboratory inventory data from MongoDB, including stock levels, expiration tracking, and purchase suggestions. It is specifically designed to optimize token usage for AI assistants through dedicated tool endpoints for inventory management.

P-Link-MCP

Payment & Transaction Tools that allow AI agents to send, receive, and request payments

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.

Advanced HWP MCP Server

Enables comprehensive control of Korean Hangul (HWP) documents with 59 features including document manipulation, text editing, formatting, table operations, PDF export, and advanced automation capabilities like template filling and document structure analysis.

EdgeOne Pages MCP Server

A self-hosted MCP server that enables AI assistants to deploy and manage static websites directly on EdgeOne Pages platform with KV storage support.

iMCP

A universal bridge that turns legacy backend services and modern APIs into AI-accessible tools without requiring code rewrites. It dynamically generates tool definitions from WSDL, OpenAPI, or custom JSON specs to enable AI assistants to interact with systems like SAP, IBMi, and SOAP services.

Weather MCP Tool

A Model Context Protocol tool that provides weather information for cities, with London access requiring Solana devnet payment via the Latinum Wallet MCP server.

CloudBase MCP

Bridges AI IDEs with Tencent CloudBase for seamless deployment, enabling users to go from AI-generated code to live applications with automatic cloud resource configuration, database setup, and intelligent debugging.