Discover Awesome MCP Servers

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.

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.

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.

Things MCP Server

Integrates with Things 3 task management app on macOS via URL schemes, enabling creation, updating, deletion of todos and projects, navigation, search, and JSON batch imports.

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.

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.

LNR-server-02-cascading-failure-scenario-simulatio

This server is to precess files for LNR.

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.

Anyquery

Conecte-se a mais de 40 aplicativos com um único binário.

Weather MCP Server

Provides weather forecast and alert information for US locations using the National Weather Service API. Enables users to get detailed weather forecasts by coordinates and retrieve active weather alerts by state.

Vibe Coder MCP

Um servidor MCP que turbina assistentes de IA com ferramentas poderosas para desenvolvimento de software, permitindo pesquisa, planejamento, geração de código e estruturação de projetos através da interação em linguagem natural.

Generalized MCP Server

Dynamically exposes Python SDKs (Kubernetes, GitHub, Azure) through an agent-friendly gRPC interface. Enables interaction with cloud services and platforms using natural language by automatically converting SDK functionality into callable functions.

Riot Games API Documentation

Provides access to comprehensive Riot Games API documentation for League of Legends, Teamfight Tactics, Valorant, and Legends of Runeterra, including endpoint details, parameters, and response formats.

Knesset MCP Server

Servidor de Protocolo de Contexto de Modelo (MCP) para acessar a API de informações parlamentares do Knesset israelense.

MCP Iceberg Catalog

Servidor MCP para interagir com o catálogo Apache Iceberg a partir do Claude, permitindo a descoberta de data lake e a busca de metadados através de um prompt LLM.

OpenProject MCP Server

Enables interaction with self-hosted OpenProject instances through the MCP protocol, supporting CRUD operations for projects and tasks (work packages) with pagination and filtering capabilities.

GitHub MCP Server in Go

Uma implementação não oficial de um servidor MCP para GitHub em Go. Usado internamente na Metoro.

Firelinks MCP Server

Enables interaction with the Firelinks link shortening platform to create and manage short links, track click statistics, manage custom domains, and compare analytics periods through natural language.

Shanghai Disney MCP Server

Provides real-time ticket pricing and availability information for Shanghai Disney Resort through the Model Context Protocol. It enables LLMs to query sales status and specific costs for one-day and two-day passes.