Discover Awesome MCP Servers

TimezoneToolkit MCP Server

Servidor MCP avanzado que proporciona herramientas integrales de tiempo y zona horaria.

mcp-server-bluesky

Mirror of

MCP Command History

Una herramienta poderosa para explorar, buscar y gestionar tu historial de comandos de shell a través de la interfaz MCP (Protocolo de Control de Modelos). Este proyecto te permite acceder, buscar y recuperar fácilmente los comandos de shell que has ejecutado previamente.

Choose MCP Server Setup

Espejo de

mock-assistant-mcp-server

Asistente de servidor MCP para datos simulados.

McpDocs

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

mpc-csharp-semantickernel

Okay, here's an example illustrating how you might 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 tailor the example accordingly. **Remember to replace the placeholder values with your actual API keys, server addresses, and specific requirements.** **Scenario:** Let's say you want to build a simple application that: 1. Takes a user's request (e.g., "Summarize this article"). 2. Uses OpenAI to summarize the article. 3. Sends the summary to an MCP Server for further processing (e.g., sentiment analysis, formatting, or storage). 4. Returns the processed summary to the user. **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 Example { private static readonly HttpClient client = new HttpClient(); public static async Task Main(string[] args) { // 1. Configure Semantic Kernel string apiKey = "YOUR_OPENAI_API_KEY"; // Replace with your OpenAI API key string orgId = "YOUR_OPENAI_ORG_ID"; // Replace with your OpenAI organization ID (optional) string modelName = "gpt-3.5-turbo"; // Or another suitable model Kernel kernel = Kernel.CreateBuilder() .AddOpenAIChatCompletion(modelName, apiKey, orgId) .Build(); // 2. Define the Prompt (using Semantic Kernel's prompt template) string promptTemplate = @" Summarize the following text: {{$input}} Summary: "; // 3. Create a Semantic Function var summarizeFunction = kernel.CreateFunction(promptTemplate); // 4. Get User Input (replace with your actual input method) string articleText = "This is a long article about the benefits of using Semantic Kernel with OpenAI. It allows developers to easily integrate AI into their applications. Semantic Kernel provides a flexible and extensible framework for building AI-powered solutions. OpenAI provides powerful language models that can be used for a variety of tasks, such as summarization, translation, and code generation."; // 5. Execute the Semantic Function (call OpenAI) var arguments = new KernelArguments { ["input"] = articleText }; var summaryResult = await kernel.InvokeAsync(summarizeFunction, arguments); string summary = summaryResult.ToString(); Console.WriteLine($"OpenAI Summary: {summary}"); // 6. Send the Summary to the MCP Server string mcpServerUrl = "http://your-mcp-server.com/process"; // Replace with your MCP server URL string mcpResponse = await SendToMCP(mcpServerUrl, summary); Console.WriteLine($"MCP Server Response: {mcpResponse}"); // 7. Display the Final Result Console.WriteLine($"Final Result: {mcpResponse}"); // Or format/combine as needed } // Helper function to send data to the MCP Server static async Task<string> SendToMCP(string url, string data) { try { var json = JsonSerializer.Serialize(new { summary = data }); // Package the data as JSON var content = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await client.PostAsync(url, content); response.EnsureSuccessStatusCode(); // Throw exception if not successful string responseBody = await response.Content.ReadAsStringAsync(); return responseBody; } catch (HttpRequestException e) { Console.WriteLine($"Error sending to MCP Server: {e.Message}"); return "Error processing with MCP Server."; } } } ``` **Explanation:** 1. **Configure Semantic Kernel:** This section sets up the Semantic Kernel, connects to OpenAI using your API key and organization ID, and specifies the OpenAI model you want to use (e.g., `gpt-3.5-turbo`). You'll need to install the necessary NuGet packages: `Microsoft.SemanticKernel`, `Microsoft.SemanticKernel.Connectors.OpenAI`. 2. **Define the Prompt:** This defines the prompt template that will be sent to OpenAI. The `{{$input}}` placeholder will be replaced with the article text. 3. **Create a Semantic Function:** This creates a Semantic Kernel function from the prompt template. This function encapsulates the logic for summarizing the text using OpenAI. 4. **Get User Input:** This is where you would get the article text from the user (e.g., from a text box, a file, or a web API). In this example, it's hardcoded for simplicity. 5. **Execute the Semantic Function:** This calls the Semantic Kernel function, which sends the prompt to OpenAI and retrieves the summary. The `KernelArguments` object is used to pass the article text to the prompt. 6. **Send to MCP Server:** This is the crucial part where you interact with your hypothetical MCP Server. This example assumes the MCP Server accepts a JSON payload with a `summary` field and returns a JSON response. The `SendToMCP` helper function handles the HTTP communication. **You'll need to adapt this section to match the specific API of your MCP Server.** This includes the URL, the request format (JSON, XML, etc.), and the expected response format. Error handling is included. 7. **Display the Final Result:** This displays the final result to the user. You might want to format or combine the OpenAI summary and the MCP Server response before displaying it. **Important Considerations and Adaptations for Your MCP Server:** * **MCP Server API:** The most important thing is to understand the API of your MCP Server. What URL do you need to send requests to? What data format does it expect (JSON, XML, form data, etc.)? What data does it return? Adapt the `SendToMCP` function accordingly. * **Authentication:** If your MCP Server requires authentication (e.g., API keys, OAuth), you'll need to add the appropriate authentication headers to the `HttpClient` requests in the `SendToMCP` function. * **Error Handling:** The example includes basic error handling for the HTTP request. You should add more robust error handling to handle potential issues with the MCP Server, such as network errors, server errors, and invalid responses. * **Data Transformation:** You might need to transform the data between the OpenAI summary and the format expected by the MCP Server. For example, you might need to convert the summary to a different character encoding or add additional metadata. * **Asynchronous Operations:** The example uses asynchronous operations (`async` and `await`) to avoid blocking the main thread. This is important for performance, especially when dealing with network requests. * **Dependency Injection:** For a more robust application, consider using dependency injection to manage the `HttpClient` and other dependencies. * **Configuration:** Store configuration values (API keys, server URLs) in a configuration file (e.g., `appsettings.json`) instead of hardcoding them in the code. **Spanish Translation of the Explanation:** Aquí tienes un ejemplo que ilustra cómo podrías usar Microsoft Semantic Kernel con OpenAI y un hipotético "Servidor MCP" (asumiendo que MCP significa algo como "Mi Servidor de Procesamiento Personalizado" o "Servidor de Protocolo de Control de Mensajes"). Dado que "Servidor MCP" es vago, haré algunas suposiciones sobre su funcionalidad y adaptaré el ejemplo en consecuencia. **Recuerda reemplazar los valores de marcador de posición con tus claves API reales, direcciones de servidor y requisitos específicos.** **Escenario:** Digamos que quieres construir una aplicación simple que: 1. Toma la solicitud de un usuario (por ejemplo, "Resume este artículo"). 2. Utiliza OpenAI para resumir el artículo. 3. Envía el resumen a un Servidor MCP para su posterior procesamiento (por ejemplo, análisis de sentimiento, formateo o almacenamiento). 4. Devuelve el resumen procesado al usuario. **Ejemplo de Código (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 Example { private static readonly HttpClient client = new HttpClient(); public static async Task Main(string[] args) { // 1. Configurar Semantic Kernel string apiKey = "YOUR_OPENAI_API_KEY"; // Reemplaza con tu clave API de OpenAI string orgId = "YOUR_OPENAI_ORG_ID"; // Reemplaza con tu ID de organización de OpenAI (opcional) string modelName = "gpt-3.5-turbo"; // U otro modelo adecuado Kernel kernel = Kernel.CreateBuilder() .AddOpenAIChatCompletion(modelName, apiKey, orgId) .Build(); // 2. Definir el Prompt (usando la plantilla de prompt de Semantic Kernel) string promptTemplate = @" Resume el siguiente texto: {{$input}} Resumen: "; // 3. Crear una Función Semántica var summarizeFunction = kernel.CreateFunction(promptTemplate); // 4. Obtener la Entrada del Usuario (reemplaza con tu método de entrada real) string articleText = "Este es un artículo largo sobre los beneficios de usar Semantic Kernel con OpenAI. Permite a los desarrolladores integrar fácilmente la IA en sus aplicaciones. Semantic Kernel proporciona un marco flexible y extensible para construir soluciones impulsadas por IA. OpenAI proporciona modelos de lenguaje potentes que se pueden utilizar para una variedad de tareas, como resumen, traducción y generación de código."; // 5. Ejecutar la Función Semántica (llamar a OpenAI) var arguments = new KernelArguments { ["input"] = articleText }; var summaryResult = await kernel.InvokeAsync(summarizeFunction, arguments); string summary = summaryResult.ToString(); Console.WriteLine($"Resumen de OpenAI: {summary}"); // 6. Enviar el Resumen al Servidor MCP string mcpServerUrl = "http://your-mcp-server.com/process"; // Reemplaza con la URL de tu servidor MCP string mcpResponse = await SendToMCP(mcpServerUrl, summary); Console.WriteLine($"Respuesta del Servidor MCP: {mcpResponse}"); // 7. Mostrar el Resultado Final Console.WriteLine($"Resultado Final: {mcpResponse}"); // O formatea/combina según sea necesario } // Función auxiliar para enviar datos al Servidor MCP static async Task<string> SendToMCP(string url, string data) { try { var json = JsonSerializer.Serialize(new { summary = data }); // Empaqueta los datos como JSON var content = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await client.PostAsync(url, content); response.EnsureSuccessStatusCode(); // Lanza una excepción si no tiene éxito string responseBody = await response.Content.ReadAsStringAsync(); return responseBody; } catch (HttpRequestException e) { Console.WriteLine($"Error al enviar al Servidor MCP: {e.Message}"); return "Error al procesar con el Servidor MCP."; } } } ``` **Explicación:** 1. **Configurar Semantic Kernel:** Esta sección configura Semantic Kernel, se conecta a OpenAI usando tu clave API e ID de organización, y especifica el modelo de OpenAI que deseas usar (por ejemplo, `gpt-3.5-turbo`). Necesitarás instalar los paquetes NuGet necesarios: `Microsoft.SemanticKernel`, `Microsoft.SemanticKernel.Connectors.OpenAI`. 2. **Definir el Prompt:** Esto define la plantilla de prompt que se enviará a OpenAI. El marcador de posición `{{$input}}` se reemplazará con el texto del artículo. 3. **Crear una Función Semántica:** Esto crea una función Semantic Kernel a partir de la plantilla de prompt. Esta función encapsula la lógica para resumir el texto usando OpenAI. 4. **Obtener la Entrada del Usuario:** Aquí es donde obtendrías el texto del artículo del usuario (por ejemplo, desde un cuadro de texto, un archivo o una API web). En este ejemplo, está codificado para simplificar. 5. **Ejecutar la Función Semántica:** Esto llama a la función Semantic Kernel, que envía el prompt a OpenAI y recupera el resumen. El objeto `KernelArguments` se utiliza para pasar el texto del artículo al prompt. 6. **Enviar al Servidor MCP:** Esta es la parte crucial donde interactúas con tu hipotético Servidor MCP. Este ejemplo asume que el Servidor MCP acepta una carga útil JSON con un campo `summary` y devuelve una respuesta JSON. La función auxiliar `SendToMCP` maneja la comunicación HTTP. **Deberás adaptar esta sección para que coincida con la API específica de tu Servidor MCP.** Esto incluye la URL, el formato de solicitud (JSON, XML, etc.) y el formato de respuesta esperado. Se incluye el manejo de errores. 7. **Mostrar el Resultado Final:** Esto muestra el resultado final al usuario. Es posible que desees formatear o combinar el resumen de OpenAI y la respuesta del Servidor MCP antes de mostrarlo. **Consideraciones Importantes y Adaptaciones para tu Servidor MCP:** * **API del Servidor MCP:** Lo más importante es comprender la API de tu Servidor MCP. ¿A qué URL necesitas enviar solicitudes? ¿Qué formato de datos espera (JSON, XML, datos de formulario, etc.)? ¿Qué datos devuelve? Adapta la función `SendToMCP` en consecuencia. * **Autenticación:** Si tu Servidor MCP requiere autenticación (por ejemplo, claves API, OAuth), deberás agregar los encabezados de autenticación apropiados a las solicitudes `HttpClient` en la función `SendToMCP`. * **Manejo de Errores:** El ejemplo incluye un manejo de errores básico para la solicitud HTTP. Debes agregar un manejo de errores más robusto para manejar posibles problemas con el Servidor MCP, como errores de red, errores del servidor y respuestas no válidas. * **Transformación de Datos:** Es posible que debas transformar los datos entre el resumen de OpenAI y el formato esperado por el Servidor MCP. Por ejemplo, es posible que debas convertir el resumen a una codificación de caracteres diferente o agregar metadatos adicionales. * **Operaciones Asíncronas:** El ejemplo utiliza operaciones asíncronas (`async` y `await`) para evitar bloquear el hilo principal. Esto es importante para el rendimiento, especialmente cuando se trata de solicitudes de red. * **Inyección de Dependencias:** Para una aplicación más robusta, considera usar la inyección de dependencias para administrar el `HttpClient` y otras dependencias. * **Configuración:** Almacena los valores de configuración (claves API, URL del servidor) en un archivo de configuración (por ejemplo, `appsettings.json`) en lugar de codificarlos en el código. This example provides a solid foundation. Remember to adapt it to the specifics of your "MCP Server" and your desired application logic. Good luck!

Simple Memory Extension MCP Server

Un servidor MCP que extiende la ventana de contexto de los agentes de IA al proporcionar herramientas para almacenar, recuperar y buscar recuerdos, lo que permite a los agentes mantener el historial y el contexto a lo largo de interacciones prolongadas.

Telegram MCP Server

MCP server to send notifications to Telegram

🐋 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

Okay, here's a basic outline and code snippets to get you started with a simple "Weather MCP" (presumably meaning a weather server using the Minecraft Protocol) in Python. I'll break it down into sections: **1. Understanding the Goal** * **Minecraft Protocol (MCP):** You want to send weather information to a Minecraft client (or a server acting as a client) using the Minecraft network protocol. This means understanding how Minecraft represents weather data in its packets. * **Weather Data Source:** You need a source of weather data. This could be a local file, a weather API (like OpenWeatherMap), or a simulated weather system. * **Server Logic:** Your Python script will act as a server, listening for connections from Minecraft clients, fetching weather data, and formatting it into Minecraft packets. **2. Core Libraries** You'll likely need these libraries: * **`socket`:** For basic network communication (listening for connections, sending data). * **`struct`:** For packing and unpacking data into the binary formats required by the Minecraft protocol. * **`json` or `requests` (if using a weather API):** To fetch and parse weather data from an external source. * **`threading` (optional):** If you want to handle multiple client connections concurrently. **3. Basic Server Structure** ```python import socket import struct import json import time import threading # Optional # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 25566 # Choose a port (not the default Minecraft port!) # --- Weather Data (Example - Replace with your source) --- def get_weather_data(): """ Replace this with your actual weather data source. This is just a placeholder. """ # Example: Simulate weather weather = { "raining": False, "thundering": False, "rain_strength": 0.0, "thunder_strength": 0.0 } return weather # --- Minecraft Packet Handling --- def create_change_game_state_packet(reason, value): """ Creates a Change Game State packet (0x1F in 1.12.2, might be different in other versions). This is used to control weather. Args: reason: The reason for the game state change (e.g., 1 for begin raining, 2 for end raining). value: The value associated with the reason (e.g., rain strength). Returns: bytes: The Minecraft packet. """ packet_id = 0x1F # Change Game State packet ID (1.12.2) data = struct.pack(">b f", reason, value) # Reason (byte), Value (float) packet = struct.pack(">b", packet_id) + data length = len(packet) packet = struct.pack(">b", length) + packet # Add length prefix return packet def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: while True: weather_data = get_weather_data() # Example: Send rain start/stop if weather_data["raining"]: rain_strength = weather_data["rain_strength"] packet = create_change_game_state_packet(1, rain_strength) # Begin raining conn.sendall(packet) else: packet = create_change_game_state_packet(2, 0.0) # End raining conn.sendall(packet) # Example: Send thunder start/stop if weather_data["thundering"]: thunder_strength = weather_data["thunder_strength"] packet = create_change_game_state_packet(7, thunder_strength) # Begin thundering conn.sendall(packet) else: packet = create_change_game_state_packet(8, 0.0) # End thundering conn.sendall(packet) time.sleep(5) # Send weather updates every 5 seconds except ConnectionResetError: print(f"Client {addr} disconnected.") finally: conn.close() # --- Main Server Loop --- def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() # Start a new thread for each client (optional) thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() #handle_client(conn, addr) # If not using threads if __name__ == "__main__": main() ``` **4. Explanation and Key Points** * **`get_weather_data()`:** This is the most important part to customize. Replace the placeholder with code that fetches real weather data from an API or your own simulation. The example returns a dictionary with `raining`, `thundering`, `rain_strength`, and `thunder_strength`. * **`create_change_game_state_packet()`:** This function constructs the Minecraft packet that tells the client to change the weather. It uses `struct.pack()` to convert Python data types (integers, floats) into the binary format that Minecraft expects. **Important:** The packet ID (0x1F) and the structure of the packet can change between Minecraft versions. You'll need to consult the Minecraft protocol documentation for the version you're targeting. The example is for 1.12.2. * **Packet Structure:** Minecraft packets generally have a length prefix (a VarInt in newer versions, a single byte in older versions like 1.12.2), a packet ID, and then the packet data. The example uses a single byte for the length. * **`handle_client()`:** This function handles the communication with a single Minecraft client. It gets weather data, creates the appropriate packets, and sends them to the client. It also includes error handling for client disconnections. * **`main()`:** This is the main server loop. It listens for incoming connections and spawns a new thread (optionally) to handle each client. * **Threading (Optional):** Using threads allows you to handle multiple clients concurrently. If you don't use threads, the server will only be able to handle one client at a time. * **Error Handling:** The `try...except` block in `handle_client` catches `ConnectionResetError`, which occurs when a client disconnects abruptly. This prevents the server from crashing. * **Minecraft Protocol Documentation:** The most crucial resource is the Minecraft protocol documentation for the specific version of Minecraft you're targeting. You can find this information on the Minecraft Wiki or in community-maintained protocol specifications. Search for "Minecraft protocol [version]" (e.g., "Minecraft protocol 1.19"). * **Testing:** You'll need a Minecraft client (or a server acting as a client) to test your weather server. You can use a simple Minecraft client mod or a custom client written in Python or another language. **5. How to Use It** 1. **Install Libraries:** `pip install requests` (if you use a weather API). 2. **Replace Placeholder:** Implement the `get_weather_data()` function to fetch real weather data. 3. **Run the Script:** `python your_script_name.py` 4. **Connect a Client:** You'll need to write a Minecraft client (or modify an existing one) to connect to your server on the specified `HOST` and `PORT`. The client will need to be able to interpret the `Change Game State` packets. **Important Considerations and Next Steps** * **Minecraft Version Compatibility:** The Minecraft protocol changes between versions. The packet IDs and data structures in this example are likely for Minecraft 1.12.2. You'll need to adapt the code to the version you're using. * **Authentication:** This example doesn't include any authentication. In a real-world scenario, you'd want to add authentication to prevent unauthorized clients from connecting to your server. * **Error Handling:** Add more robust error handling to catch potential exceptions (e.g., network errors, API errors). * **Configuration:** Make the server configurable (e.g., allow the user to specify the weather API key, the update interval, the port number). * **More Weather Effects:** Explore other Minecraft weather effects that you can control through packets (e.g., lightning, fog). * **Client-Side Mod:** The easiest way to test this is to create a simple client-side Minecraft mod that connects to your server and displays the weather information. This will allow you to see the effects of the packets you're sending. This is a starting point. Building a fully functional weather server requires a deeper understanding of the Minecraft protocol and some client-side development. Good luck!

mcp-cbs-cijfers-open-data

Here are a few ways to translate "MCP server for working with CBS Cijfers Open Data" into Spanish, depending on the nuance you want to convey: **Option 1 (Most literal and general):** * **Servidor MCP para trabajar con los Datos Abiertos de CBS Cijfers** * This is a direct translation and is suitable if you want to be clear and concise. **Option 2 (Slightly more descriptive):** * **Servidor MCP para el procesamiento de los Datos Abiertos de CBS Cijfers** * This emphasizes the processing aspect of working with the data. **Option 3 (Focus on using the data):** * **Servidor MCP para utilizar los Datos Abiertos de CBS Cijfers** * This emphasizes the usage of the data. **Option 4 (More technical, if appropriate):** * **Servidor MCP para la gestión de los Datos Abiertos de CBS Cijfers** * This implies a more comprehensive management of the data. **Which option is best depends on the specific context.** If you can provide more information about what you're trying to do with the MCP server and the CBS Cijfers Open Data, I can give you a more precise translation. **Key Considerations:** * **MCP:** It's assumed that "MCP" is an acronym or proper noun that doesn't need translation. If it *does* have a Spanish equivalent, please provide it. * **CBS Cijfers Open Data:** This is likely a specific dataset name and should be kept as is. * **"Working with":** The best translation of this phrase depends on the specific actions being performed with the data (processing, using, managing, etc.).

testmcpgithubdemo1

created from MCP server demo

Linear MCP Server

Mirror of

create-mcp-server

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

MCP Server Docker

Servidor MCP para Docker

Flights Mcp Server

Servidor MCP para Google Flights!!

gatherings MCP Server

Un servidor de Protocolo de Contexto de Modelo que ayuda a rastrear gastos y calcular reembolsos para eventos sociales, facilitando el ajuste de cuentas entre amigos.

MCP Server Pool

MCP 服务合集

mcp-server-fetch-typescript MCP Server

Mirror of

Google Scholar

🔍 Habilita a los asistentes de IA para buscar y acceder a artículos de Google Académico a través de una interfaz MCP sencilla.

MCP Server для Prom.ua

Un servidor MCP para trabajar con la API de Prom.ua.