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', { useClass: DataService } ); container.register( '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 { // 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; } ``` **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'); 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', { useClass: DataService } ); container.register( '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 { // 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; } ``` **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'); 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!

Discover Awesome MCP Servers

Extend your agent with 10,066 capabilities via MCP servers.