Discover Awesome MCP Servers

MCP Expert Server

Un servidor de Protocolo de Contexto de Modelo que utiliza la IA de Claude para generar consultas inteligentes y ofrecer asistencia de documentación basada en el análisis de la documentación de la API.

Web Accessibility MCP Server

Proporciona análisis de accesibilidad web y simulación de daltonismo utilizando axe-core y Puppeteer, lo que permite comprobaciones de accesibilidad detalladas y simulaciones visuales basadas en las directrices WCAG.

Frontend Review MCP

Un servidor MCP que revisa visualmente las solicitudes de edición de la interfaz de usuario comparando capturas de pantalla antes y después de las modificaciones, asegurando que los cambios satisfagan las peticiones del usuario.

Git MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los Modelos de Lenguaje Grandes interactuar con repositorios Git a través de una API robusta, que admite operaciones como la inicialización de repositorios, la clonación, la preparación de archivos, la confirmación de cambios y la gestión de ramas.

MCP Python Toolbox

Un servidor de Protocolo de Contexto de Modelo que permite a asistentes de IA como Claude realizar tareas de desarrollo en Python a través de operaciones de archivos, análisis de código, gestión de proyectos y ejecución segura de código.

browser-use MCP server

Este servidor proporciona un sistema de almacenamiento de notas con un esquema URI personalizado, que permite a los usuarios añadir y resumir notas, con niveles de detalle de resumen ajustables.

GCP MCP

Un servidor de Protocolo de Contexto de Modelo que permite a asistentes de IA como Claude interactuar con entornos de Google Cloud Platform a través del lenguaje natural, permitiendo a los usuarios consultar y administrar recursos de GCP durante las conversaciones.

Zotero MCP Connector

Integra bibliotecas locales de Zotero con la interfaz de escritorio de Claude, permitiendo a los usuarios acceder y gestionar sus colecciones de bibliotecas a través de una API local.

Shell MCP Server

Un servidor seguro que permite que las aplicaciones de IA ejecuten comandos de shell en directorios especificados, admitiendo múltiples tipos de shell (bash, sh, cmd, powershell) con características de seguridad integradas como aislamiento de directorios y control de tiempo de espera.

MCP Snowflake Service

Un servidor de Protocolo de Contexto de Modelo que permite a Claude ejecutar consultas SQL en bases de datos Snowflake con gestión automática del ciclo de vida de la conexión.

Doc Scraper MCP Server

Convierte documentación basada en la web a formato markdown utilizando el servicio de conversión de jina.ai, permitiendo a los usuarios extraer documentación de cualquier URL y guardarla como archivos markdown.

YouTube Music MCP Server

Un servidor MCP que permite a modelos de IA controlar la reproducción de YouTube Music a través de Google Chrome, buscando y reproduciendo canciones utilizando los nombres de la canción y el artista.

Google Drive MCP Server

Permite la integración con Google Drive para listar, leer y buscar archivos, admitiendo varios tipos de archivos con exportación automática para archivos de Google Workspace.

MCP 3D Printer Server

Permite la interacción con sistemas de gestión de impresoras 3D a través de un servidor MCP, admitiendo la manipulación de archivos STL, el rebanado (slicing) y el control de impresoras como OctoPrint, Klipper, Duet y más.

MCP MySQL Server

Facilita la interacción con una base de datos MySQL local a través de una API RESTful, admitiendo consultas a la base de datos y actualizaciones en tiempo real con integración para los servicios Cursor MCP.

MCP Server Template

Okay, here's a TypeScript template outline for creating Model Context Protocol (MCP) servers, incorporating container-based dependency injection, a service-based architecture, and integration with an LLM CLI for architectural feedback. This is a high-level structure; you'll need to flesh out the details based on your specific needs. **Project Structure:** ``` mcp-server-template/ ├── src/ │ ├── core/ # Core application logic │ │ ├── container.ts # Dependency Injection Container │ │ ├── services/ # Business logic services │ │ │ ├── data-service.ts │ │ │ ├── model-service.ts │ │ │ └── ... │ │ ├── models/ # Data models/interfaces │ │ │ ├── request.ts │ │ │ ├── response.ts │ │ │ └── ... │ │ ├── interfaces/ # Service interfaces │ │ │ ├── data-service.interface.ts │ │ │ ├── model-service.interface.ts │ │ │ └── ... │ │ ├── errors/ # Custom error definitions │ │ │ ├── invalid-argument-error.ts │ │ │ └── ... │ ├── api/ # API layer (e.g., Express routes) │ │ ├── controllers/ # Route handlers │ │ │ ├── data-controller.ts │ │ │ ├── model-controller.ts │ │ │ └── ... │ │ ├── middleware/ # Middleware (logging, auth, etc.) │ │ │ ├── request-logger.ts │ │ │ └── ... │ │ ├── routes/ # Route definitions │ │ │ ├── data-routes.ts │ │ │ ├── model-routes.ts │ │ │ └── ... │ ├── config/ # Configuration files │ │ ├── default.ts # Default configuration │ │ ├── development.ts # Development overrides │ │ ├── production.ts # Production overrides │ ├── llm/ # LLM Integration (CLI) │ │ ├── llm-cli.ts # CLI entry point │ │ ├── prompts/ # Prompts for architectural feedback │ │ │ ├── design-review.prompt.txt │ │ │ └── ... │ ├── app.ts # Main application entry point │ └── server.ts # Server setup (Express) ├── test/ # Unit and integration tests ├── package.json ├── tsconfig.json ├── README.md ``` **Key Components and Code Snippets:** **1. Dependency Injection (Container):** * **`src/core/container.ts`:** Uses a library like `tsyringe` or `inversify-express-utils`. ```typescript // src/core/container.ts import { container } from 'tsyringe'; import { DataService } from './services/data-service'; import { ModelService } from './services/model-service'; import { IDataService } from './interfaces/data-service.interface'; import { IModelService } from './interfaces/model-service.interface'; container.register<IDataService>( 'IDataService', { useClass: DataService } ); container.register<IModelService>( 'IModelService', { useClass: ModelService } ); export { container }; ``` **2. Service-Based Architecture:** * **`src/core/services/data-service.ts`:** Example service. ```typescript // src/core/services/data-service.ts import { injectable, inject } from 'tsyringe'; import { IDataService } from '../interfaces/data-service.interface'; @injectable() export class DataService implements IDataService { constructor() { // Inject dependencies here if needed } async getData(): Promise<any> { // Your data retrieval logic here return { message: 'Data from DataService' }; } } ``` * **`src/core/interfaces/data-service.interface.ts`:** Interface for the service. ```typescript // src/core/interfaces/data-service.interface.ts export interface IDataService { getData(): Promise<any>; } ``` **3. API Layer (Express):** * **`src/api/controllers/data-controller.ts`:** Handles requests related to data. ```typescript // src/api/controllers/data-controller.ts import { Request, Response } from 'express'; import { container } from '../../core/container'; import { IDataService } from '../../core/interfaces/data-service.interface'; export const getData = async (req: Request, res: Response) => { const dataService = container.resolve<IDataService>('IDataService'); try { const data = await dataService.getData(); res.json(data); } catch (error) { console.error(error); res.status(500).json({ error: 'Failed to retrieve data' }); } }; ``` * **`src/api/routes/data-routes.ts`:** Defines the routes. ```typescript // src/api/routes/data-routes.ts import express from 'express'; import { getData } from '../controllers/data-controller'; const router = express.Router(); router.get('/data', getData); export default router; ``` * **`src/app.ts`:** Main application setup. ```typescript // src/app.ts import express from 'express'; import dataRoutes from './api/routes/data-routes'; import { requestLogger } from './api/middleware/request-logger'; // Example middleware const app = express(); // Middleware app.use(express.json()); app.use(requestLogger); // Routes app.use('/api', dataRoutes); export default app; ``` * **`src/server.ts`:** Starts the server. ```typescript // src/server.ts import app from './app'; import config from './config/default'; // Or use environment variables const port = config.port || 3000; app.listen(port, () => { console.log(`Server listening on port ${port}`); }); ``` **4. LLM CLI Integration:** * **`src/llm/llm-cli.ts`:** CLI entry point using a library like `commander`. ```typescript // src/llm/llm-cli.ts import { Command } from 'commander'; import fs from 'fs'; import path from 'path'; import { OpenAI } from 'openai'; // Or your preferred LLM library import config from '../config/default'; const program = new Command(); program .command('review-design') .description('Get architectural design feedback from an LLM') .action(async () => { try { const openai = new OpenAI({ apiKey: config.openaiApiKey }); // Replace with your API key and setup const promptPath = path.join(__dirname, 'prompts', 'design-review.prompt.txt'); const prompt = fs.readFileSync(promptPath, 'utf-8'); // Gather architectural information (e.g., from your code or config) const architectureDescription = ` Service-based architecture with DataService and ModelService. Uses tsyringe for dependency injection. Express.js for the API layer. `; const fullPrompt = prompt.replace('{{ARCHITECTURE_DESCRIPTION}}', architectureDescription); const completion = await openai.chat.completions.create({ messages: [{ role: "user", content: fullPrompt }], model: "gpt-3.5-turbo", // Or your preferred model }); console.log(completion.choices[0].message.content); } catch (error) { console.error('Error getting LLM feedback:', error); } }); program.parse(process.argv); ``` * **`src/llm/prompts/design-review.prompt.txt`:** Prompt for the LLM. ``` You are an experienced software architect providing feedback on a system design. Here's a description of the architecture: {{ARCHITECTURE_DESCRIPTION}} Please provide feedback on the following aspects: * Scalability * Maintainability * Security * Potential bottlenecks Suggest improvements where applicable. ``` **5. Configuration:** * **`src/config/default.ts`:** Default configuration. ```typescript // src/config/default.ts export default { port: 3000, databaseUrl: 'mongodb://localhost:27017/mcp', openaiApiKey: 'YOUR_OPENAI_API_KEY', // Replace with your actual API key }; ``` **6. `package.json`:** ```json { "name": "mcp-server-template", "version": "1.0.0", "description": "TypeScript template for MCP servers", "main": "dist/server.js", "scripts": { "build": "tsc", "start": "node dist/server.js", "dev": "nodemon src/server.ts", "llm": "ts-node src/llm/llm-cli.ts" // Add this line }, "dependencies": { "express": "^4.18.2", "tsyringe": "^4.8.0", "reflect-metadata": "^0.1.13", "commander": "^11.1.0", "openai": "^4.15.2" }, "devDependencies": { "@types/express": "^4.17.21", "@types/node": "^20.9.0", "nodemon": "^3.0.1", "ts-node": "^10.9.1", "typescript": "^5.2.2" } } ``` **Explanation and Key Considerations:** * **TypeScript:** Provides static typing for better code maintainability and error detection. * **Dependency Injection (tsyringe):** Makes your code more modular, testable, and easier to maintain. Other options include `inversify-express-utils`. Remember to install `reflect-metadata` and configure it in your `tsconfig.json`. * **Service-Based Architecture:** Separates concerns and promotes reusability. Each service encapsulates a specific piece of business logic. * **Express.js:** A popular Node.js web framework for building APIs. * **LLM CLI:** Allows you to get architectural feedback from an LLM directly from the command line. You'll need an LLM API key (e.g., OpenAI) and a well-crafted prompt. The prompt should provide the LLM with enough context about your architecture to give meaningful feedback. Consider using environment variables for sensitive information like API keys. * **Configuration:** Use a configuration library (or environment variables) to manage different settings for different environments (development, production, etc.). * **Error Handling:** Implement robust error handling throughout your application. * **Testing:** Write unit and integration tests to ensure the quality of your code. * **Middleware:** Use middleware for common tasks like logging, authentication, and request validation. * **Models/Interfaces:** Define clear data models and interfaces to improve code clarity and maintainability. * **Asynchronous Operations:** Use `async/await` for asynchronous operations to avoid callback hell. * **Security:** Implement security best practices, such as input validation, output encoding, and authentication/authorization. * **MCP Specifics:** Adapt the `models`, `services`, and API endpoints to match the specific requirements of the Model Context Protocol. This template provides a general structure; you'll need to define the data formats and operations that are part of the MCP. **How to Use the LLM CLI:** 1. **Install Dependencies:** `npm install` 2. **Set your OpenAI API key:** Either in `src/config/default.ts` (for testing) or as an environment variable. 3. **Build the project:** `npm run build` 4. **Run the LLM CLI:** `npm run llm review-design` **Important Considerations for the LLM Integration:** * **Prompt Engineering:** The quality of the LLM's feedback depends heavily on the prompt. Experiment with different prompts to get the best results. * **Context:** Provide the LLM with as much relevant context as possible about your architecture. This might include service descriptions, data models, and configuration settings. * **Cost:** LLM APIs can be expensive. Be mindful of the number of requests you're making. * **Security:** Avoid sending sensitive information to the LLM. * **Rate Limiting:** Be aware of the LLM API's rate limits. * **Error Handling:** Handle errors from the LLM API gracefully. This template provides a solid foundation for building MCP servers in TypeScript. Remember to adapt it to your specific needs and to follow best practices for software development. Good luck! --- Now, here's the translation of the above response into Spanish: **Estructura de Plantilla para Servidores MCP (Model Context Protocol) en TypeScript** Aquí tienes un esquema de plantilla en TypeScript para crear servidores Model Context Protocol (MCP), incorporando inyección de dependencias basada en contenedores, una arquitectura basada en servicios e integración con una CLI LLM para obtener retroalimentación arquitectónica. Esta es una estructura de alto nivel; deberás completar los detalles según tus necesidades específicas. **Estructura del Proyecto:** ``` mcp-server-template/ ├── src/ │ ├── core/ # Lógica central de la aplicación │ │ ├── container.ts # Contenedor de Inyección de Dependencias │ │ ├── services/ # Servicios de lógica de negocio │ │ │ ├── data-service.ts │ │ │ ├── model-service.ts │ │ │ └── ... │ │ ├── models/ # Modelos/interfaces de datos │ │ │ ├── request.ts │ │ │ ├── response.ts │ │ │ └── ... │ │ ├── interfaces/ # Interfaces de servicio │ │ │ ├── data-service.interface.ts │ │ │ ├── model-service.interface.ts │ │ │ └── ... │ │ ├── errors/ # Definiciones de errores personalizados │ │ │ ├── invalid-argument-error.ts │ │ │ └── ... │ ├── api/ # Capa de API (ej., rutas de Express) │ │ ├── controllers/ # Manejadores de rutas │ │ │ ├── data-controller.ts │ │ │ ├── model-controller.ts │ │ │ └── ... │ │ ├── middleware/ # Middleware (logging, autenticación, etc.) │ │ │ ├── request-logger.ts │ │ │ └── ... │ │ ├── routes/ # Definiciones de rutas │ │ │ ├── data-routes.ts │ │ │ ├── model-routes.ts │ │ │ └── ... │ ├── config/ # Archivos de configuración │ │ ├── default.ts # Configuración predeterminada │ │ ├── development.ts # Anulaciones para desarrollo │ │ ├── production.ts # Anulaciones para producción │ ├── llm/ # Integración LLM (CLI) │ │ ├── llm-cli.ts # Punto de entrada de la CLI │ │ ├── prompts/ # Prompts para retroalimentación arquitectónica │ │ │ ├── design-review.prompt.txt │ │ │ └── ... │ ├── app.ts # Punto de entrada principal de la aplicación │ └── server.ts # Configuración del servidor (Express) ├── test/ # Pruebas unitarias y de integración ├── package.json ├── tsconfig.json ├── README.md ``` **Componentes Clave y Fragmentos de Código:** **1. Inyección de Dependencias (Contenedor):** * **`src/core/container.ts`:** Utiliza una biblioteca como `tsyringe` o `inversify-express-utils`. ```typescript // src/core/container.ts import { container } from 'tsyringe'; import { DataService } from './services/data-service'; import { ModelService } from './services/model-service'; import { IDataService } from './interfaces/data-service.interface'; import { IModelService } from './interfaces/model-service.interface'; container.register<IDataService>( 'IDataService', { useClass: DataService } ); container.register<IModelService>( 'IModelService', { useClass: ModelService } ); export { container }; ``` **2. Arquitectura Basada en Servicios:** * **`src/core/services/data-service.ts`:** Servicio de ejemplo. ```typescript // src/core/services/data-service.ts import { injectable, inject } from 'tsyringe'; import { IDataService } from '../interfaces/data-service.interface'; @injectable() export class DataService implements IDataService { constructor() { // Inyecta dependencias aquí si es necesario } async getData(): Promise<any> { // Tu lógica de recuperación de datos aquí return { message: 'Datos desde DataService' }; } } ``` * **`src/core/interfaces/data-service.interface.ts`:** Interfaz para el servicio. ```typescript // src/core/interfaces/data-service.interface.ts export interface IDataService { getData(): Promise<any>; } ``` **3. Capa de API (Express):** * **`src/api/controllers/data-controller.ts`:** Maneja las solicitudes relacionadas con los datos. ```typescript // src/api/controllers/data-controller.ts import { Request, Response } from 'express'; import { container } from '../../core/container'; import { IDataService } from '../../core/interfaces/data-service.interface'; export const getData = async (req: Request, res: Response) => { const dataService = container.resolve<IDataService>('IDataService'); try { const data = await dataService.getData(); res.json(data); } catch (error) { console.error(error); res.status(500).json({ error: 'Error al recuperar los datos' }); } }; ``` * **`src/api/routes/data-routes.ts`:** Define las rutas. ```typescript // src/api/routes/data-routes.ts import express from 'express'; import { getData } from '../controllers/data-controller'; const router = express.Router(); router.get('/data', getData); export default router; ``` * **`src/app.ts`:** Configuración principal de la aplicación. ```typescript // src/app.ts import express from 'express'; import dataRoutes from './api/routes/data-routes'; import { requestLogger } from './api/middleware/request-logger'; // Ejemplo de middleware const app = express(); // Middleware app.use(express.json()); app.use(requestLogger); // Rutas app.use('/api', dataRoutes); export default app; ``` * **`src/server.ts`:** Inicia el servidor. ```typescript // src/server.ts import app from './app'; import config from './config/default'; // O usa variables de entorno const port = config.port || 3000; app.listen(port, () => { console.log(`Servidor escuchando en el puerto ${port}`); }); ``` **4. Integración de la CLI LLM:** * **`src/llm/llm-cli.ts`:** Punto de entrada de la CLI utilizando una biblioteca como `commander`. ```typescript // src/llm/llm-cli.ts import { Command } from 'commander'; import fs from 'fs'; import path from 'path'; import { OpenAI } from 'openai'; // O tu biblioteca LLM preferida import config from '../config/default'; const program = new Command(); program .command('review-design') .description('Obtener retroalimentación del diseño arquitectónico de un LLM') .action(async () => { try { const openai = new OpenAI({ apiKey: config.openaiApiKey }); // Reemplaza con tu clave API y configuración const promptPath = path.join(__dirname, 'prompts', 'design-review.prompt.txt'); const prompt = fs.readFileSync(promptPath, 'utf-8'); // Recopila información arquitectónica (ej., de tu código o configuración) const architectureDescription = ` Arquitectura basada en servicios con DataService y ModelService. Utiliza tsyringe para la inyección de dependencias. Express.js para la capa de API. `; const fullPrompt = prompt.replace('{{ARCHITECTURE_DESCRIPTION}}', architectureDescription); const completion = await openai.chat.completions.create({ messages: [{ role: "user", content: fullPrompt }], model: "gpt-3.5-turbo", // O tu modelo preferido }); console.log(completion.choices[0].message.content); } catch (error) { console.error('Error al obtener retroalimentación del LLM:', error); } }); program.parse(process.argv); ``` * **`src/llm/prompts/design-review.prompt.txt`:** Prompt para el LLM. ``` Eres un arquitecto de software experimentado que proporciona retroalimentación sobre un diseño de sistema. Aquí hay una descripción de la arquitectura: {{ARCHITECTURE_DESCRIPTION}} Por favor, proporciona retroalimentación sobre los siguientes aspectos: * Escalabilidad * Mantenibilidad * Seguridad * Posibles cuellos de botella Sugiere mejoras donde sea aplicable. ``` **5. Configuración:** * **`src/config/default.ts`:** Configuración predeterminada. ```typescript // src/config/default.ts export default { port: 3000, databaseUrl: 'mongodb://localhost:27017/mcp', openaiApiKey: 'YOUR_OPENAI_API_KEY', // Reemplaza con tu clave API real }; ``` **6. `package.json`:** ```json { "name": "mcp-server-template", "version": "1.0.0", "description": "Plantilla TypeScript para servidores MCP", "main": "dist/server.js", "scripts": { "build": "tsc", "start": "node dist/server.js", "dev": "nodemon src/server.ts", "llm": "ts-node src/llm/llm-cli.ts" // Agrega esta línea }, "dependencies": { "express": "^4.18.2", "tsyringe": "^4.8.0", "reflect-metadata": "^0.1.13", "commander": "^11.1.0", "openai": "^4.15.2" }, "devDependencies": { "@types/express": "^4.17.21", "@types/node": "^20.9.0", "nodemon": "^3.0.1", "ts-node": "^10.9.1", "typescript": "^5.2.2" } } ``` **Explicación y Consideraciones Clave:** * **TypeScript:** Proporciona tipado estático para una mejor mantenibilidad del código y detección de errores. * **Inyección de Dependencias (tsyringe):** Hace que tu código sea más modular, fácil de probar y mantener. Otras opciones incluyen `inversify-express-utils`. Recuerda instalar `reflect-metadata` y configurarlo en tu `tsconfig.json`. * **Arquitectura Basada en Servicios:** Separa las preocupaciones y promueve la reutilización. Cada servicio encapsula una pieza específica de lógica de negocio. * **Express.js:** Un framework web popular de Node.js para construir APIs. * **CLI LLM:** Te permite obtener retroalimentación arquitectónica de un LLM directamente desde la línea de comandos. Necesitarás una clave API LLM (ej., OpenAI) y un prompt bien elaborado. El prompt debe proporcionar al LLM suficiente contexto sobre tu arquitectura para dar una retroalimentación significativa. Considera usar variables de entorno para información sensible como las claves API. * **Configuración:** Utiliza una biblioteca de configuración (o variables de entorno) para administrar diferentes configuraciones para diferentes entornos (desarrollo, producción, etc.). * **Manejo de Errores:** Implementa un manejo de errores robusto en toda tu aplicación. * **Pruebas:** Escribe pruebas unitarias y de integración para asegurar la calidad de tu código. * **Middleware:** Utiliza middleware para tareas comunes como logging, autenticación y validación de solicitudes. * **Modelos/Interfaces:** Define modelos de datos e interfaces claros para mejorar la claridad y mantenibilidad del código. * **Operaciones Asíncronas:** Utiliza `async/await` para operaciones asíncronas para evitar el infierno de los callbacks. * **Seguridad:** Implementa las mejores prácticas de seguridad, como la validación de entrada, la codificación de salida y la autenticación/autorización. * **Específicos de MCP:** Adapta los `models`, `services` y los endpoints de la API para que coincidan con los requisitos específicos del Model Context Protocol. Esta plantilla proporciona una estructura general; deberás definir los formatos de datos y las operaciones que forman parte del MCP. **Cómo Usar la CLI LLM:** 1. **Instala las Dependencias:** `npm install` 2. **Configura tu clave API de OpenAI:** Ya sea en `src/config/default.ts` (para pruebas) o como una variable de entorno. 3. **Construye el proyecto:** `npm run build` 4. **Ejecuta la CLI LLM:** `npm run llm review-design` **Consideraciones Importantes para la Integración LLM:** * **Ingeniería de Prompts:** La calidad de la retroalimentación del LLM depende en gran medida del prompt. Experimenta con diferentes prompts para obtener los mejores resultados. * **Contexto:** Proporciona al LLM la mayor cantidad de contexto relevante posible sobre tu arquitectura. Esto podría incluir descripciones de servicios, modelos de datos y configuraciones. * **Costo:** Las APIs LLM pueden ser costosas. Ten en cuenta la cantidad de solicitudes que estás haciendo. * **Seguridad:** Evita enviar información sensible al LLM. * **Limitación de Tasa:** Ten en cuenta los límites de tasa de la API LLM. * **Manejo de Errores:** Maneja los errores de la API LLM con elegancia. Esta plantilla proporciona una base sólida para construir servidores MCP en TypeScript. Recuerda adaptarla a tus necesidades específicas y seguir las mejores prácticas para el desarrollo de software. ¡Buena suerte!

MCP File Server

Permite que los modelos de IA realicen operaciones del sistema de archivos (leer, crear y listar archivos) en un sistema de archivos local a través de una interfaz estandarizada del Protocolo de Contexto del Modelo.

Anki MCP Server

Un servidor basado en TypeScript que se integra con Anki a través del plugin AnkiConnect, permitiéndote gestionar mazos de tarjetas, modelos de notas y crear notas de Anki utilizando lenguaje natural.

MCP Notmuch Sendmail

Un servidor asistente de correo electrónico que conecta Claude Desktop a bases de datos de correo electrónico notmuch, permitiendo a los usuarios buscar correos electrónicos, ver hilos, redactar mensajes nuevos y responder a conversaciones con formato markdown.

Code Sandbox MCP

Un servidor MCP para crear un entorno sandbox de código seguro para ejecutar código dentro de contenedores Docker.

Github-Oauth MCP Server

Facilita la autenticación con GitHub utilizando el protocolo OAuth, permitiendo un acceso seguro e interacción con los repositorios y servicios de GitHub.

claude-code-mcp

Este proyecto tiene como objetivo construir un servidor Claude Code MCP e implementar sus herramientas asociadas (explain\_code, review\_code, fix\_code, edit\_code, test\_code, simulate\_command, your\_own\_query). El servidor se implementa utilizando Node.js y el SDK de MCP. Recibe solicitudes de herramientas de los clientes a través de Stdio, dinámicamente.

Super Windows CLI MCP Server

Un servidor MCP mejorado para la CLI de Windows que proporciona capacidades de acceso irrestricto al sistema, diseñado para entornos de confianza con requisitos de acceso total al sistema.

Notion MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a Claude y otros LLMs interactuar con espacios de trabajo de Notion, proporcionando capacidades como buscar, recuperar, crear y actualizar páginas, así como gestionar bases de datos.

mcp-local-dev

Crea entornos de desarrollo locales aislados directamente desde Github y ejecuta pruebas, consulta la cobertura y ¡mucho más! Compatible con Python, Node, Bun y muchos frameworks de pruebas.

Azure OpenAI

Aquí tienes una implementación mínima de una aplicación servidor/cliente que utiliza el Protocolo de Contexto de Modelo (MCP) y Azure OpenAI: **Consideraciones:** * **Simplicidad:** Este es un ejemplo simplificado para ilustrar los conceptos básicos. En una aplicación real, necesitarás manejar errores, autenticación, autorización, y otras consideraciones de producción. * **Entorno:** Asumo que tienes configurado un entorno de desarrollo con Python, las bibliotecas necesarias (ver abajo) y acceso a Azure OpenAI. * **Azure OpenAI:** Necesitarás una instancia de Azure OpenAI desplegada y configurada, con un modelo desplegado. Necesitarás la clave API y el endpoint. * **MCP:** El Protocolo de Contexto de Modelo (MCP) es un concepto, no una biblioteca específica. Aquí, lo implementamos directamente con llamadas HTTP. En el futuro, podrían existir bibliotecas que faciliten esto. **Requisitos (Python):** ```bash pip install flask requests ``` **1. Servidor (server.py):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Configuración de Azure OpenAI (reemplaza con tus valores) AZURE_OPENAI_ENDPOINT = os.environ.get("AZURE_OPENAI_ENDPOINT") # Ejemplo: "https://your-resource-name.openai.azure.com/" AZURE_OPENAI_API_KEY = os.environ.get("AZURE_OPENAI_API_KEY") AZURE_OPENAI_DEPLOYMENT_NAME = os.environ.get("AZURE_OPENAI_DEPLOYMENT_NAME") # Ejemplo: "your-deployment-name" AZURE_OPENAI_API_VERSION = "2023-05-15" # Asegúrate de usar una versión compatible @app.route('/mcp/query', methods=['POST']) def mcp_query(): """ Endpoint que recibe una consulta (prompt) y la envía a Azure OpenAI. Implementa el concepto de MCP (aunque de forma muy básica). """ try: data = request.get_json() prompt = data.get('prompt') if not prompt: return jsonify({'error': 'Prompt is required'}), 400 # Construye la solicitud a Azure OpenAI api_url = f"{AZURE_OPENAI_ENDPOINT}openai/deployments/{AZURE_OPENAI_DEPLOYMENT_NAME}/completions?api-version={AZURE_OPENAI_API_VERSION}" headers = { "Content-Type": "application/json", "api-key": AZURE_OPENAI_API_KEY } payload = { "prompt": prompt, "max_tokens": 150, # Ajusta según sea necesario "n": 1, "stop": None, "temperature": 0.7, } # Envía la solicitud a Azure OpenAI response = requests.post(api_url, headers=headers, json=payload) response.raise_for_status() # Lanza una excepción si hay un error HTTP # Procesa la respuesta de Azure OpenAI response_data = response.json() completion = response_data['choices'][0]['text'] # Devuelve la respuesta al cliente return jsonify({'completion': completion}) except Exception as e: print(f"Error: {e}") return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True, port=5000) ``` **2. Cliente (client.py):** ```python import requests import json SERVER_URL = "http://localhost:5000/mcp/query" # Ajusta si el servidor está en otra dirección def send_query(prompt): """ Envía una consulta al servidor MCP. """ try: headers = {'Content-Type': 'application/json'} payload = {'prompt': prompt} response = requests.post(SERVER_URL, headers=headers, data=json.dumps(payload)) response.raise_for_status() # Lanza una excepción si hay un error HTTP data = response.json() return data.get('completion') except requests.exceptions.RequestException as e: print(f"Error al conectar con el servidor: {e}") return None except Exception as e: print(f"Error al procesar la respuesta: {e}") return None if __name__ == '__main__': query = "Escribe un breve poema sobre la lluvia." completion = send_query(query) if completion: print(f"Consulta: {query}") print(f"Respuesta: {completion}") else: print("No se pudo obtener una respuesta.") ``` **Cómo ejecutar:** 1. **Configura las variables de entorno:** Antes de ejecutar el servidor, asegúrate de configurar las variables de entorno `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY` y `AZURE_OPENAI_DEPLOYMENT_NAME`. Puedes hacerlo en tu terminal antes de ejecutar el script: ```bash export AZURE_OPENAI_ENDPOINT="https://your-resource-name.openai.azure.com/" export AZURE_OPENAI_API_KEY="tu_clave_api" export AZURE_OPENAI_DEPLOYMENT_NAME="your-deployment-name" ``` Reemplaza los valores con los tuyos. También puedes usar un archivo `.env` y una biblioteca como `python-dotenv` para cargar las variables. 2. **Ejecuta el servidor:** ```bash python server.py ``` 3. **Ejecuta el cliente:** ```bash python client.py ``` **Explicación:** * **Servidor (server.py):** * Utiliza Flask para crear un servidor web simple. * Define un endpoint `/mcp/query` que acepta solicitudes POST con un `prompt` en formato JSON. * Toma el `prompt` del cuerpo de la solicitud. * Construye una solicitud a la API de Azure OpenAI. **Importante:** Reemplaza los valores de `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY` y `AZURE_OPENAI_DEPLOYMENT_NAME` con tus credenciales y el nombre de tu despliegue. * Envía la solicitud a Azure OpenAI usando la biblioteca `requests`. * Procesa la respuesta de Azure OpenAI y extrae la `completion`. * Devuelve la `completion` al cliente en formato JSON. * Maneja errores y devuelve códigos de estado HTTP apropiados. * **Cliente (client.py):** * Define la URL del servidor. * Define una función `send_query` que envía una solicitud POST al servidor con el `prompt` en formato JSON. * Recibe la respuesta del servidor y extrae la `completion`. * Imprime la consulta y la respuesta. * Maneja errores de conexión y procesamiento de la respuesta. **Concepto de MCP (Protocolo de Contexto de Modelo):** En este ejemplo, el concepto de MCP se implementa de la siguiente manera: * El servidor actúa como un intermediario entre el cliente y el modelo de lenguaje (Azure OpenAI). * El cliente envía una consulta (prompt) al servidor. * El servidor se encarga de: * Formatear la consulta para que sea compatible con el modelo de lenguaje. * Enviar la consulta al modelo de lenguaje. * Procesar la respuesta del modelo de lenguaje. * Devolver la respuesta al cliente en un formato consistente. En una implementación más compleja de MCP, el servidor podría también: * Gestionar el contexto de la conversación (historial de mensajes). * Aplicar reglas de seguridad y privacidad. * Realizar preprocesamiento y postprocesamiento de la consulta y la respuesta. * Seleccionar el modelo de lenguaje más adecuado para la consulta. **Mejoras:** * **Manejo de errores robusto:** Implementa un manejo de errores más completo en ambos lados (servidor y cliente). * **Autenticación y autorización:** Agrega autenticación y autorización para proteger el endpoint del servidor. * **Logging:** Implementa logging para rastrear las solicitudes y respuestas. * **Contexto de conversación:** Implementa la gestión del contexto de la conversación para permitir interacciones más complejas. * **Configuración:** Utiliza un archivo de configuración para almacenar la configuración del servidor y del cliente. * **Asincronía:** Considera usar `asyncio` para manejar las solicitudes de forma asíncrona, especialmente si esperas un alto volumen de tráfico. * **Validación de datos:** Valida los datos de entrada (prompt) en el servidor para prevenir ataques. * **Implementación de un esquema MCP más completo:** Define un esquema JSON para las solicitudes y respuestas MCP para garantizar la interoperabilidad. Este ejemplo proporciona un punto de partida para construir una aplicación más completa que utiliza el Protocolo de Contexto de Modelo y Azure OpenAI. Recuerda adaptar el código a tus necesidades específicas.

MCP-LOGO-GEN

MCP Tool Server for Logo Generation. This server provides logo generation capabilities using FAL AI, with tools for image generation, background removal, and image scaling.

Cline Personas MCP Server

Un servidor MCP para gestionar y activar plantillas y componentes de persona escribiendo en archivos .clinerules, que admite el seguimiento de versiones y el almacenamiento basado en archivos.

Cursor A11y MCP

Proporciona capacidades de pruebas de accesibilidad a través de la CLI, ayudando a identificar problemas de accesibilidad en aplicaciones web utilizando axe-core y Puppeteer.