Discover Awesome MCP Servers

SkyeNet-MCP-ACE

Enables AI agents to execute server-side JavaScript and perform CRUD operations directly on ServiceNow instances with context bloat reduction features for efficient token usage.

rxjs-mcp-server

Execute, debug, and visualize RxJS streams directly from AI assistants like Claude.

Sequential Thinking Tool API

A Node.js/TypeScript backend for managing sequential thinking sessions, allowing users to create sessions and post thoughts in a structured sequence with support for real-time updates via Server-Sent Events.

MCP Documentation Server

Enables semantic search and retrieval of MCP (Model Context Protocol) documentation using Redis-backed embeddings, allowing users to query and access documentation content through natural language.

Voice MCP

Enables voice interaction with Claude Code through local speech-to-text (Whisper) and text-to-speech (Supertonic), allowing verbal input/output without external API calls.

Remote MCP Server

A Cloudflare Workers-based MCP server that enables tool integration with Claude AI through OAuth login, allowing users to extend Claude's capabilities with custom tools like mathematical operations.

mcp-colombia

This MCP server connects AI agents with Colombian e-commerce, travel, and financial services, allowing users to search MercadoLibre, find hotels, and compare banking products like CDTs and loans. It enables seamless integration with local services in pesos colombianos through specialized tools for shopping, travel planning, and financial simulation.

Trusted GMail MCP Server

Primer servidor MCP confiable ejecutándose en un entorno de ejecución confiable AWS Nitro Enclave.

Databento MCP

A Model Context Protocol server that provides access to Databento's historical and real-time market data, including trades, OHLCV bars, and order book depth. It enables AI assistants to perform financial data analysis, manage batch jobs, and convert market data between DBN and Parquet formats.

OpenAPI REST MCP Server

Dynamically converts any REST service's OpenAPI specification into MCP tools, enabling interaction with REST endpoints through natural language. Supports Spring Boot services and includes auto-discovery for common API configurations.

mcp-victorialogs

mcp-victorialogs

MCP Password Generator

Generates secure random passwords and memorable passphrases with customizable options including length, character types, emojis, and automatic strength evaluation using zxcvbn scoring.

Mozaic MCP Server

Provides AI assistants access to the ADEO Mozaic Design System, enabling lookups of design tokens, component documentation, icons, and CSS utilities, plus generation of Vue and React component code snippets.

Futurama Quote Machine MCP Server

Enables interaction with Futurama quotes through Claude Desktop by connecting to the Futurama Quote Machine API. Supports getting random quotes, searching by character, adding new quotes, editing existing ones, and managing the quote collection through natural language.

Alayman MCP Server

Enables access to articles from alayman.io, allowing users to fetch, search, and filter technical content through natural language. It supports pagination and keyword-based filtering for specific topics like React, Angular, and TypeScript.

Hong Kong Creative Goods Trade MCP Server

Provides access to Hong Kong's recreation, sports, and cultural data through a FastMCP interface, allowing users to retrieve statistics on creative goods trade including domestic exports, re-exports, and imports with optional year filtering.

Airline Flight Delays MCP Server

An AI-powered customer service automation system designed to handle flight disruptions by providing real-time flight status, sentiment-aware passenger communication, and personalized engagement activities. It streamlines rebooking, airport recommendations, and human agent handoffs to improve the passenger experience during delays.

mcp-reticle

The Wireshark for the Model Context Protocol (Reticle) intercepts, visualises, and profiles MCP JSON-RPC traffic in real time — designed for microsecond-level overhead.

Wappalyzer MCP

A local MCP server that wraps the Wappalyzer API to identify web technologies, subdomains, and site metadata. It enables users to perform site lookups and access technology categories through natural language interfaces.

Audius MCP Server

Permite la interacción con la API de la plataforma de música Audius, admitiendo operaciones de usuario, pista y lista de reproducción a través del Protocolo de Contexto del Modelo.

YouTube MCP Server

Enables AI models to interact with YouTube content through video search, channel information, transcripts, comments, trending videos, and content analysis tools including quiz and flashcard generation.

Hyperliquid MCP Server v2

A Model Context Protocol server for Hyperliquid with integrated dashboard

Example Next.js MCP Server

A drop-in Model Context Protocol server implementation for Next.js projects that enables AI tools, prompts, and resources integration using the Vercel MCP Adapter.

Manim MCP Server

Enables Claude to create mathematical animation videos using Manim, allowing visualization of complex mathematical concepts like equations, graphs, geometric transformations, and calculus through programmatically generated animations.

Browser Control MCP

Un servidor MCP emparejado con una extensión de Firefox que permite a los clientes LLM controlar el navegador del usuario, con soporte para la gestión de pestañas, la búsqueda en el historial y la lectura de contenido.

MCP Avantage

A Model Context Protocol server that enables LLMs to access comprehensive financial data from Alpha Vantage API, including stock prices, fundamentals, forex, crypto, and economic indicators.

mcp-nestjs

A NestJS module for building Model Context Protocol (MCP) servers using decorators to expose services as tools, resources, and prompts. It features auto-discovery, a built-in playground UI, and support for multiple transports including SSE and Stdio.

mcpserver-ts

Okay, here's a basic MCP (presumably meaning something like "Mock Control Panel" or similar) server template in TypeScript, designed for quickly serving mock data. This focuses on simplicity and ease of modification. I'll include explanations to help you understand the code. ```typescript import express, { Express, Request, Response } from 'express'; import cors from 'cors'; // Import the cors middleware import bodyParser from 'body-parser'; const app: Express = express(); const port = process.env.PORT || 3000; // Middleware app.use(cors()); // Enable CORS for all origins (for development - adjust for production!) app.use(bodyParser.json()); // Parse JSON request bodies // Mock Data (Example) interface User { id: number; name: string; email: string; } const mockUsers: User[] = [ { id: 1, name: 'John Doe', email: 'john.doe@example.com' }, { id: 2, name: 'Jane Smith', email: 'jane.smith@example.com' }, { id: 3, name: 'Peter Jones', email: 'peter.jones@example.com' }, ]; // Routes // GET /users - Returns all users app.get('/users', (req: Request, res: Response) => { res.json(mockUsers); }); // GET /users/:id - Returns a specific user by ID app.get('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); // Get the ID from the URL parameter const user = mockUsers.find((u) => u.id === userId); if (user) { res.json(user); } else { res.status(404).json({ message: 'User not found' }); } }); // POST /users - Creates a new user (adds to the mock data) app.post('/users', (req: Request, res: Response) => { const newUser: User = { id: mockUsers.length + 1, // Simple ID generation (not suitable for production) ...req.body, // Assumes the request body contains the user data (name, email) }; mockUsers.push(newUser); res.status(201).json(newUser); // 201 Created status code }); // PUT /users/:id - Updates an existing user app.put('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); const userIndex = mockUsers.findIndex(u => u.id === userId); if (userIndex === -1) { return res.status(404).json({ message: 'User not found' }); } const updatedUser: User = { id: userId, ...req.body // Assumes the request body contains the updated user data }; mockUsers[userIndex] = updatedUser; res.json(updatedUser); }); // DELETE /users/:id - Deletes a user app.delete('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); const userIndex = mockUsers.findIndex(u => u.id === userId); if (userIndex === -1) { return res.status(404).json({ message: 'User not found' }); } mockUsers.splice(userIndex, 1); res.status(204).send(); // 204 No Content (successful deletion) }); app.listen(port, () => { console.log(`Server is running at http://localhost:${port}`); }); ``` Key improvements and explanations: * **TypeScript:** Uses TypeScript for type safety and better code organization. Interfaces like `User` define the structure of your data. * **Express:** Uses Express.js, a popular Node.js web framework, for handling routes and requests. * **CORS:** Includes `cors` middleware. This is *essential* if your frontend is running on a different port than your backend (which is very common during development). **Important:** For production, you should configure CORS to only allow requests from your specific frontend domain. The `cors()` call without arguments allows *all* origins, which is insecure for production. * **Body Parser:** Uses `body-parser` middleware to parse JSON request bodies. This is needed to access data sent in POST and PUT requests. * **Clearer Route Handling:** Uses `req.params.id` to get the ID from the URL in the `GET /users/:id` route. Includes error handling (404 Not Found) if the user isn't found. * **POST Route:** The `POST /users` route now creates a new user, adds it to the `mockUsers` array, and returns the new user with a 201 Created status code. It uses a very simple ID generation; in a real application, you'd use a database to generate unique IDs. * **PUT Route:** The `PUT /users/:id` route updates an existing user. It finds the user by ID, updates the properties with the data from the request body, and returns the updated user. Includes error handling (404 Not Found). * **DELETE Route:** The `DELETE /users/:id` route deletes a user. It finds the user by ID, removes them from the array, and returns a 204 No Content status code. Includes error handling (404 Not Found). * **Status Codes:** Uses appropriate HTTP status codes (200 OK, 201 Created, 204 No Content, 404 Not Found) to indicate the success or failure of requests. * **Error Handling:** Includes basic error handling for "user not found" scenarios. You'll want to expand this for more robust error handling in a real application. * **Comments:** Includes comments to explain the code. **How to use it:** 1. **Install Node.js and npm:** Make sure you have Node.js and npm (Node Package Manager) installed. 2. **Create a project directory:** ```bash mkdir mock-mcp-server cd mock-mcp-server ``` 3. **Initialize the project:** ```bash npm init -y ``` 4. **Install dependencies:** ```bash npm install express cors body-parser typescript @types/express @types/node --save-dev ``` 5. **Configure TypeScript:** * Create a `tsconfig.json` file in your project root: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "rootDir": "./", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["*.ts"], "exclude": ["node_modules"] } ``` 6. **Create the `index.ts` file:** Copy the TypeScript code above into a file named `index.ts` in your project directory. 7. **Compile the TypeScript:** ```bash npx tsc ``` This will create a `dist` directory with the compiled JavaScript files. 8. **Run the server:** ```bash node dist/index.js ``` Now your mock server should be running at `http://localhost:3000`. You can test it with tools like `curl`, Postman, or by making requests from your frontend application. **Example `curl` commands:** * **Get all users:** ```bash curl http://localhost:3000/users ``` * **Get user with ID 2:** ```bash curl http://localhost:3000/users/2 ``` * **Create a new user:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"name": "New User", "email": "new.user@example.com"}' http://localhost:3000/users ``` * **Update user with ID 1:** ```bash curl -X PUT -H "Content-Type: application/json" -d '{"name": "Updated User", "email": "updated.user@example.com"}' http://localhost:3000/users/1 ``` * **Delete user with ID 3:** ```bash curl -X DELETE http://localhost:3000/users/3 ``` **Important Considerations for Production:** * **CORS:** Configure CORS *very carefully* to only allow requests from your frontend domain(s). Never use `cors()` without arguments in production. * **Authentication/Authorization:** This template has no authentication or authorization. You'll need to add middleware to protect your routes if you're dealing with sensitive data. * **Data Persistence:** The mock data is stored in memory and will be lost when the server restarts. For a real application, you'll need to use a database (e.g., MongoDB, PostgreSQL, MySQL). * **Error Handling:** Implement more robust error handling, including logging and proper error responses. * **Validation:** Validate the data you receive from the client (e.g., using a library like `joi`) to prevent errors and security vulnerabilities. * **Security:** Follow security best practices to protect your server from attacks (e.g., using HTTPS, preventing SQL injection, etc.). * **Scalability:** This simple server is not designed for high traffic. If you need to handle a large number of requests, you'll need to consider scaling strategies (e.g., load balancing, caching). This template provides a solid foundation for building a mock server. Remember to adapt it to your specific needs and to address the production considerations if you're using it in a real-world environment. ```spanish Aquí tienes una plantilla básica de servidor MCP (presumiblemente significa algo como "Panel de Control de Mock" o similar) en TypeScript, diseñada para servir datos de prueba rápidamente. Se centra en la simplicidad y la facilidad de modificación. Incluiré explicaciones para ayudarte a entender el código. ```typescript import express, { Express, Request, Response } from 'express'; import cors from 'cors'; // Importa el middleware cors import bodyParser from 'body-parser'; const app: Express = express(); const port = process.env.PORT || 3000; // Middleware app.use(cors()); // Habilita CORS para todos los orígenes (para desarrollo - ¡ajusta para producción!) app.use(bodyParser.json()); // Analiza los cuerpos de las solicitudes JSON // Datos de prueba (Ejemplo) interface User { id: number; name: string; email: string; } const mockUsers: User[] = [ { id: 1, name: 'John Doe', email: 'john.doe@example.com' }, { id: 2, name: 'Jane Smith', email: 'jane.smith@example.com' }, { id: 3, name: 'Peter Jones', email: 'peter.jones@example.com' }, ]; // Rutas // GET /users - Devuelve todos los usuarios app.get('/users', (req: Request, res: Response) => { res.json(mockUsers); }); // GET /users/:id - Devuelve un usuario específico por ID app.get('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); // Obtiene el ID del parámetro de la URL const user = mockUsers.find((u) => u.id === userId); if (user) { res.json(user); } else { res.status(404).json({ message: 'Usuario no encontrado' }); } }); // POST /users - Crea un nuevo usuario (agrega a los datos de prueba) app.post('/users', (req: Request, res: Response) => { const newUser: User = { id: mockUsers.length + 1, // Generación de ID simple (no apta para producción) ...req.body, // Asume que el cuerpo de la solicitud contiene los datos del usuario (nombre, email) }; mockUsers.push(newUser); res.status(201).json(newUser); // Código de estado 201 Creado }); // PUT /users/:id - Actualiza un usuario existente app.put('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); const userIndex = mockUsers.findIndex(u => u.id === userId); if (userIndex === -1) { return res.status(404).json({ message: 'Usuario no encontrado' }); } const updatedUser: User = { id: userId, ...req.body // Asume que el cuerpo de la solicitud contiene los datos actualizados del usuario }; mockUsers[userIndex] = updatedUser; res.json(updatedUser); }); // DELETE /users/:id - Elimina un usuario app.delete('/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); const userIndex = mockUsers.findIndex(u => u.id === userId); if (userIndex === -1) { return res.status(404).json({ message: 'Usuario no encontrado' }); } mockUsers.splice(userIndex, 1); res.status(204).send(); // 204 Sin contenido (eliminación exitosa) }); app.listen(port, () => { console.log(`El servidor se está ejecutando en http://localhost:${port}`); }); ``` Mejoras y explicaciones clave: * **TypeScript:** Utiliza TypeScript para seguridad de tipos y una mejor organización del código. Las interfaces como `User` definen la estructura de tus datos. * **Express:** Utiliza Express.js, un popular framework web de Node.js, para manejar rutas y solicitudes. * **CORS:** Incluye el middleware `cors`. Esto es *esencial* si tu frontend se está ejecutando en un puerto diferente al de tu backend (lo cual es muy común durante el desarrollo). **Importante:** Para producción, debes configurar CORS para que solo permita solicitudes desde tu dominio frontend específico. La llamada `cors()` sin argumentos permite *todos* los orígenes, lo cual es inseguro para producción. * **Body Parser:** Utiliza el middleware `body-parser` para analizar los cuerpos de las solicitudes JSON. Esto es necesario para acceder a los datos enviados en las solicitudes POST y PUT. * **Manejo de rutas más claro:** Utiliza `req.params.id` para obtener el ID de la URL en la ruta `GET /users/:id`. Incluye manejo de errores (404 No encontrado) si no se encuentra el usuario. * **Ruta POST:** La ruta `POST /users` ahora crea un nuevo usuario, lo agrega al array `mockUsers` y devuelve el nuevo usuario con un código de estado 201 Creado. Utiliza una generación de ID muy simple; en una aplicación real, usarías una base de datos para generar ID únicos. * **Ruta PUT:** La ruta `PUT /users/:id` actualiza un usuario existente. Encuentra el usuario por ID, actualiza las propiedades con los datos del cuerpo de la solicitud y devuelve el usuario actualizado. Incluye manejo de errores (404 No encontrado). * **Ruta DELETE:** La ruta `DELETE /users/:id` elimina un usuario. Encuentra el usuario por ID, lo elimina del array y devuelve un código de estado 204 Sin contenido. Incluye manejo de errores (404 No encontrado). * **Códigos de estado:** Utiliza códigos de estado HTTP apropiados (200 OK, 201 Creado, 204 Sin contenido, 404 No encontrado) para indicar el éxito o el fracaso de las solicitudes. * **Manejo de errores:** Incluye manejo de errores básico para escenarios de "usuario no encontrado". Deberás ampliar esto para un manejo de errores más robusto en una aplicación real. * **Comentarios:** Incluye comentarios para explicar el código. **Cómo usarlo:** 1. **Instala Node.js y npm:** Asegúrate de tener Node.js y npm (Node Package Manager) instalados. 2. **Crea un directorio de proyecto:** ```bash mkdir mock-mcp-server cd mock-mcp-server ``` 3. **Inicializa el proyecto:** ```bash npm init -y ``` 4. **Instala las dependencias:** ```bash npm install express cors body-parser typescript @types/express @types/node --save-dev ``` 5. **Configura TypeScript:** * Crea un archivo `tsconfig.json` en la raíz de tu proyecto: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "rootDir": "./", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["*.ts"], "exclude": ["node_modules"] } ``` 6. **Crea el archivo `index.ts`:** Copia el código TypeScript anterior en un archivo llamado `index.ts` en tu directorio de proyecto. 7. **Compila el TypeScript:** ```bash npx tsc ``` Esto creará un directorio `dist` con los archivos JavaScript compilados. 8. **Ejecuta el servidor:** ```bash node dist/index.js ``` Ahora tu servidor de prueba debería estar ejecutándose en `http://localhost:3000`. Puedes probarlo con herramientas como `curl`, Postman o haciendo solicitudes desde tu aplicación frontend. **Ejemplo de comandos `curl`:** * **Obtener todos los usuarios:** ```bash curl http://localhost:3000/users ``` * **Obtener el usuario con ID 2:** ```bash curl http://localhost:3000/users/2 ``` * **Crear un nuevo usuario:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"name": "New User", "email": "new.user@example.com"}' http://localhost:3000/users ``` * **Actualizar el usuario con ID 1:** ```bash curl -X PUT -H "Content-Type: application/json" -d '{"name": "Updated User", "email": "updated.user@example.com"}' http://localhost:3000/users/1 ``` * **Eliminar el usuario con ID 3:** ```bash curl -X DELETE http://localhost:3000/users/3 ``` **Consideraciones importantes para producción:** * **CORS:** Configura CORS *con mucho cuidado* para que solo permita solicitudes desde tus dominios frontend. Nunca uses `cors()` sin argumentos en producción. * **Autenticación/Autorización:** Esta plantilla no tiene autenticación ni autorización. Deberás agregar middleware para proteger tus rutas si estás manejando datos confidenciales. * **Persistencia de datos:** Los datos de prueba se almacenan en la memoria y se perderán cuando se reinicie el servidor. Para una aplicación real, deberás usar una base de datos (por ejemplo, MongoDB, PostgreSQL, MySQL). * **Manejo de errores:** Implementa un manejo de errores más robusto, incluyendo el registro y las respuestas de error adecuadas. * **Validación:** Valida los datos que recibes del cliente (por ejemplo, usando una biblioteca como `joi`) para evitar errores y vulnerabilidades de seguridad. * **Seguridad:** Sigue las mejores prácticas de seguridad para proteger tu servidor de ataques (por ejemplo, usando HTTPS, previniendo la inyección SQL, etc.). * **Escalabilidad:** Este servidor simple no está diseñado para un alto tráfico. Si necesitas manejar una gran cantidad de solicitudes, deberás considerar estrategias de escalamiento (por ejemplo, balanceo de carga, almacenamiento en caché). Esta plantilla proporciona una base sólida para construir un servidor de prueba. Recuerda adaptarlo a tus necesidades específicas y abordar las consideraciones de producción si lo estás utilizando en un entorno del mundo real.

Trading MCP Server

Enables fetching real-time stock prices from Yahoo Finance through Claude AI's interface. Allows users to query current market data for stocks using natural language commands.