Discover Awesome MCP Servers

generator-mcp

Yeoman Generator to quickly create a new MCP Server

mcp-server-datahub

El servidor MCP oficial para DataHub (

Browser JavaScript Evaluator

This is a reference design for a MCP server that hosts a web page that connects back to the server via sse and allows Claude to execute javascript on the page.

mcp_server_local_files

Local File System MCP Server

MCP Expert Server

Mirror of

NSAF MCP Server

Espejo de

MCP Server Playwright

MCP Server Playwright - Un servicio de automatización de navegador para Claude Desktop

Gmail MCP Server

Mirror of

Initial thoughts

Okay, here's a breakdown of how to convert OpenAPI specifications to MCP (presumably, you mean Media Control Protocol) server-ready tools, along with considerations and potential approaches. Since "MCP server-ready tools" is a bit vague, I'll cover a few interpretations and provide general guidance. **Understanding the Goal** First, let's clarify what you mean by "MCP server-ready tools." Here are a few possibilities: * **Code Generation (Server Stubs):** You want to automatically generate server-side code (stubs, skeletons) from your OpenAPI specification that can handle MCP requests. This is the most common interpretation. * **API Gateway Configuration:** You want to configure an API gateway (like Kong, Tyk, or AWS API Gateway) to handle MCP requests based on your OpenAPI definition. * **Testing Tools:** You want to generate test cases or testing frameworks that can validate your MCP server implementation against the OpenAPI specification. * **Documentation Generation:** You want to generate documentation for your MCP server based on the OpenAPI specification. * **Data Transformation/Mapping:** You need to transform data from the format defined in your OpenAPI spec to the format expected by your MCP server, or vice versa. **General Workflow** The general process involves these steps: 1. **Define your API with OpenAPI:** Create a well-defined OpenAPI specification (YAML or JSON) that accurately describes your MCP API. This is the *most important* step. The quality of your OpenAPI definition directly impacts the quality of the generated tools. 2. **Choose a Tool/Approach:** Select a tool or method that suits your specific needs (code generation, API gateway configuration, testing, etc.). 3. **Configure the Tool:** Configure the chosen tool with your OpenAPI specification and any necessary options (e.g., target language for code generation, API gateway settings). 4. **Generate/Deploy:** Run the tool to generate the desired output (code, configuration files, test scripts, documentation). 5. **Customize (if needed):** The generated output might require some customization to fully integrate with your MCP server environment. **Specific Approaches and Tools** Here are some tools and approaches, categorized by common use cases: **1. Code Generation (Server Stubs)** * **OpenAPI Generator:** This is a very popular and versatile tool. It supports a wide range of server-side languages and frameworks (e.g., Java Spring, Python Flask, Node.js Express, Go). * **How to use:** ```bash # Example: Generate a Python Flask server stub openapi-generator generate -i your_openapi.yaml -g python-flask -o output_directory ``` Replace `your_openapi.yaml` with the path to your OpenAPI file, `python-flask` with the desired generator, and `output_directory` with the output directory. * **Considerations:** You'll need to install OpenAPI Generator (usually via `brew install openapi-generator` or downloading the JAR file). You'll also need to choose the appropriate generator for your target language and framework. The generated code will typically provide the basic structure for your API endpoints; you'll need to implement the actual business logic. * **Swagger Codegen (Older, but still used):** A predecessor to OpenAPI Generator. It's still functional, but OpenAPI Generator is generally preferred due to its wider support and active development. * **Commercial Tools:** Some commercial API management platforms offer code generation capabilities as part of their suite. **2. API Gateway Configuration** * **Kong:** A popular open-source API gateway. You can import your OpenAPI specification into Kong to automatically configure routes, request validation, authentication, and other features. * **How to use:** Kong provides a plugin called `kong-plugin-openapi` that allows you to import your OpenAPI specification. You'll need to install and configure Kong first. Then, you can use the Kong Admin API or Kong Manager UI to import the OpenAPI file. * **Considerations:** You'll need to understand Kong's configuration model and how it maps to OpenAPI concepts. You might need to customize the Kong configuration to handle specific MCP requirements. * **Tyk:** Another open-source API gateway with OpenAPI support. Similar to Kong, you can import your OpenAPI definition to configure routes, security policies, and other features. * **AWS API Gateway:** Amazon's API Gateway allows you to import OpenAPI definitions to create and manage APIs. * **Azure API Management:** Microsoft's API Management service also supports importing OpenAPI specifications. **3. Testing Tools** * **Dredd:** A command-line tool that validates API implementations against OpenAPI specifications. It reads your OpenAPI definition and sends HTTP requests to your API endpoints, verifying that the responses match the specification. * **How to use:** ```bash dredd your_openapi.yaml http://your-mcp-server ``` Replace `your_openapi.yaml` with the path to your OpenAPI file and `http://your-mcp-server` with the base URL of your MCP server. * **Considerations:** Dredd requires a running MCP server to test against. You might need to write custom hooks to handle authentication or other specific requirements. * **Postman:** While not strictly a code generator, Postman can import OpenAPI specifications and generate collections of API requests. You can then use these collections to manually test your API or run automated tests. * **Swagger Inspector:** A tool that allows you to send requests to your API and automatically generate an OpenAPI definition based on the responses. This can be useful for creating an OpenAPI specification from an existing API. **4. Documentation Generation** * **Swagger UI:** A popular tool for rendering OpenAPI specifications as interactive documentation. You can host Swagger UI and point it to your OpenAPI file to create a user-friendly interface for exploring your API. * **Redoc:** Another documentation generator that focuses on a clean and modern design. It's an alternative to Swagger UI. **5. Data Transformation/Mapping** * **Custom Code:** In many cases, you'll need to write custom code to transform data between the format defined in your OpenAPI specification and the format expected by your MCP server. This might involve mapping fields, converting data types, or handling different encoding schemes. * **Data Mapping Tools:** Some specialized data mapping tools can help automate the process of transforming data between different formats. However, these tools might require some configuration and customization to work with your specific OpenAPI definition and MCP server. **Example: Using OpenAPI Generator for Python Flask** Let's say you have an OpenAPI specification named `mcp_api.yaml` that describes your MCP API. You want to generate a Python Flask server stub. 1. **Install OpenAPI Generator:** ```bash brew install openapi-generator # (if you're on macOS with Homebrew) # Or download the JAR file from https://openapi-generator.tech/docs/installation/ ``` 2. **Generate the code:** ```bash openapi-generator generate -i mcp_api.yaml -g python-flask -o mcp_server ``` 3. **Customize the generated code:** The `mcp_server` directory will contain the generated Flask application. You'll need to: * Implement the business logic for each API endpoint in the generated `controllers` directory. * Configure the Flask application (e.g., database connections, logging). * Handle any MCP-specific protocols or data formats. **Important Considerations** * **Accuracy of OpenAPI Specification:** The quality of your generated tools depends entirely on the accuracy and completeness of your OpenAPI specification. Make sure your OpenAPI definition is up-to-date and accurately reflects your API. * **MCP-Specific Requirements:** Consider any MCP-specific protocols, data formats, or security requirements that are not covered by the standard OpenAPI specification. You might need to add custom extensions to your OpenAPI definition or write custom code to handle these requirements. * **Iteration:** Code generation is often an iterative process. You might need to regenerate the code multiple times as you refine your OpenAPI specification and implement your API. * **Security:** Pay close attention to security considerations when generating code or configuring API gateways. Make sure to implement appropriate authentication, authorization, and input validation mechanisms. * **Error Handling:** Implement robust error handling in your MCP server to gracefully handle invalid requests or unexpected errors. **In Summary** Converting OpenAPI specifications to MCP server-ready tools involves choosing the right tool for the job (code generation, API gateway configuration, testing, etc.), configuring the tool with your OpenAPI definition, and customizing the generated output to meet your specific requirements. The key is to start with a well-defined OpenAPI specification and carefully consider any MCP-specific requirements. Good luck! I hope this comprehensive explanation helps! If you can provide more details about your specific MCP server environment and what you want to achieve, I can give you more tailored advice.

glif-mcp

Espejo de

Financial Analysis MCP Server

Espejo de

Ghost MCP Server

Mirror of

Weather MCP Server

Okay, here's a sample MCP (MicroConfig Protocol) server implementation concept for fetching weather forecasts, along with explanations to help you understand the key parts. I'll provide a Python example, as it's commonly used for this kind of task due to its readability and available libraries. **Conceptual Overview** 1. **MCP Server:** This is the core component. It listens for incoming MCP requests, parses them, and responds with the requested data. 2. **Weather Data Source:** This is where you get the actual weather information. This could be: * A public weather API (e.g., OpenWeatherMap, AccuWeather, WeatherAPI.com). This is the most common and practical approach. * A local weather station (if you have one). * A database of weather data. 3. **MCP Request Handling:** The server needs to understand the format of the incoming MCP requests. Typically, this involves: * **Parsing:** Extracting the relevant parameters from the request (e.g., location, units). * **Validation:** Ensuring the parameters are valid (e.g., location is a valid city, units are supported). * **Data Fetching:** Using the parameters to query the weather data source. * **Response Formatting:** Structuring the weather data into a valid MCP response. **Python Example (using `Flask` for the MCP server and `requests` for the API call)** ```python from flask import Flask, request, jsonify import requests import os # For accessing environment variables app = Flask(__name__) # Replace with your actual API key from OpenWeatherMap or another provider WEATHER_API_KEY = os.environ.get("WEATHER_API_KEY") # Get API key from environment variable if not WEATHER_API_KEY: print("Error: WEATHER_API_KEY environment variable not set.") exit() WEATHER_API_URL = "https://api.openweathermap.org/data/2.5/weather" # Example: OpenWeatherMap def get_weather_data(city, units="metric"): """Fetches weather data from the OpenWeatherMap API.""" params = { "q": city, "appid": WEATHER_API_KEY, "units": units, } try: response = requests.get(WEATHER_API_URL, params=params) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None def format_weather_response(data): """Formats the weather data into a simplified MCP-like response.""" if not data: return None try: temperature = data["main"]["temp"] description = data["weather"][0]["description"] humidity = data["main"]["humidity"] wind_speed = data["wind"]["speed"] response = { "status": "ok", "temperature": temperature, "description": description, "humidity": humidity, "wind_speed": wind_speed, } return response except KeyError as e: print(f"Error formatting weather data: Missing key {e}") return None @app.route("/weather", methods=["GET"]) def weather_endpoint(): """Handles the /weather endpoint for MCP requests.""" city = request.args.get("city") units = request.args.get("units", "metric") # Default to metric if not city: return jsonify({"status": "error", "message": "City parameter is required"}), 400 weather_data = get_weather_data(city, units) if not weather_data: return jsonify({"status": "error", "message": "Failed to fetch weather data"}), 500 formatted_response = format_weather_response(weather_data) if not formatted_response: return jsonify({"status": "error", "message": "Failed to format weather data"}), 500 return jsonify(formatted_response) if __name__ == "__main__": app.run(debug=True, host="0.0.0.0", port=5000) ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to handle potential errors during API requests and data formatting. This is *crucial* for a robust server. Specifically, it catches `requests.exceptions.RequestException` which covers network errors, timeouts, and HTTP errors. It also catches `KeyError` in the `format_weather_response` function, which can occur if the API response format changes. * **API Key from Environment Variable:** The `WEATHER_API_KEY` is now read from an environment variable. **Never hardcode API keys directly into your code!** This is a security risk. Environment variables are a much safer way to manage sensitive information. The code also checks if the environment variable is set and exits if it's not. * **`response.raise_for_status()`:** This line is very important. It checks the HTTP status code of the API response. If the status code indicates an error (e.g., 404 Not Found, 500 Internal Server Error), it will raise an `HTTPError` exception, which will be caught by the `except` block. This allows you to handle API errors gracefully. * **Clearer Error Messages:** The error messages in the `jsonify` responses are more informative, making it easier to debug problems. * **`units` Parameter:** The `weather_endpoint` function now accepts an optional `units` parameter, allowing the client to specify whether they want the temperature in Celsius or Fahrenheit (or other units supported by the API). It defaults to "metric" (Celsius). * **`format_weather_response` Function:** This function encapsulates the logic for formatting the raw weather data from the API into a simplified dictionary that is returned as the JSON response. This makes the code more modular and easier to maintain. * **`host="0.0.0.0"`:** This makes the server accessible from other machines on the network. If you only want to access it from your local machine, you can use `host="127.0.0.1"`. * **Comments:** Added more comments to explain the code. * **JSON Responses:** Uses `jsonify` to return JSON responses, which is the standard for web APIs. * **Status Codes:** Returns appropriate HTTP status codes (e.g., 400 for bad request, 500 for internal server error) to provide more information to the client. **How to Run:** 1. **Install Dependencies:** ```bash pip install Flask requests ``` 2. **Set Environment Variable:** ```bash export WEATHER_API_KEY="YOUR_OPENWEATHERMAP_API_KEY" # Replace with your actual key ``` (Or set it in your system's environment variables.) 3. **Run the Script:** ```bash python your_script_name.py ``` 4. **Test the Endpoint:** Open your web browser or use `curl` to access the endpoint: ``` http://localhost:5000/weather?city=London http://localhost:5000/weather?city=New York&units=imperial ``` **Important Considerations for a Real MCP Implementation:** * **MCP Specification:** This example is a *simplified* MCP server. A true MCP implementation would need to strictly adhere to the MCP specification, including the required headers, data formats, and error handling. You'd likely need to use a dedicated MCP library or implement the protocol parsing and serialization yourself. * **Security:** Implement proper authentication and authorization to protect your server from unauthorized access. Consider using HTTPS to encrypt communication. * **Scalability:** For high-traffic applications, consider using a more scalable web server (e.g., Gunicorn, uWSGI) and a load balancer. You might also want to cache weather data to reduce the load on the weather API. * **Rate Limiting:** Be aware of the rate limits imposed by the weather API you are using. Implement rate limiting in your server to avoid being blocked. * **Data Validation:** Thoroughly validate all input parameters to prevent injection attacks and other security vulnerabilities. * **Configuration:** Use a configuration file or environment variables to manage settings such as the API key, API URL, and port number. * **Logging:** Implement logging to track requests, errors, and other important events. This will help you debug problems and monitor the performance of your server. * **Testing:** Write unit tests and integration tests to ensure that your server is working correctly. **Spanish Translation of Key Concepts** * **MCP Server:** Servidor MCP * **Weather Data Source:** Fuente de datos meteorológicos * **API Key:** Clave de API * **Environment Variable:** Variable de entorno * **Endpoint:** Punto final * **Request:** Solicitud * **Response:** Respuesta * **Error Handling:** Manejo de errores * **Rate Limiting:** Limitación de velocidad * **Authentication:** Autenticación * **Authorization:** Autorización * **Scalability:** Escalabilidad * **Load Balancer:** Balanceador de carga * **Caching:** Almacenamiento en caché * **Data Validation:** Validación de datos * **Logging:** Registro (de eventos) This comprehensive example and explanation should give you a solid foundation for building your own MCP weather forecast server. Remember to adapt it to your specific needs and the requirements of the MCP protocol you are using. Good luck!

🏆 LinkedIn DI MCP Server

Audiense Digital Intelligence LinkedIn MCP Server es un servidor basado en el Protocolo de Contexto de Modelo (MCP) que permite a Claude y a otros clientes compatibles con MCP interactuar con tu cuenta de DI LinkedIn de Audiense.

Simple MCP Server Example

A simple example of a Model Context Protocol Server implementation

Git

Tools to read, search, and manipulate Git repositories

ConnectWise Manage MCP Server

A Model Context Protocol (MCP) server for ConnectWise Manage API integration

Gmail MCP Server

Mirror of

Confluence MCP Server

Confluence MCP server providing API tools for Atlassian Confluence operations including page management, space handling, and content search with built-in rate limiting and error handling.

Perplexity MCP Server

An MCP server for the Perplexity for use with Claude Code and Claude Desktop, giving you enhanced search and reasoning capabilties.

PubMed MCP Server

🔍 Habilite a los asistentes de IA para buscar, acceder y analizar artículos de PubMed a través de una interfaz MCP sencilla.

LocalMind

LocalMind is an local LLM Chat App fully compatible with the Model Context Protocol. It uses Azure OpenAI as a LLM backend and you can connect it to all MCP Servers out there.

MCP Servers for Cursor AI - README

He recopilado mucha información sobre servidores MCP (Protocolo de Contexto del Modelo) con integración a Cursor AI y Claude Desktop. De esta manera, puedes agregar esta carpeta a tu IDE preferido para que tenga información de indexación contextual disponible y así comprender cómo crear servidores MCP correctamente.

MCP Server Readability Parser (Python / FastMCP)

Espejo de

AI Federation Network

Esta implementación sigue la especificación oficial de MCP, incluyendo el correcto encuadre de mensajes, la implementación de la capa de transporte y la gestión completa del ciclo de vida del protocolo. Proporciona una base para construir sistemas MCP federados que pueden escalar a través de múltiples servidores manteniendo los requisitos de seguridad y estandarización.

FirstCycling MCP Server

Este es un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona datos de ciclismo profesional de FirstCycling. Te permite recuperar información sobre ciclistas profesionales, resultados de carreras y más.

aoirint_mcping_server

Headless status monitor with HTTP JSON API for Minecraft Bedrock/Java server