Discover Awesome MCP Servers

MCP Registry Server

Mirror of

MCP Lambda Server

A Lambda Layer that allows a lambda to operate as an MCP server

GitHub MCP Server Configuration

Documentation and configuration details for GitHub MCP server setup

mcp-software-consultant

A CLI tool, MCP server, and vscode extension that allows Cline to ask an external specialized consultant for help

@madisonbullard/mcp-servers

A monorepo containing Model Context Protocol servers for various use cases.

Hubble AI for Solana

Servidor MCP de Hubble-ai

spring-ai-mcp-client

mcp client application that utilizes spring ai and anthropic claude models. it integrates with mcp protocol-supported servers to enable ai-powered chat interactions.

WindTools MCP Server

Your own codebase tools like code semantic search

QuickBooks Time MCP Server (Combined)

Mirror of

paperscraper-MCP-Server

Un servidor MCP para paperscraper: Herramientas para extraer metadatos de publicaciones de PubMed, arXiv, medRxiv, bioRxiv y chemRxiv.

MCP Community Portal

Una colección moderna e impulsada por la comunidad de servidores, herramientas y recursos de Model Context Protocol (MCP) en contenedores Docker.

Sydney Grammar School Headmasters Chat Application

Agente RAG y servidor MCP para el chat del Colegio Sydney Grammar.

Claude Memory MCP Server

Un servidor MCP que proporciona capacidades de memoria persistente para Claude, ofreciendo una arquitectura de memoria escalonada con búsqueda semántica, consolidación de memoria e integración con la aplicación de escritorio de Claude.

testmcpgithubdemo1

created from MCP server demo

Telegram MCP Server

MCP server to send notifications to Telegram

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!

create-mcp-server

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

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.

🐋 Docker MCP server

Mirror of

MCP Server Pool

MCP 服务合集

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.