Discover Awesome MCP Servers

desk-mcp

A desktop automation MCP server that enables AI agents to interact with Linux environments through screenshots, window inspection, and input simulation. It provides tools for mouse control, keyboard input, and screen capture using xdotool and XDG Desktop Portals.

doit-mcp-server

Here are a few ways to translate "MCP server for doit (pydoit)" into Spanish, depending on the context: **Option 1 (Most Literal):** * **Servidor MCP para doit (pydoit)** This is a direct translation and is perfectly understandable. "MCP" would likely remain as "MCP" since it's an acronym. **Option 2 (Slightly More Descriptive):** * **Servidor MCP para el sistema doit (pydoit)** This adds "sistema" (system) to clarify that "doit" is a system or tool. **Option 3 (If "MCP" needs explanation):** * **Servidor de gestión de procesos múltiples (MCP) para doit (pydoit)** This expands "MCP" to "gestión de procesos múltiples" (multiple process management) and then includes the acronym in parentheses. Use this if your audience is unlikely to know what "MCP" stands for. **Which option is best depends on your audience:** * If your audience is familiar with the term "MCP" in the context of `doit`, then **Option 1** is the most concise and appropriate. * If you want to be slightly more explicit, **Option 2** is a good choice. * If your audience is unlikely to know what "MCP" means, then **Option 3** is the best option. Therefore, I recommend **Servidor MCP para doit (pydoit)** unless you have reason to believe your audience won't understand "MCP".

Hyperliquid MCP Server v2

A Model Context Protocol server for Hyperliquid with integrated dashboard

Weather Java SSE Transport MCP Service

Here are a few ways to translate "Java Model Context Protocol SSE HTTP Server with Jetty" into Spanish, depending on the nuance you want to convey: **Option 1 (Most Literal and Common):** * **Servidor HTTP SSE con Jetty para Protocolo de Contexto de Modelo Java** * This is a direct translation, keeping the order relatively similar to the English. It's clear and understandable. **Option 2 (Slightly More Natural Flow):** * **Servidor HTTP SSE basado en Jetty para Protocolo de Contexto de Modelo Java** * "basado en Jetty" (based on Jetty) can sound a bit more natural than just "con Jetty" (with Jetty). **Option 3 (Emphasizing the Technology):** * **Servidor HTTP SSE implementado con Jetty para Protocolo de Contexto de Modelo Java** * "implementado con Jetty" (implemented with Jetty) emphasizes that Jetty is the technology used to build the server. **Breakdown of the Translation:** * **Java Model Context Protocol:** Protocolo de Contexto de Modelo Java * **SSE HTTP Server:** Servidor HTTP SSE * **with Jetty:** con Jetty / basado en Jetty / implementado con Jetty **Which one should you use?** I recommend **Option 1: Servidor HTTP SSE con Jetty para Protocolo de Contexto de Modelo Java** as a good starting point. It's clear, concise, and easily understood. If you want to emphasize that Jetty is the underlying technology, then **Option 3** is a good choice.

BugcrowdMCP

A high-performance Model Context Protocol server that provides secure, tool-based access to the Bugcrowd API, allowing for natural language interaction with bug bounty programs through various AI agent platforms.

Acknowledgments

Espejo de

UniMCP4CC

Enables Claude Code to directly control Unity Editor, supporting scene manipulation, component operations, asset management, prefab handling, and audio control through natural language commands.

MM Query

Enables querying and comparing products from MM's retail (B2C) and wholesale (B2B) platforms in Vietnam, including price comparisons, stock availability checks, and multi-store support with Vietnamese language integration.

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.

NetworkX Graph MCP Server

Enables creation and management of state/decision graphs using NetworkX, supporting directed graphs with conditional branches, edge ordering, path finding, and visualization through PNG exports or interactive web interface.

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.

Pokémon VGC Damage Calculator MCP Server

An MCP-compliant server that enables AI agents to perform accurate Pokémon battle damage calculations using the Smogon calculator, supporting comprehensive input handling for Pokémon stats, moves, abilities, and field conditions.

MCP All-in-One Server

A versatile MCP server providing tools for arithmetic operations, n8n webhook integration, and access to a customer support playbook resource. It also includes specialized prompt templates for converting webinar transcripts into engaging blog posts.

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.

ZiweiAI

紫微AI，是一个紫微斗数解盘AI应用。Ziwei AI is an AI application for Ziwei Doushu chart interpretation.紫微AIは、紫微斗数のチャート解読のためのAIアプリケーションです。

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.

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.

Todoist Meeting MCP

Connects Claude to Todoist for transforming meeting notes into actionable tasks with inferred due dates and priorities. It enables full task lifecycle management, including creating subtasks, listing projects, and completing tasks through natural language.

Trusted GMail MCP Server

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

Reddit MCP Server

Enables read-only access to Reddit for searching posts within specific subreddits using OAuth2 authentication. It allows users to search by query and sort results by relevance, popularity, or date.

Weather MCP Server

Enables AI assistants to retrieve real-time weather data and 5-day forecasts for any city using the OpenWeather API, supporting both metric and imperial units.

SEQ MCP Server

Enables LLMs to query and analyze logs from SEQ structured logging server with capabilities for searching events, retrieving event details, analyzing log patterns, and accessing saved searches.

MCP Servers Search

Enables discovery and querying of available MCP servers from the official repository. Supports searching by name, description, features, categories, and provides random server suggestions for exploration.

heap-seance

MCP server that provides 8 tools for Java memory leak investigation: \- Class histograms, GC pressure snapshots, JFR recordings, heap dumps, MAT leak suspects analysis, async-profiler allocation profiles \- Structured confidence-based verdicts (none/low/medium/high) requiring independent signal corroboration \- Designed for use inside Claude Code with two slash commands

ServiceDesk Plus MCP Server

A Model Context Protocol server for integrating with ServiceDesk Plus On-Premise that provides comprehensive CMDB functionality, allowing users to manage tickets, assets, software licenses, contracts, vendors, and administrative settings through natural language.

Harvest MCP Server

Provides MCP integration for Harvest's time tracking, project management, and invoicing functionality, enabling natural language interaction with Harvest API through tools for managing clients, time entries, projects, tasks, and users.

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.