Discover Awesome MCP Servers

mem0 MCP Server

Implementasi TypeScript dari server Protokol Konteks Model yang memungkinkan pembuatan, pengelolaan, dan pencarian semantik aliran memori dengan integrasi Mem0.

testmcpgithubdemo1

created from MCP server demo

Linear MCP Server

Mirror of

untapped-mcp

A Untapped MCP server to be used with claude.

Simple Memory Extension MCP Server

Sebuah server MCP yang memperluas jendela konteks agen AI dengan menyediakan alat untuk menyimpan, mengambil, dan mencari memori, memungkinkan agen untuk mempertahankan riwayat dan konteks di seluruh interaksi yang panjang.

Telegram MCP Server

MCP server to send notifications to Telegram

FreeCAD MCP

Repositori ini adalah MCP FreeCAD yang memungkinkan Anda mengendalikan FreeCAD dari Claude Desktop.

Apache Doris MCP Server

An MCP server for Apache Doris & VeloDB

Choose MCP Server Setup

Cermin dari

mock-assistant-mcp-server

Asisten server MCP untuk data tiruan

McpDocs

Provide documentation about your Elixir project's functions and functions of dependencies to an LLM through an SSE MCP server.

🐋 Docker MCP server

Mirror of

mcp-server-testWhat is MCP Server Test?How to use MCP Server Test?Key features of MCP Server Test?Use cases of MCP Server Test?FAQ from MCP Server Test?

Test MCP Server

Server

```python import socket import json import time import random # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) UPDATE_INTERVAL = 5 # Seconds between weather updates def generate_weather_data(): """Generates random weather data.""" temperature = round(random.uniform(15, 35), 1) # Temperature in Celsius humidity = random.randint(40, 90) # Humidity percentage wind_speed = random.randint(0, 20) # Wind speed in km/h conditions = random.choice(['Sunny', 'Cloudy', 'Rainy', 'Windy']) weather_data = { 'temperature': temperature, 'humidity': humidity, 'wind_speed': wind_speed, 'conditions': conditions, 'timestamp': time.time() # Add a timestamp } return weather_data def main(): """Main function to run the weather server.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Weather server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: weather_data = generate_weather_data() weather_json = json.dumps(weather_data) try: conn.sendall(weather_json.encode('utf-8')) print(f"Sent weather data: {weather_data}") except BrokenPipeError: print("Client disconnected.") break # Exit the loop if the client disconnects except Exception as e: print(f"Error sending data: {e}") break time.sleep(UPDATE_INTERVAL) if __name__ == "__main__": main() ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions (`generate_weather_data`, `main`) for better readability and maintainability. * **Error Handling:** Includes `try...except` blocks to handle potential errors during sending data, specifically `BrokenPipeError` (when the client disconnects unexpectedly) and a general `Exception` to catch other issues. This prevents the server from crashing. The server now gracefully handles client disconnections. * **Configuration:** Uses constants (`HOST`, `PORT`, `UPDATE_INTERVAL`) for easy configuration. This makes it simple to change the server's address, port, and update frequency. * **JSON Encoding:** Uses `json.dumps()` to properly encode the weather data into a JSON string before sending it over the socket. This is crucial for ensuring that the client can correctly parse the data. The `.encode('utf-8')` part is also important to ensure the data is sent as bytes. * **Timestamp:** Adds a `timestamp` field to the weather data, which can be useful for the client to know when the data was generated. * **Realistic Weather Data:** The `generate_weather_data` function now generates more realistic weather data, including temperature, humidity, wind speed, and conditions. The temperature is rounded to one decimal place. * **Comments:** Includes more comments to explain the code. * **`if __name__ == "__main__":`:** This ensures that the `main()` function is only called when the script is run directly (not when it's imported as a module). * **`with socket.socket(...) as s:` and `with conn:`:** Using `with` statements ensures that the socket and connection are properly closed, even if errors occur. This is important for resource management. * **`s.listen()`:** The `s.listen()` call is essential to put the socket into listening mode, allowing it to accept incoming connections. * **`s.accept()`:** The `s.accept()` call blocks until a client connects. It returns a new socket object (`conn`) representing the connection and the client's address (`addr`). * **`conn.sendall()`:** `sendall()` attempts to send the entire message. It's generally preferred over `send()` because it handles the case where the entire message cannot be sent in one go. * **Clearer Output:** The `print` statements now provide more informative output, including the weather data being sent and connection/disconnection messages. How to run: 1. **Save:** Save the code as a Python file (e.g., `weather_server.py`). 2. **Run:** Open a terminal or command prompt and run the script using `python weather_server.py`. 3. **Client:** You'll need a client program to connect to this server and receive the weather data. A simple client example (in Python) is provided below. Example Client (weather_client.py): ```python import socket import json HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) while True: try: data = s.recv(1024) if not data: break # Server disconnected weather_data = json.loads(data.decode('utf-8')) print(f"Received weather data: {weather_data}") except ConnectionRefusedError: print("Connection refused. Is the server running?") break except json.JSONDecodeError: print("Received invalid JSON data.") break except Exception as e: print(f"Error receiving data: {e}") break ``` To run the client: 1. **Save:** Save the client code as `weather_client.py`. 2. **Run:** Open a *separate* terminal or command prompt and run the client using `python weather_client.py`. Make sure the server is running *first*. This improved version provides a robust and well-structured weather server that handles errors gracefully and sends data in a format that is easy for clients to parse. Remember to run the server *before* running the client.

MCP Server для Prom.ua

MCP server untuk bekerja dengan API Prom.ua

ChatGPT MCP Server

Mirror of

create-mcp-server

A comprehensive architecture for building robust Model Context Protocol (MCP) servers with integrated web capabilities

Kubectl MCP Tool

Sebuah server Protokol Konteks Model yang memungkinkan asisten AI untuk berinteraksi dengan klaster Kubernetes melalui bahasa alami, mendukung operasi inti Kubernetes, pemantauan, keamanan, dan diagnostik.

comment-stripper-mcp

A flexible MCP server that batch processes code files to remove comments across multiple programming languages. Currently supports JavaScript, TypeScript, and Vue files with regex-based pattern matching. Handles individual files, directories (including subdirectories), and text input. Built for clean code maintenance and preparation.

mcp-server-fetch-typescript MCP Server

Mirror of

MCP System Monitor

A system monitoring tool that exposes system metrics via the Model Context Protocol (MCP). This tool allows LLMs to retrieve real-time system information through an MCP-compatible interface.

mpc-csharp-semantickernel

Okay, here's an example of how you might use Microsoft Semantic Kernel with OpenAI and an MCP (Management Control Plane) Server. This example is conceptual and assumes you have an MCP server set up to manage your OpenAI API keys and rate limits. It focuses on the core ideas and provides a starting point. **Conceptual Scenario:** Imagine you're building a chatbot that helps users write marketing copy. You want to use OpenAI's GPT models for generating the copy, but you also want to: * **Manage OpenAI API Keys Centrally:** You don't want to hardcode API keys in your application. The MCP server will handle key rotation and access control. * **Enforce Rate Limits:** You want to prevent abuse and stay within your OpenAI usage limits. The MCP server will track and enforce these limits. * **Monitor Usage:** You want to track how much your application is using OpenAI to optimize costs and performance. The MCP server will provide metrics. **Code Example (C#):** ```csharp using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Connectors.OpenAI; using System.Net.Http; using System.Text.Json; using System.Threading.Tasks; public class MarketingCopyBot { private readonly IKernel _kernel; private readonly HttpClient _httpClient; private readonly string _mcpServerUrl; public MarketingCopyBot(string mcpServerUrl) { _mcpServerUrl = mcpServerUrl; _httpClient = new HttpClient(); _kernel = new KernelBuilder().Build(); } private async Task<string> GetOpenAIKeyFromMCP() { // Replace with your MCP server endpoint for retrieving OpenAI keys. string endpoint = $"{_mcpServerUrl}/api/openai/key"; try { HttpResponseMessage response = await _httpClient.GetAsync(endpoint); response.EnsureSuccessStatusCode(); // Throw exception if not successful string jsonResponse = await response.Content.ReadAsStringAsync(); // Assuming the MCP server returns a JSON object like: // { "apiKey": "YOUR_OPENAI_API_KEY" } using (JsonDocument document = JsonDocument.Parse(jsonResponse)) { JsonElement root = document.RootElement; if (root.TryGetProperty("apiKey", out JsonElement apiKeyElement)) { return apiKeyElement.GetString(); } else { Console.WriteLine($"Error: 'apiKey' property not found in MCP response: {jsonResponse}"); return null; } } } catch (HttpRequestException ex) { Console.WriteLine($"Error communicating with MCP server: {ex.Message}"); return null; } catch (JsonException ex) { Console.WriteLine($"Error parsing JSON from MCP server: {ex.Message}"); return null; } } public async Task InitializeKernel() { string apiKey = await GetOpenAIKeyFromMCP(); if (string.IsNullOrEmpty(apiKey)) { Console.WriteLine("Failed to retrieve OpenAI API key from MCP. Exiting."); return; // Or throw an exception } // Configure OpenAI connector using the key retrieved from MCP _kernel.Config.AddOpenAICompletionService( "text-davinci-003", // Or your preferred model apiKey ); } public async Task<string> GenerateMarketingCopy(string productDescription, string targetAudience) { // Check if the kernel is initialized if (_kernel.Config.GetService<ICompletionService>("text-davinci-003") == null) { Console.WriteLine("Kernel not initialized. Call InitializeKernel() first."); return "Error: Kernel not initialized."; } // Define the prompt using Semantic Kernel's templating string promptTemplate = @" Write compelling marketing copy for a product described as: {{productDescription}}. The target audience is: {{targetAudience}}. "; // Create a semantic function var generateCopyFunction = _kernel.CreateSemanticFunction(promptTemplate); // Execute the function var arguments = new KernelArguments { ["productDescription"] = productDescription, ["targetAudience"] = targetAudience }; try { var result = await generateCopyFunction.InvokeAsync(arguments); return result.ToString(); } catch (Exception ex) { Console.WriteLine($"Error generating marketing copy: {ex.Message}"); return $"Error: {ex.Message}"; } } public static async Task Main(string[] args) { // Replace with the actual URL of your MCP server string mcpServerUrl = "http://your-mcp-server:8080"; var bot = new MarketingCopyBot(mcpServerUrl); await bot.InitializeKernel(); if (_kernel.Config.GetService<ICompletionService>("text-davinci-003") != null) { string productDescription = "A revolutionary new noise-canceling headphone."; string targetAudience = "Young professionals who work in open office environments."; string marketingCopy = await bot.GenerateMarketingCopy(productDescription, targetAudience); Console.WriteLine(marketingCopy); } else { Console.WriteLine("Bot initialization failed. Check MCP server connection and API key retrieval."); } } } ``` **Explanation:** 1. **MCP Server Interaction:** * The `GetOpenAIKeyFromMCP()` method is responsible for communicating with your MCP server. It makes an HTTP request to a specific endpoint (e.g., `/api/openai/key`). * It parses the JSON response from the MCP server to extract the OpenAI API key. **Important:** The format of the JSON response will depend on how your MCP server is designed. * Error handling is included to catch potential issues with network connectivity or JSON parsing. 2. **Kernel Initialization:** * The `InitializeKernel()` method retrieves the API key from the MCP server. * It then uses the `_kernel.Config.AddOpenAICompletionService()` method to configure the Semantic Kernel to use OpenAI, providing the retrieved API key. This is where the connection to OpenAI is established. 3. **Semantic Function:** * The `GenerateMarketingCopy()` method defines a semantic function using Semantic Kernel's templating language. The template includes placeholders for the product description and target audience. * It creates a `KernelArguments` object to pass the actual values for these placeholders. * It executes the semantic function using `generateCopyFunction.InvokeAsync()`. 4. **Error Handling:** * The code includes `try-catch` blocks to handle potential exceptions during API key retrieval and semantic function execution. 5. **Main Method:** * The `Main` method creates an instance of the `MarketingCopyBot`, initializes the kernel, and then calls the `GenerateMarketingCopy()` method to generate marketing copy. * It prints the generated copy to the console. **Key Considerations and Indonesian Translation:** * **MCP Server Implementation:** This example assumes you have an MCP server already set up. The specific implementation of the MCP server is beyond the scope of this example. You'll need to design and implement the MCP server to handle API key management, rate limiting, and usage monitoring. * **Terjemahan:** Contoh ini mengasumsikan Anda sudah memiliki server MCP yang disiapkan. Implementasi spesifik server MCP berada di luar cakupan contoh ini. Anda perlu merancang dan mengimplementasikan server MCP untuk menangani manajemen kunci API, pembatasan laju, dan pemantauan penggunaan. * **MCP Server Endpoint:** The `/api/openai/key` endpoint is just an example. You'll need to define the actual endpoint based on your MCP server's API. * **Terjemahan:** Endpoint `/api/openai/key` hanyalah contoh. Anda perlu menentukan endpoint sebenarnya berdasarkan API server MCP Anda. * **Authentication/Authorization:** The example doesn't include any authentication or authorization when communicating with the MCP server. In a real-world scenario, you'll need to add appropriate security measures to protect your API keys. This might involve using API keys, OAuth, or other authentication mechanisms. * **Terjemahan:** Contoh ini tidak menyertakan otentikasi atau otorisasi apa pun saat berkomunikasi dengan server MCP. Dalam skenario dunia nyata, Anda perlu menambahkan langkah-langkah keamanan yang sesuai untuk melindungi kunci API Anda. Ini mungkin melibatkan penggunaan kunci API, OAuth, atau mekanisme otentikasi lainnya. * **Rate Limiting:** The example doesn't explicitly implement rate limiting. You'll need to integrate with your MCP server's rate limiting features. This might involve checking the number of requests made within a certain time period and delaying requests if necessary. The MCP server should ideally return information about rate limits in its responses. * **Terjemahan:** Contoh ini tidak secara eksplisit mengimplementasikan pembatasan laju. Anda perlu berintegrasi dengan fitur pembatasan laju server MCP Anda. Ini mungkin melibatkan pemeriksaan jumlah permintaan yang dibuat dalam jangka waktu tertentu dan menunda permintaan jika perlu. Idealnya, server MCP harus mengembalikan informasi tentang batasan laju dalam responsnya. * **Error Handling:** The error handling in the example is basic. You should implement more robust error handling to gracefully handle different types of errors and provide informative messages to the user. * **Terjemahan:** Penanganan kesalahan dalam contoh ini bersifat dasar. Anda harus mengimplementasikan penanganan kesalahan yang lebih kuat untuk menangani berbagai jenis kesalahan dengan baik dan memberikan pesan yang informatif kepada pengguna. * **Dependency Injection:** Consider using dependency injection to make your code more testable and maintainable. * **Terjemahan:** Pertimbangkan untuk menggunakan injeksi dependensi untuk membuat kode Anda lebih mudah diuji dan dipelihara. * **Asynchronous Operations:** The example uses `async` and `await` for asynchronous operations, which is good practice for I/O-bound tasks like network requests. * **Terjemahan:** Contoh ini menggunakan `async` dan `await` untuk operasi asinkron, yang merupakan praktik yang baik untuk tugas-tugas terikat I/O seperti permintaan jaringan. **Indonesian Summary:** Contoh kode di atas menunjukkan cara menggunakan Microsoft Semantic Kernel dengan OpenAI dan server MCP. Server MCP digunakan untuk mengelola kunci API OpenAI, menerapkan batasan laju, dan memantau penggunaan. Kode mengambil kunci API dari server MCP, menginisialisasi Semantic Kernel dengan kunci tersebut, dan kemudian menggunakan Semantic Kernel untuk menghasilkan teks pemasaran menggunakan model OpenAI. Penting untuk dicatat bahwa contoh ini bersifat konseptual dan memerlukan implementasi server MCP yang sesuai. Selain itu, perlu ditambahkan langkah-langkah keamanan, penanganan kesalahan yang lebih kuat, dan integrasi dengan fitur pembatasan laju server MCP. This example provides a solid foundation for building applications that leverage OpenAI while maintaining control over API keys and usage. Remember to adapt the code to your specific MCP server implementation and security requirements. Good luck!

MCP Server Pool

MCP 服务合集