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

Primeiro servidor MCP confiável executado no ambiente de execução confiável 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 a interação com a API da plataforma de música Audius, suportando operações de usuário, faixa e playlist através do Protocolo de Contexto de 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

Um servidor MCP emparelhado com uma extensão do Firefox que permite que clientes LLM controlem o navegador do usuário, com suporte para gerenciamento de abas, pesquisa no histórico e leitura de conteúdo.

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

Here's a basic MCP (Minimal, Complete, and Verifiable) server template in TypeScript for quick mock data, along with explanations to help you understand and adapt it: ```typescript // Dependencies import express, { Request, Response } from 'express'; import cors from 'cors'; // Optional, but useful for local development import bodyParser from 'body-parser'; // For parsing request bodies // Configuration const port = process.env.PORT || 3000; // Use environment variable or default to 3000 const app = express(); // Middleware app.use(cors()); // Enable CORS for all origins (for development - be careful in production) app.use(bodyParser.json()); // Parse JSON request bodies // Mock Data (Replace with your actual data) const mockData = [ { id: 1, name: 'Item 1', description: 'This is the first item.' }, { id: 2, name: 'Item 2', description: 'This is the second item.' }, { id: 3, name: 'Item 3', description: 'This is the third item.' }, ]; // Routes app.get('/items', (req: Request, res: Response) => { res.json(mockData); }); app.get('/items/:id', (req: Request, res: Response) => { const id = parseInt(req.params.id); // Convert ID to number const item = mockData.find(item => item.id === id); if (item) { res.json(item); } else { res.status(404).json({ message: 'Item not found' }); } }); app.post('/items', (req: Request, res: Response) => { const newItem = { id: mockData.length + 1, // Simple ID generation (not suitable for production) ...req.body, }; mockData.push(newItem); res.status(201).json(newItem); // 201 Created }); app.put('/items/:id', (req: Request, res: Response) => { const id = parseInt(req.params.id); const itemIndex = mockData.findIndex(item => item.id === id); if (itemIndex !== -1) { mockData[itemIndex] = { ...mockData[itemIndex], ...req.body, id: id }; // Update with request body res.json(mockData[itemIndex]); } else { res.status(404).json({ message: 'Item not found' }); } }); app.delete('/items/:id', (req: Request, res: Response) => { const id = parseInt(req.params.id); const itemIndex = mockData.findIndex(item => item.id === id); if (itemIndex !== -1) { mockData.splice(itemIndex, 1); res.status(204).send(); // 204 No Content (successful deletion) } else { res.status(404).json({ message: 'Item not found' }); } }); // Start the server app.listen(port, () => { console.log(`Server listening on port ${port}`); }); ``` **Explanation:** 1. **Dependencies:** - `express`: The core web framework for Node.js. - `cors`: Middleware to enable Cross-Origin Resource Sharing (CORS). Crucial for allowing your frontend (running on a different port) to access the server. **Important:** In production, you should configure CORS to only allow specific origins for security. - `body-parser`: Middleware to parse the body of incoming requests. Specifically, `bodyParser.json()` parses JSON data. 2. **Configuration:** - `port`: Sets the port the server will listen on. It tries to use the `PORT` environment variable (useful for deployment) and defaults to 3000 if the environment variable isn't set. - `app = express()`: Creates an Express application instance. 3. **Middleware:** - `app.use(cors())`: Enables CORS for all origins. **Use with caution in production!** Configure it properly. - `app.use(bodyParser.json())`: Tells Express to use the `body-parser` middleware to parse JSON request bodies. This is necessary so you can access data sent in the body of `POST`, `PUT`, and `PATCH` requests. 4. **Mock Data:** - `mockData`: This is where you define your sample data. It's a simple JavaScript array of objects. **Replace this with your actual mock data.** You can load this data from a file (e.g., a JSON file) if you have a lot of data. 5. **Routes:** - `app.get('/items', ...)`: Defines a route that handles `GET` requests to `/items`. It returns the entire `mockData` array as a JSON response. - `app.get('/items/:id', ...)`: Defines a route that handles `GET` requests to `/items/:id`, where `:id` is a route parameter. It extracts the `id` from the URL, finds the corresponding item in `mockData`, and returns it as a JSON response. If the item is not found, it returns a 404 (Not Found) error. - `app.post('/items', ...)`: Handles `POST` requests to `/items`. It creates a new item by taking the data from the request body (`req.body`), assigning it a new ID, adding it to the `mockData` array, and returning the new item with a 201 (Created) status code. - `app.put('/items/:id', ...)`: Handles `PUT` requests to `/items/:id`. It updates an existing item. It finds the item by ID, merges the data from the request body into the existing item, and returns the updated item. If the item is not found, it returns a 404 error. - `app.delete('/items/:id', ...)`: Handles `DELETE` requests to `/items/:id`. It deletes an item. It finds the item by ID, removes it from the `mockData` array, and returns a 204 (No Content) status code. 6. **Start the Server:** - `app.listen(port, ...)`: Starts the Express server and listens for incoming requests on the specified port. The callback function logs a message to the console indicating that the server is running. **How to Use:** 1. **Install Node.js and npm:** Make sure you have Node.js and npm (Node Package Manager) installed. 2. **Create a Project Directory:** Create a new directory for your project. 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. **Create `tsconfig.json`:** Create a `tsconfig.json` file in your project root to configure the TypeScript compiler. A basic configuration would be: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` 6. **Create `src/index.ts`:** Create a directory named `src` and save the TypeScript code above as `src/index.ts`. 7. **Compile the TypeScript:** ```bash npx tsc ``` This will compile your TypeScript code into JavaScript files in the `dist` directory. 8. **Run the Server:** ```bash node dist/index.js ``` Or, if you want to use `ts-node` for direct execution (without compiling first, useful for development): ```bash npm install -g ts-node # Install globally (if you haven't already) ts-node src/index.ts ``` 9. **Test the API:** Use a tool like `curl`, `Postman`, or a browser to test your API endpoints. For example: - `GET http://localhost:3000/items` - `GET http://localhost:3000/items/1` - `POST http://localhost:3000/items` (with a JSON body) **Key Improvements and Considerations:** * **TypeScript:** Using TypeScript provides type safety and helps catch errors early. * **CORS:** `cors` is essential for local development when your frontend is running on a different port. **Configure CORS properly for production!** Don't use `cors()` without any options in a production environment. * **Error Handling:** The example includes basic error handling (e.g., 404 Not Found). You should add more robust error handling for a production application. * **ID Generation:** The ID generation in the `POST` route is very basic and not suitable for production. Use a proper ID generation strategy (e.g., UUIDs, database auto-increment). * **Data Persistence:** This example uses in-memory data. For a real application, you'll need to connect to a database (e.g., MongoDB, PostgreSQL). * **Validation:** You should validate the data in the request body to ensure it's in the correct format and meets your requirements. Libraries like `joi` or `express-validator` can help with this. * **Environment Variables:** Use environment variables for configuration (e.g., database connection strings, API keys). * **Logging:** Add logging to your application to help with debugging and monitoring. * **Testing:** Write unit tests and integration tests to ensure your API is working correctly. * **Asynchronous Operations:** For more complex operations (e.g., database access), use asynchronous functions (`async/await`) to avoid blocking the event loop. **Portuguese Translation of Key Terms:** * **Server:** Servidor * **Template:** Modelo * **Mock Data:** Dados simulados / Dados de teste * **TypeScript:** TypeScript (the name remains the same) * **Dependencies:** Dependências * **Configuration:** Configuração * **Middleware:** Middleware (the name remains the same) * **Routes:** Rotas * **Request:** Requisição * **Response:** Resposta * **Port:** Porta * **Error:** Erro * **Not Found:** Não encontrado * **Created:** Criado * **No Content:** Sem conteúdo * **Environment Variables:** Variáveis de ambiente * **Logging:** Registro (de logs) * **Testing:** Teste * **Asynchronous:** Assíncrono This template provides a solid foundation for building a mock API server in TypeScript. Remember to adapt it to your specific needs and add the necessary features for your application.

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.