Discover Awesome MCP Servers

code-rules-mcp

에이전트 AI 컨텍스트에 코드 규칙을 안정적으로 읽어들이기 위한 MCP 서버

MCP Server for YouTube Transcript API

유튜브 통합을 위한 MCP 서버 구현

Curl MCP Server

A Model Context Protocol server that provides secure curl command execution capabilities, allowing AI assistants to make HTTP requests with configurable parameters and built-in security protections.

MCP RSS

Enables intelligent RSS feed management with AI-powered semantic search, advanced filtering, and a comprehensive reading workflow. Supports OPML parsing, article organization with status tracking, and token-efficient browsing of large feed collections.

GitHub MCP Server

Github MCP 서버를 CI 흐름과 통합

Excel MCP Server

Enables AI agents to create, read, and modify Excel workbooks without requiring Microsoft Excel, supporting operations like formulas, charts, pivot tables, formatting, and data validation.

WeatherAPI MCP Server

WeatherAPI를 사용하여 모든 도시의 현재 날씨 및 대기 질 데이터를 제공하며, n8n 및 Claude Desktop App과 같은 MCP 클라이언트와 쉽게 통합됩니다.

MCP to LangChain/LangGraph Adapter

Addapter that turns MCP server tools into langchain usable tools

Selenium MCP Server

Enables AI assistants to automate web browser interactions through Selenium WebDriver. Supports multi-browser automation, element interaction, navigation, and web testing capabilities.

Openai Mcp Server

OpenAI 프로토콜용 MCP 서버

MCPE-ServerInfo

마인크래프트 베드락 서버 주소를 입력받아 연결되지 않은 정보를 표시하는 프로그램입니다.

PostgreSQL MCP Server

Enables interaction with PostgreSQL databases through both HTTP and stdio transports. Supports executing read-only SQL queries, listing tables, and retrieving schema information with stateful session management.

Whoop MCP Server

거울

rekordbox-mcp

MCP server for rekordbox DJ database access. Provides read-only querying of tracks, playlists, and DJ session history from encrypted rekordbox SQLite databases using pyrekordbox.

RateSpot MCP Server

Provides access to RateSpot.io mortgage rate APIs, enabling AI assistants to fetch real-time mortgage rates, compare loan products, calculate payments, and access comprehensive lending information.

mcp-book-search

국내 도서 검색용 MCP 서버

Python Server MCP

CoinMarketCap API 연동을 통해 MCP (모델 컨텍스트 프로토콜) 프레임워크로 실시간 암호화폐 가격 정보를 제공하는 암호화폐 가격 서비스.

TOPdesk MCP Server

Enables interaction with TOPdesk service management platform through comprehensive API integration. Supports incident management, operator/person operations, document conversion, and FIQL querying for streamlined IT service desk workflows.

Component Library MCP Server

Provides AI assistants with access to private React component library documentation, props, and code examples through type-safe TypeScript integration.

InstantDB MCP Server

A read-only interface for querying InstantDB that dynamically loads schemas and enables executing queries through pre-defined patterns.

Apifox MCP

Enables AI assistants to automatically manage Apifox API documentation by importing OpenAPI/Swagger specifications and exporting existing API structures. Supports batch operations, intelligent deprecation marking, and smart scope detection for partial module imports.

MCP Hello World Example

MCP 서버 및 클라이언트 프로젝트를 만들기 위한 템플릿 프로젝트

TaskMateAI

MCP를 통해 작동하는 AI 기반 작업 관리 애플리케이션으로, 하위 작업, 우선 순위, 진행 상황 추적을 지원하여 자율적인 작업 생성, 구성 및 실행이 가능합니다.

Financial Data MCP Server

A Model Context Protocol server that provides financial tools for retrieving real-time stock data, analyst recommendations, financial statements, and web search capabilities for a LangGraph-powered ReAct agent.

Naver Search MCP Server

Provides access to Naver Search APIs, allowing AI agents to search across multiple categories (blogs, news, books, images, shopping items, etc.) with structured responses optimized for LLM consumption.

OpenFeature MCP Server

Provides OpenFeature SDK installation guidance through MCP tool calls. Enables AI clients to fetch installation prompts and setup instructions for various OpenFeature SDKs across different programming languages and frameworks.

RobotFrameworkLibrary-to-MCP

Turning a Robot Framework library into an MCP (Master Control Program) server involves several steps and considerations. Here's a breakdown of the process, along with explanations and code examples: **Understanding the Concepts** * **Robot Framework:** A generic open-source automation framework. You write tests in a human-readable format (using keywords). * **Robot Framework Library:** A collection of keywords (functions) that Robot Framework can use. These are typically written in Python. * **MCP (Master Control Program) Server:** In this context, we're assuming you want to create a server that can receive commands (likely from Robot Framework) and execute actions based on those commands. This server could control hardware, software, or any other system. * **Communication:** The key is how Robot Framework will communicate with your MCP server. Common methods include: * **TCP/IP Sockets:** Direct socket communication. Flexible but requires more coding. * **HTTP/REST API:** The MCP server exposes an HTTP endpoint. Robot Framework uses the `RequestsLibrary` to send HTTP requests. Widely used and well-understood. * **Message Queues (e.g., RabbitMQ, ZeroMQ):** Asynchronous communication. Good for decoupling and scalability. * **gRPC:** A modern, high-performance RPC framework. **General Steps** 1. **Choose a Communication Method:** Select the best communication method based on your needs. HTTP/REST is often a good starting point due to its simplicity and widespread support. 2. **Create the MCP Server (Python):** Write a Python application that acts as the MCP server. This server will: * Listen for incoming requests (e.g., HTTP requests). * Parse the requests to determine the desired action. * Execute the corresponding action (which might involve calling functions from your Robot Framework library). * Send a response back to the client (Robot Framework). 3. **Modify Your Robot Framework Library (if needed):** If your library functions need to be called directly by the MCP server, ensure they are properly structured and accessible. You might need to refactor your library to make it more modular. 4. **Create Robot Framework Keywords:** Write Robot Framework keywords that send commands to the MCP server using the chosen communication method. These keywords will act as the interface between your Robot Framework tests and the MCP server. **Example: Using HTTP/REST API** This is a common and relatively straightforward approach. **1. MCP Server (Python - using Flask):** ```python from flask import Flask, request, jsonify import your_robot_library # Replace with your library app = Flask(__name__) @app.route('/execute_keyword', methods=['POST']) def execute_keyword(): """ Receives a keyword name and arguments, executes the keyword, and returns the result. """ data = request.get_json() keyword_name = data.get('keyword') arguments = data.get('arguments', []) # Default to empty list if no arguments try: # Dynamically call the keyword from your library keyword_function = getattr(your_robot_library, keyword_name) result = keyword_function(*arguments) # Execute the keyword with arguments return jsonify({'status': 'success', 'result': result}) except AttributeError: return jsonify({'status': 'error', 'message': f'Keyword "{keyword_name}" not found'}) except Exception as e: return jsonify({'status': 'error', 'message': str(e)}) if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Listen on all interfaces ``` * **Explanation:** * **Flask:** A lightweight Python web framework. * **`/execute_keyword` route:** This is the endpoint that Robot Framework will call. * **`request.get_json()`:** Parses the JSON data sent in the HTTP request. * **`keyword_name` and `arguments`:** Extracts the keyword name and arguments from the JSON data. * **`getattr(your_robot_library, keyword_name)`:** Dynamically retrieves the function (keyword) from your Robot Framework library. **Important:** This assumes your library is structured so that keywords are directly accessible as attributes of the library module. * **`keyword_function(*arguments)`:** Executes the keyword with the provided arguments. * **Error Handling:** Includes `try...except` blocks to handle potential errors (e.g., keyword not found, exceptions during execution). * **`jsonify()`:** Converts the response data to JSON format. * **`app.run()`:** Starts the Flask development server. Use a production-ready server (e.g., Gunicorn, uWSGI) for real deployments. **2. Robot Framework Library (Example):** ```python # your_robot_library.py def add_numbers(a, b): """Adds two numbers and returns the result.""" return a + b def greet(name): """Greets the given name.""" return f"Hello, {name}!" ``` **3. Robot Framework Test Suite:** ```robotframework ***Settings*** Library RequestsLibrary ***Variables*** ${MCP_SERVER_URL} http://localhost:5000 ***Test Cases*** Execute Add Numbers ${data}= Create Dictionary keyword=add_numbers arguments=${[1, 2]} ${response}= Post Request alias=MCP Server url=${MCP_SERVER_URL}/execute_keyword data=${data} headers=${{'Content-Type': 'application/json'}} Should Be Equal As Strings ${response.status_code} 200 ${result}= Evaluate ${response.json()['result']} Should Be Equal As Numbers ${result} 3 Execute Greet ${data}= Create Dictionary keyword=greet arguments=${['World']} ${response}= Post Request alias=MCP Server url=${MCP_SERVER_URL}/execute_keyword data=${data} headers=${{'Content-Type': 'application/json'}} Should Be Equal As Strings ${response.status_code} 200 ${result}= Evaluate ${response.json()['result']} Should Be Equal As Strings ${result} Hello, World! ``` * **Explanation:** * **`RequestsLibrary`:** Used to make HTTP requests. Install it: `pip install robotframework-requests` * **`MCP_SERVER_URL`:** The URL of your MCP server. * **`Create Dictionary`:** Creates a dictionary containing the `keyword` and `arguments` to send to the server. * **`Post Request`:** Sends an HTTP POST request to the MCP server. * **`Should Be Equal As Strings` / `Should Be Equal As Numbers`:** Robot Framework keywords to verify the response. * **`Evaluate`:** Used to access the `result` from the JSON response. **To Run This Example:** 1. **Install Dependencies:** ```bash pip install flask robotframework robotframework-requests ``` 2. **Save the files:** Save the Python code as `mcp_server.py` and `your_robot_library.py`. Save the Robot Framework code as `test.robot`. 3. **Start the MCP Server:** ```bash python mcp_server.py ``` 4. **Run the Robot Framework Test:** ```bash robot test.robot ``` **Important Considerations and Improvements:** * **Security:** This example is very basic and has no security. For production, you *must* implement proper authentication and authorization. Consider using API keys, OAuth 2.0, or other security mechanisms. * **Error Handling:** Improve error handling in both the server and the Robot Framework tests. Provide more informative error messages. * **Data Validation:** Validate the input data on the server side to prevent unexpected behavior or security vulnerabilities. * **Asynchronous Execution:** If your keywords take a long time to execute, consider using asynchronous tasks (e.g., using Celery or asyncio) to prevent the server from blocking. * **Configuration:** Use configuration files (e.g., YAML, JSON) to store settings like the server port, database connection details, etc. * **Logging:** Implement proper logging in the server to track requests, errors, and other important events. * **Scalability:** For high-traffic scenarios, consider using a more robust web server (e.g., Gunicorn, uWSGI) and load balancing. * **gRPC:** For high-performance communication, explore gRPC. It's more complex to set up than HTTP/REST, but it can offer significant performance benefits. * **Message Queues:** If you need asynchronous communication or decoupling, consider using a message queue like RabbitMQ or ZeroMQ. **In summary, turning a Robot Framework library into an MCP server involves creating a server application that can receive commands, execute functions from your library, and return results. HTTP/REST is a good starting point, but consider other communication methods based on your specific requirements.** Remember to prioritize security, error handling, and scalability as you develop your MCP server.