Discover Awesome MCP Servers

Resemble AI Voice Generation MCP Server

Se integra con Claude y Cursor utilizando el Protocolo de Contexto del Modelo para generar audio de voz a partir de texto utilizando las voces de Resemble AI.

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.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol servers using TypeScript, featuring example tools (calculator, greeting) and resources (server info) with Zod schema validation.

MySQL MCP Server Pro

Provides comprehensive MySQL database operations including CRUD, performance optimization, health analysis, and anomaly detection. Supports multiple connection modes, OAuth2.0 authentication, and role-based permissions for database management through natural language.

Playwright MCP Server

A minimal server that exposes Playwright browser automation capabilities through a simple API, enabling webpage interaction, DOM manipulation, and content extraction via the Model Context Protocol.

MCP Server

A centralized architecture that serves as the only data access layer between frontend/backend applications and Supabase/Redis, enforcing strict data access control while maintaining simplicity and efficiency.

MCP Home Assistant

Enables natural language control of Home Assistant smart home devices through Cursor AI, supporting entity queries, automation management, configuration file editing, and system operations.

Uni-res_MCP

An MCP server for my University Results

Multilead Open API MCP Server

Enables AI assistants to interact with the Multilead platform for lead management, email campaigns, conversations, webhooks, and analytics through 74 API endpoints.

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.

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.

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-servers-experiments

Este repositorio contiene mis experimentos con servidores MCP.

P-Link-MCP

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

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.

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.

Formath MCP

Enables extraction of mathematical content from TeX papers and conversion to Lean code through a structured intermediate representation. Supports project scaffolding, entity management, and task tracking for mathematical formalization workflows.

Index Network MCP Server

Enables ChatGPT integration with Index Network's discovery protocol through MCP tools. Provides quick setup with ngrok tunneling for public access and includes health check, echo, and search functionality.

PayPal MCP Server

A server that provides integration with PayPal's APIs, enabling seamless interaction with payment processing, invoicing, subscription management, and business operations through a standardized interface.

Readwise Reader MCP Server

Enables Claude to interact with the Readwise Reader API, allowing for saving, listing, updating, and deleting documents with complete metadata and content access through natural language.

Kogna MCP Server

Enables interaction with Kogna's multi-agent AI avatar system, allowing users to start conversations, switch between specialized avatars and rooms, and manage conversation history through natural language.

ms-sentinel-mcp-server

ms-sentinel-mcp-server

Godot MCP Server

An MCP server that provides tools for Godot Engine development, enabling users to run unit tests, check for syntax errors, and manage project scenes or exports.

MCP E-commerce Demo

A Laravel-based Model Context Protocol demonstration that enables users to manage orders and query e-commerce data in Traditional Chinese through an AI-powered chat interface.