发现优秀的 MCP 服务器

mcp-server-for-local

大家好！我是功能丰富的 MCP 服务，旨在打破设备与服务的隔阂，为用户带来便捷体验。天气工具和气象平台联动，快速为用户推送全球实时天气，助力大家规划出行。控制浏览器工具模拟人工操作，自动搜索、浏览网页，大幅节省时间。摄像头工具调用本地摄像头拍照、录像，实现人脸识别，保障家庭安防。 为实现工具协同，我搭建了稳定框架，开发者可以基于现有服务进行拓展。 **Translation:** 大家好！我是一个功能丰富的 MCP 服务，旨在打破设备与服务之间的隔阂，为用户带来便捷的体验。天气工具与气象平台联动，可以快速为用户推送全球实时天气，帮助大家规划出行。控制浏览器工具可以模拟人工操作，自动搜索和浏览网页，从而大幅节省时间。摄像头工具可以调用本地摄像头进行拍照和录像，并实现人脸识别，保障家庭安防。为了实现工具的协同工作，我搭建了一个稳定的框架，开发者可以基于现有的服务进行拓展。

Spider MCP Server

Enables crawling and extracting clean content from documentation websites with optional LLM-powered analysis for intelligent summaries, code example extraction, and content classification.

BinDiff MCP Tool

Enables binary comparison capabilities by leveraging IDA Pro and BinDiff to analyze similarities and differences between files. Users can perform automated function analysis to identify changed functions and compare original binaries against patched versions.

Figma MCP Server

镜子 (jìng zi)

AiryLark MCP Translation Server

一个 ModelContextProtocol 服务器，提供高质量的翻译服务，采用三阶段翻译工作流程（分析、分段翻译、全文审查），支持多种语言，并与 Claude 和 OpenAI 兼容的模型集成。

MCP Bitpanda Server

Enables programmatic access to Bitpanda cryptocurrency exchange features including trades, wallets, and transactions via the Model Context Protocol.

MedixHub Model Context Protocol (MCP) Server

MedixHub - 具有一系列医疗和健康护理 API 和工具的模型上下文协议 (MCP) 服务器。

QoutaMCP

Enables inspection and analysis of project structures to detect languages, frameworks, entry points, and dependencies across multiple programming languages including Node.js, Python, PHP, Go, Java, and Rust.

Ambiance MCP Server

Provides intelligent code context and analysis through semantic compression, AST parsing, and multi-language support. Offers 60-80% token reduction while enabling AI assistants to understand codebases through local analysis, OpenAI-enhanced insights, and GitHub repository integration.

FFmpeg MCP Server

Enables secure video and audio processing using FFmpeg commands in an isolated sandbox environment. Supports file management, Google Cloud Storage integration, and URL-based file transfers for AI-powered multimedia operations.

MiniMax MCP

Enables interaction with MiniMax AI APIs for text-to-speech, voice cloning, video generation, image generation, and music creation through MCP clients like Claude Desktop and Cursor.

Android Debug Bridge MCP

Enables control of Android devices via ADB for automation and testing. Supports app management, screen capture, UI analysis, and input simulation through natural language commands.

Japanese Vocab Anki MCP Server

A Model Context Protocol server that enables language models to interact with Anki flashcard decks programmatically, with specialized features for Japanese language learning including vocabulary import, sample sentence generation, and spaced repetition review.

New Relic MCP Server

Run NRQL, NerdGraph, and REST v2 operations to query data, manage incidents, create synthetics, and annotate deployments — all from your MCP client.

MCP UI Glue Code Generator

Automates frontend integration by mapping messy API JSON responses to Vue or React Design System components, generating Zod schemas for type-safe data transformation with live UI previews in chat.

WHOOP MCP Server

Enables access to WHOOP fitness and health data through all WHOOP v2 API endpoints. Supports OAuth 2.0 authentication and provides comprehensive access to user profiles, physiological cycles, recovery metrics, sleep analysis, and workout data.

Server

Okay, here's a basic outline and code snippets for a simple "Weather MCP" (presumably meaning "Minecraft Protocol") server in Python. I'll break it down into sections and explain the key concepts. Keep in mind that this is a *very* simplified example and doesn't implement the full Minecraft protocol. It's designed to illustrate the core idea of a server that responds to Minecraft client requests with weather data. **Important Considerations:** * **Minecraft Protocol Complexity:** The actual Minecraft protocol is complex and constantly evolving. This example *does not* implement it fully. It's a simplified demonstration. For real Minecraft server development, you'd need a robust library like `mcstatus` or a more complete server implementation. * **MCP (Minecraft Coder Pack):** MCP is primarily for *modding* the Minecraft client and server, not for creating entirely new servers. I'm assuming you're using "MCP" loosely to mean "something that interacts with Minecraft." * **Weather Data Source:** This example uses a placeholder for weather data. You'll need to integrate a real weather API (e.g., OpenWeatherMap, AccuWeather) to get actual weather information. * **Security:** This is a basic example and doesn't include any security measures. Real Minecraft servers need proper security to prevent exploits. **Conceptual Outline:** 1. **Socket Setup:** Create a TCP socket to listen for incoming connections from Minecraft clients (or a proxy/mod that simulates a client). 2. **Client Connection Handling:** When a client connects, accept the connection and create a new thread or process to handle it. 3. **Simplified Protocol:** Define a very simple protocol for the client to request weather data. For example, the client might send a specific string like "WEATHER_REQUEST". 4. **Weather Data Retrieval:** When a request is received, fetch weather data from your chosen source (API or placeholder). 5. **Response Formatting:** Format the weather data into a string or a simple data structure that the client can understand. 6. **Sending the Response:** Send the formatted weather data back to the client through the socket. 7. **Closing the Connection:** Close the connection with the client. **Python Code (Illustrative Example):** ```python import socket import threading import time # For simulating weather updates import random # For simulating weather updates # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 25566 # Choose a port (not the default Minecraft port) WEATHER_REQUEST_COMMAND = "WEATHER_REQUEST" SIMULATE_WEATHER = True # Set to False if using a real API # Placeholder for weather data (replace with API integration) weather_data = { "temperature": 25, "condition": "Clear", "humidity": 60 } def update_weather(): """Simulates weather updates (replace with API calls).""" global weather_data while SIMULATE_WEATHER: weather_data["temperature"] = random.randint(15, 35) conditions = ["Clear", "Rain", "Cloudy", "Thunderstorm"] weather_data["condition"] = random.choice(conditions) weather_data["humidity"] = random.randint(40, 80) print(f"Weather updated: {weather_data}") time.sleep(60) # Update every 60 seconds def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break # Client disconnected message = data.decode('utf-8').strip() print(f"Received: {message}") if message == WEATHER_REQUEST_COMMAND: # Format the weather data into a string weather_string = f"Temperature: {weather_data['temperature']}°C, Condition: {weather_data['condition']}, Humidity: {weather_data['humidity']}%" conn.sendall(weather_string.encode('utf-8')) else: conn.sendall("Unknown command".encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def start_server(): """Starts the weather server.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Avoid address already in use error try: server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Weather server listening on {HOST}:{PORT}") # Start the weather update thread if SIMULATE_WEATHER: weather_thread = threading.Thread(target=update_weather) weather_thread.daemon = True # Exit when the main thread exits weather_thread.start() while True: conn, addr = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(conn, addr)) client_thread.start() except Exception as e: print(f"Server error: {e}") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **Explanation:** 1. **Imports:** Imports necessary modules: `socket` for network communication, `threading` for handling multiple clients concurrently, `time` for simulating weather updates, and `random` for generating random weather data. 2. **Configuration:** * `HOST`: The IP address to listen on (localhost in this case). * `PORT`: The port number to listen on. Choose a port that's not already in use. *Do not use the default Minecraft port (25565) unless you know what you're doing.* * `WEATHER_REQUEST_COMMAND`: The string that the client sends to request weather data. * `SIMULATE_WEATHER`: A flag to control whether to simulate weather updates or use a real API. 3. **`weather_data`:** A dictionary to store the current weather information. This is a placeholder; you'll replace this with data from a real weather API. 4. **`update_weather()`:** This function simulates weather updates. It randomly changes the temperature, condition, and humidity every 60 seconds. *Replace this with code that calls a weather API.* The `time.sleep(60)` call pauses the thread for 60 seconds. The `weather_thread.daemon = True` line ensures that the thread exits when the main program exits. 5. **`handle_client(conn, addr)`:** This function handles the communication with a single client. * It receives data from the client using `conn.recv(1024)`. * It decodes the data from bytes to a string using `data.decode('utf-8')`. * It checks if the received message is the `WEATHER_REQUEST_COMMAND`. * If it is, it formats the weather data into a string and sends it back to the client using `conn.sendall(weather_string.encode('utf-8'))`. The `encode('utf-8')` converts the string to bytes before sending. * If the message is not recognized, it sends an "Unknown command" message. * It closes the connection using `conn.close()`. 6. **`start_server()`:** This function sets up the server socket and listens for incoming connections. * It creates a TCP socket using `socket.socket(socket.AF_INET, socket.SOCK_STREAM)`. * It binds the socket to the specified host and port using `server_socket.bind((HOST, PORT))`. * It starts listening for connections using `server_socket.listen()`. * It enters a loop that accepts incoming connections using `server_socket.accept()`. * For each connection, it creates a new thread to handle the client using `threading.Thread(target=handle_client, args=(conn, addr))`. * It starts the thread using `client_thread.start()`. * The `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` line is important. It allows you to quickly restart the server after it crashes or is stopped without getting an "Address already in use" error. 7. **`if __name__ == "__main__":`:** This ensures that the `start_server()` function is only called when the script is run directly (not when it's imported as a module). **How to Run:** 1. Save the code as a Python file (e.g., `weather_server.py`). 2. Run the script from your terminal: `python weather_server.py` **Client-Side (Simplified Example - Requires Modification for Minecraft):** This is a *very* basic Python client to test the server. **This will NOT work directly with Minecraft.** You'll need to adapt it to send the request from within a Minecraft mod or through a proxy. ```python import socket HOST = '127.0.0.1' PORT = 25566 WEATHER_REQUEST_COMMAND = "WEATHER_REQUEST" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(WEATHER_REQUEST_COMMAND.encode('utf-8')) data = s.recv(1024) print('Received:', repr(data.decode('utf-8'))) ``` **Important Notes and Next Steps:** * **Minecraft Integration:** The biggest challenge is integrating this with Minecraft. You'll need to: * **Create a Minecraft Mod:** This is the most common approach. Your mod would need to: * Establish a connection to your Python server. * Send the `WEATHER_REQUEST_COMMAND`. * Receive the weather data. * Display the weather data in the game (e.g., in the chat, on a custom GUI). * **Use a Proxy:** You could create a proxy server that sits between the Minecraft client and the real Minecraft server. The proxy would intercept weather-related packets and replace them with data from your Python server. This is more complex. * **Weather API Integration:** Replace the placeholder weather data with calls to a real weather API. You'll need to: * Sign up for an API key from a weather service (e.g., OpenWeatherMap). * Install the `requests` library: `pip install requests` * Modify the `update_weather()` function to make API calls. * **Error Handling:** Add more robust error handling to the server and client code. * **Data Formatting:** Consider using a more structured data format like JSON for sending weather data between the server and client. This will make it easier to parse the data on the client side. * **Security:** Implement security measures to protect your server from unauthorized access. **Example of Weather API Integration (OpenWeatherMap):** ```python import requests # Replace with your OpenWeatherMap API key API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" CITY = "London" # Or any city you want def get_weather_from_api(): """Gets weather data from OpenWeatherMap.""" url = f"http://api.openweathermap.org/data/2.5/weather?q={CITY}&appid={API_KEY}&units=metric" try: response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() weather_data = { "temperature": data["main"]["temp"], "condition": data["weather"][0]["description"], "humidity": data["main"]["humidity"] } return weather_data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None # In your update_weather() function: def update_weather(): global weather_data while SIMULATE_WEATHER: new_weather = get_weather_from_api() if new_weather: weather_data = new_weather print(f"Weather updated from API: {weather_data}") else: print("Failed to update weather from API.") time.sleep(60) ``` Remember to replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key. You'll also need to adjust the `CITY` variable to the city you want weather data for. This comprehensive explanation and code should give you a solid starting point for building your weather MCP server in Python. Good luck!

Figma MCP Server

A Python implementation of the Model Context Protocol server that enables AI assistants to interact with Figma through WebSocket connections, allowing them to read, analyze, and export design data.

awsome-kali-MCPServers

awsome kali MCPServers 是一套专为 Kali Linux 定制的 MCP 服务器，旨在增强 AI 代理在逆向工程和安全测试方面的能力。它提供灵活的网络分析、目标嗅探、流量分析、二进制理解和自动化功能，从而提升 AI 驱动的工作流程。

Portfolio Tracker MCP Server

Enables AI clients to track investment portfolios by retrieving positions, calculating profit and loss, and refreshing price data via Yahoo Finance. It allows users to monitor overall performance and query specific ticker details through natural language interactions.

Pythagraph RED MCP Server

Enables retrieval and analysis of graph data from the Pythagraph RED API. Provides detailed graph statistics, node/edge distributions, and formatted table outputs for data visualization and analysis.

MCP Dungeon Game

An idle dungeon crawler game playable through conversation, featuring equipment collection, time-based dungeon exploration, auto-battles, random events, and encrypted local save data.

Linear MCP Server

镜子 (jìng zi)

Amadeus MCP Server

一个模型上下文协议服务器，连接到 Amadeus API，使 AI 助手能够搜索航班、分析价格、查找最佳旅行优惠以及规划多城市旅行。

YNAB MCP Server

Enables interaction with You Need A Budget (YNAB) through their API, allowing users to manage budgets, accounts, categories, transactions, payees, and scheduled transactions through natural language.

mpc-csharp-semantickernel

Okay, here's an example demonstrating how to use Microsoft Semantic Kernel with OpenAI and a hypothetical "MCP Server" (assuming MCP stands for something like "My Custom Processing Server" or "Message Control Protocol Server"). Since "MCP Server" is vague, I'll make some assumptions about its functionality and how it might interact with Semantic Kernel. You'll need to adapt this to your specific MCP Server's capabilities. **Conceptual Overview** The core idea is to use Semantic Kernel to orchestrate interactions between OpenAI (for language understanding and generation) and your MCP Server (for specialized processing, data retrieval, or control actions). **Assumptions about the MCP Server** * **API Endpoint:** It exposes an API endpoint (e.g., REST API) for receiving requests and sending responses. * **Functionality:** Let's assume it can perform a specific task, like: * **Data Lookup:** Retrieve information from a database based on a query. * **System Control:** Execute a command on a system. * **Message Routing:** Route a message to a specific destination. * **Input/Output:** It expects structured input (e.g., JSON) and returns structured output (e.g., JSON). **Example Scenario: Smart Home Control** Let's imagine an MCP Server that controls smart home devices. We want to use Semantic Kernel and OpenAI to allow users to control their home with natural language. **Code Example (C#)** ```csharp using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Connectors.OpenAI; using System.Net.Http; using System.Text; using System.Text.Json; using System.Threading.Tasks; public class SmartHomePlugin { private readonly HttpClient _httpClient; private readonly string _mcpServerEndpoint; public SmartHomePlugin(string mcpServerEndpoint) { _httpClient = new HttpClient(); _mcpServerEndpoint = mcpServerEndpoint; } [KernelFunction, Description("Controls a smart home device.")] public async Task<string> ControlDevice( [Description("The device to control (e.g., lights, thermostat).")] string device, [Description("The action to perform (e.g., turn on, turn off, set temperature).")] string action, [Description("The value to set (e.g., 22 for temperature).")] string value = "" ) { // 1. Prepare the request to the MCP Server var requestData = new { device = device, action = action, value = value }; string jsonRequest = JsonSerializer.Serialize(requestData); var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json"); // 2. Send the request to the MCP Server HttpResponseMessage response = await _httpClient.PostAsync(_mcpServerEndpoint, content); // 3. Handle the response from the MCP Server if (response.IsSuccessStatusCode) { string jsonResponse = await response.Content.ReadAsStringAsync(); // Deserialize the JSON response (assuming MCP Server returns JSON) try { var responseObject = JsonSerializer.Deserialize<Dictionary<string, string>>(jsonResponse); return responseObject?["status"] ?? "Unknown status"; // Assuming MCP returns a "status" field } catch (JsonException ex) { Console.WriteLine($"Error deserializing MCP Server response: {ex.Message}"); return "Error processing MCP Server response."; } } else { Console.WriteLine($"MCP Server request failed: {response.StatusCode}"); return $"MCP Server request failed with status code: {response.StatusCode}"; } } } public class Example { public static async Task Main() { // 1. Configure Semantic Kernel string apiKey = "YOUR_OPENAI_API_KEY"; string orgId = "YOUR_OPENAI_ORG_ID"; // Optional Kernel kernel = Kernel.CreateBuilder() .AddOpenAIChatCompletion("gpt-3.5-turbo", apiKey, orgId) // Or "gpt-4" .Build(); // 2. Define the MCP Server endpoint string mcpServerEndpoint = "http://your-mcp-server.com/api/control"; // Replace with your actual endpoint // 3. Import the SmartHomePlugin var smartHomePlugin = new SmartHomePlugin(mcpServerEndpoint); kernel.ImportPluginFromObject(smartHomePlugin, "SmartHome"); // 4. Create a Semantic Function (Prompt) string prompt = @" Control the smart home device. Device: {{$device}} Action: {{$action}} Value: {{$value}} {{SmartHome.ControlDevice $device $action $value}} "; var smartHomeFunction = kernel.CreateFunction(prompt); // 5. Run the Semantic Function with user input var arguments = new KernelArguments { ["device"] = "lights", ["action"] = "turn on", ["value"] = "" }; var result = await smartHomeFunction.InvokeAsync(kernel, arguments); Console.WriteLine($"Result: {result.GetValue<string>()}"); // Example 2: More natural language input using OpenAI to extract parameters string naturalLanguagePrompt = "Turn on the living room lights."; // Define a prompt to extract device, action, and value from the natural language input string extractionPrompt = @" Extract the device, action, and value from the following text: Text: {{$text}} Device: Action: Value: "; var extractionFunction = kernel.CreateFunction(extractionPrompt); var extractionResult = await extractionFunction.InvokeAsync(kernel, new KernelArguments { ["text"] = naturalLanguagePrompt }); string extractedText = extractionResult.GetValue<string>()!; // Parse the extracted text (this is a simplified example; you might need more robust parsing) string extractedDevice = extractedText.Split("Device:")[1].Split("Action:")[0].Trim(); string extractedAction = extractedText.Split("Action:")[1].Split("Value:")[0].Trim(); string extractedValue = extractedText.Split("Value:")[1].Trim(); Console.WriteLine($"Extracted Device: {extractedDevice}"); Console.WriteLine($"Extracted Action: {extractedAction}"); Console.WriteLine($"Extracted Value: {extractedValue}"); // Now use the extracted parameters with the SmartHome.ControlDevice function var controlArguments = new KernelArguments { ["device"] = extractedDevice, ["action"] = extractedAction, ["value"] = extractedValue }; var controlResult = await smartHomeFunction.InvokeAsync(kernel, controlArguments); Console.WriteLine($"Control Result: {controlResult.GetValue<string>()}"); } } ``` **Explanation:** 1. **`SmartHomePlugin`:** * This class represents a Semantic Kernel plugin that interacts with the MCP Server. * It takes the MCP Server endpoint as a constructor parameter. * The `ControlDevice` function is decorated with `[KernelFunction]` to make it available to Semantic Kernel. * It constructs a JSON request based on the input parameters (`device`, `action`, `value`). * It sends a POST request to the MCP Server. * It handles the response from the MCP Server, deserializing the JSON and returning a status message. Error handling is included. 2. **`Example.Main`:** * **Configure Semantic Kernel:** Sets up the Semantic Kernel with your OpenAI API key and organization ID. * **Define MCP Server Endpoint:** Replace `"http://your-mcp-server.com/api/control"` with the actual URL of your MCP Server's API endpoint. * **Import Plugin:** Creates an instance of the `SmartHomePlugin` and imports it into the Semantic Kernel. This makes the `ControlDevice` function available for use in prompts. * **Create Semantic Function (Prompt):** Defines a prompt that uses the `SmartHome.ControlDevice` function. The prompt takes `device`, `action`, and `value` as input parameters. * **Run Semantic Function:** Creates a `KernelArguments` object with the desired device, action, and value, and then invokes the semantic function. The result from the MCP Server is printed to the console. * **Natural Language Example:** Demonstrates how to use OpenAI to extract the device, action, and value from a natural language prompt. This allows users to control their smart home with more natural commands. A separate prompt is used for extraction. The extracted parameters are then used to call the `SmartHome.ControlDevice` function. **Key Points and Considerations:** * **MCP Server API:** The most important part is understanding the API of your MCP Server. You need to know the endpoint, the expected request format (JSON schema), and the format of the response. * **Error Handling:** The example includes basic error handling for network requests and JSON deserialization. You should add more robust error handling for production code. * **Security:** If your MCP Server requires authentication, you'll need to add authentication headers to the `HttpClient` requests. Never hardcode sensitive information like API keys directly in your code. Use environment variables or a secure configuration mechanism. * **Prompt Engineering:** The prompts are crucial for getting the desired behavior. Experiment with different prompts to improve the accuracy and reliability of the system. Consider using techniques like few-shot learning to provide examples to the language model. * **JSON Serialization/Deserialization:** The example uses `System.Text.Json`. You can use other JSON libraries like Newtonsoft.Json if you prefer. * **Dependency Injection:** For larger applications, consider using dependency injection to manage the `HttpClient` and other dependencies. * **Asynchronous Operations:** The example uses `async` and `await` for asynchronous operations. This is important for avoiding blocking the main thread and improving performance. * **Parameter Extraction:** The natural language example uses a simple string splitting approach to extract parameters. For more complex scenarios, you might need to use more sophisticated techniques like regular expressions or a dedicated natural language processing library. Semantic Kernel also offers more advanced techniques for parameter extraction. * **Semantic Kernel Plugins:** Consider breaking down your MCP Server functionality into multiple Semantic Kernel plugins for better organization and reusability. * **Testing:** Write unit tests to verify the functionality of your Semantic Kernel plugins and the interactions with the MCP Server. **How to Adapt This Example:** 1. **Replace Placeholders:** Replace `"YOUR_OPENAI_API_KEY"`, `"YOUR_OPENAI_ORG_ID"`, and `"http://your-mcp-server.com/api/control"` with your actual values. 2. **Implement MCP Server Interaction:** Modify the `SmartHomePlugin` to match the API of your MCP Server. Adjust the request format, response handling, and error handling accordingly. 3. **Customize Prompts:** Adjust the prompts to match the specific tasks you want to perform. 4. **Add Error Handling:** Implement more robust error handling to handle potential issues with the MCP Server or the OpenAI API. 5. **Add Security:** Implement appropriate security measures to protect your API keys and other sensitive information. **Chinese Translation of Key Concepts:** * **Microsoft Semantic Kernel:** 微软语义内核 (Wēiruǎn yǔyì kènèi) * **OpenAI:** 开放人工智能 (Kāifàng réngōng zhìnéng) * **MCP Server:** (You'll need to translate this based on what MCP stands for in your context. For example, if it's "My Custom Processing Server," you could translate it as: 我的自定义处理服务器 (Wǒ de zì dìngyì chǔlǐ fúwùqì)) * **Plugin:** 插件 (Chājiàn) * **Kernel Function:** 内核函数 (Nèihé hánshù) * **Prompt:** 提示 (Tíshì) * **Semantic Function:** 语义函数 (Yǔyì hánshù) * **API Endpoint:** 应用程序接口端点 (Yìngyòng chéngxù jiēkǒu duāndiǎn) * **Natural Language:** 自然语言 (Zìrán yǔyán) This comprehensive example should give you a solid foundation for using Microsoft Semantic Kernel with OpenAI and your MCP Server. Remember to adapt the code to your specific needs and to thoroughly test your implementation. Good luck!

LangChain MCP

A Multi-Server Control Plane system that enables natural language querying of job listings and employee feedback data through two specialized servers built with LangChain.

GitLab MCP Server

Connects AI assistants to GitLab, enabling natural language queries to view merge requests, review discussions, test reports, pipeline status, and respond to comments directly from chat.