Discover Awesome MCP Servers

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.

Minecraft Bedrock Education MCP

Enables controlling Minecraft Bedrock and Education Edition through natural language commands via WebSocket connection. Provides tools for player actions, world manipulation, building structures, camera control, and wiki integration for automated gameplay and educational scenarios.

MachineHearts

MCP server that gives AI agents the ability to discover, match with, and build relationships with other autonomous agents. Supports agent registration, matchmaking, messaging, shared goals, relationship lifecycle management, and real-time event subscriptions.

CodeGuard MCP Server

Provides centralized security instructions for AI-assisted code generation by matching context-aware rules to the user's programming language and file patterns. It ensures generated code adheres to security best practices without requiring manual maintenance of instruction files across individual repositories.

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.

djd-agent-score-mcp

Reputation scoring for AI agent wallets on Base. 9 tools for trust scores, fraud checks, blacklist lookups, leaderboard, badge generation, and agent registration with x402 payment verification.

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.

Access Context Manager API MCP Server

An MCP server that provides access to Google's Access Context Manager API, enabling management of service perimeters and access levels through natural language.

Godot MCP

Provides a comprehensive integration between LLMs and the Godot Engine, enabling AI assistants to intelligently manipulate project files, scripts, and the live editor. It supports advanced workflows including version-aware documentation querying, automated E2E game testing, and real-time visual context capture.

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.

databid

Agent-native company intelligence. AI agents search and retrieve structured, verified company context (certifications, capabilities, capacity, lead times) for manufacturing & supply chain via 5 MCP tools.

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.

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 (presumably meaning "Mock Control Panel" or similar) server template in TypeScript for quick mock data, along with explanations to help you understand and customize it: ```typescript // Dependencies import express, { Request, Response } from 'express'; import cors from 'cors'; // For handling Cross-Origin Resource Sharing 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; restrict in production) app.use(bodyParser.json()); // Parse JSON request bodies // Mock Data (Replace with your actual mock data) const mockData = { users: [ { id: 1, name: 'Alice', email: 'alice@example.com' }, { id: 2, name: 'Bob', email: 'bob@example.com' }, { id: 3, name: 'Charlie', email: 'charlie@example.com' }, ], products: [ { id: 'p1', name: 'Awesome Widget', price: 29.99 }, { id: 'p2', name: 'Super Gadget', price: 49.99 }, ], settings: { theme: 'dark', language: 'en', }, }; // Routes (API Endpoints) app.get('/api/users', (req: Request, res: Response) => { res.json(mockData.users); }); app.get('/api/users/:id', (req: Request, res: Response) => { const userId = parseInt(req.params.id); const user = mockData.users.find(u => u.id === userId); if (user) { res.json(user); } else { res.status(404).json({ message: 'User not found' }); } }); app.get('/api/products', (req: Request, res: Response) => { res.json(mockData.products); }); app.get('/api/settings', (req: Request, res: Response) => { res.json(mockData.settings); }); app.put('/api/settings', (req: Request, res: Response) => { // In a real application, you'd validate the request body. mockData.settings = req.body; // Update the mock data res.json(mockData.settings); // Return the updated settings }); // Start the Server app.listen(port, () => { console.log(`Server listening on port ${port}`); }); ``` **Explanation and How to Use It:** 1. **Dependencies:** - `express`: The core web framework for Node.js. Handles routing, middleware, and request/response processing. - `cors`: Enables Cross-Origin Resource Sharing. This is *essential* if your frontend (e.g., a React app) is running on a different port than your backend. In production, you should configure CORS to only allow specific origins. - `body-parser`: Parses the body of incoming requests. `bodyParser.json()` specifically parses JSON data. 2. **Configuration:** - `port`: Sets the port the server will listen on. It tries to read the `PORT` environment variable (useful for deployment) and defaults to 3000 if the environment variable isn't set. 3. **Middleware:** - `app.use(cors())`: Registers the CORS middleware. - `app.use(bodyParser.json())`: Registers the JSON body-parsing middleware. 4. **Mock Data:** - `mockData`: This is where you define your mock data. It's a simple JavaScript object. Replace the example data with your own. You can structure it however you need to match your API requirements. 5. **Routes (API Endpoints):** - `app.get('/api/users', ...)`: Defines a GET route for `/api/users`. When a client makes a GET request to this URL, the code inside the callback function will execute. - `req: Request, res: Response`: These are TypeScript types for the request and response objects. They provide type safety and autocompletion. - `res.json(mockData.users)`: Sends the `users` array from the `mockData` object as a JSON response. - `app.get('/api/users/:id', ...)`: Defines a GET route with a parameter (`:id`). The value of the `id` parameter is available in `req.params.id`. - `parseInt(req.params.id)`: Converts the `id` parameter (which is a string) to an integer. - `mockData.users.find(u => u.id === userId)`: Finds a user in the `users` array whose `id` matches the requested `userId`. - `res.status(404).json({ message: 'User not found' })`: Sends a 404 (Not Found) status code and a JSON error message if the user is not found. - `app.put('/api/settings', ...)`: Defines a PUT route to update settings. It reads the new settings from the request body (`req.body`) and updates the `mockData.settings` object. **Important:** In a real application, you would *always* validate the data in `req.body` before updating your data store. 6. **Start the Server:** - `app.listen(port, ...)`: Starts the Express server and listens for incoming requests on the specified port. **How to Run It:** 1. **Install Node.js and npm (or yarn/pnpm):** Make sure you have Node.js and npm (Node Package Manager) installed. 2. **Create a Project Directory:** ```bash mkdir mock-server cd mock-server ``` 3. **Initialize a TypeScript Project:** ```bash npm init -y # Creates a package.json file npm install -D typescript @types/node ts-node nodemon # Install TypeScript and related tools npx tsc --init # Creates a tsconfig.json file ``` 4. **Install Dependencies:** ```bash npm install express cors body-parser @types/express @types/cors @types/body-parser ``` 5. **Create `src/index.ts`:** Create a directory named `src` and put the TypeScript code above into a file named `index.ts` inside the `src` directory. 6. **Configure `tsconfig.json`:** Edit your `tsconfig.json` file to include these settings (or similar): ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true } } ``` 7. **Add a Start Script to `package.json`:** Add a `start` script to your `package.json` file: ```json { "name": "mock-server", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "nodemon src/index.ts", "build": "tsc", "serve": "node dist/index.js" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@types/body-parser": "^1.19.6", "@types/cors": "^2.8.17", "@types/express": "^4.17.24", "@types/node": "^20.11.20", "nodemon": "^3.1.0", "ts-node": "^10.9.2", "typescript": "^5.4.0" }, "dependencies": { "body-parser": "^1.20.2", "cors": "^2.8.5", "express": "^4.18.3" } } ``` 8. **Run the Server:** ```bash npm start ``` This will start the server using `nodemon`, which will automatically restart the server whenever you make changes to your TypeScript code. **How to Test It:** 1. **Open a web browser or use a tool like `curl` or Postman.** 2. **Make requests to the API endpoints:** - `http://localhost:3000/api/users` (GET) - Get all users - `http://localhost:3000/api/users/1` (GET) - Get user with ID 1 - `http://localhost:3000/api/products` (GET) - Get all products - `http://localhost:3000/api/settings` (GET) - Get settings - `http://localhost:3000/api/settings` (PUT) - Update settings (send a JSON body with the new settings) **Key Improvements and Considerations:** * **TypeScript:** Using TypeScript provides type safety, making your code more robust and easier to maintain. * **CORS:** CORS is crucial for allowing your frontend to access the backend if they are running on different origins (ports or domains). *Restrict* the allowed origins in production. * **Body Parsing:** `body-parser` is necessary to parse the JSON data sent in the request body for PUT, POST, and PATCH requests. * **Error Handling:** The example includes basic error handling (e.g., returning a 404 if a user is not found). You should add more comprehensive error handling in a real application. * **Validation:** *Always* validate the data you receive from the client (in `req.body`) before using it to update your mock data. This prevents unexpected errors and security vulnerabilities. Libraries like `joi` or `zod` are excellent for validation. * **Data Persistence:** This is a *mock* server, so the data is stored in memory. If you need to persist the data (e.g., across server restarts), you'll need to use a database (even a simple file-based database like JSONPlaceholder's `db.json` or SQLite). * **More Routes:** Add more routes as needed to mock your API. Consider using POST, PUT, PATCH, and DELETE methods for creating, updating, and deleting data. * **Authentication/Authorization:** For more realistic mocking, you might want to add basic authentication and authorization. You could use middleware to check for API keys or mock user authentication. * **Environment Variables:** Use environment variables (e.g., `process.env.PORT`) to configure your server for different environments (development, testing, production). * **Testing:** Write unit tests to ensure your mock server is working correctly. Libraries like `jest` and `supertest` are commonly used for testing Node.js applications. **Vietnamese Translation of Key Terms:** * **Mock Server:** Máy chủ giả lập / Máy chủ mô phỏng * **API Endpoint:** Điểm cuối API / Điểm truy cập API * **Request:** Yêu cầu * **Response:** Phản hồi * **Middleware:** Phần mềm trung gian * **Route:** Tuyến đường * **Port:** Cổng * **Environment Variable:** Biến môi trường * **Authentication:** Xác thực * **Authorization:** Phân quyền * **Validation:** Xác thực dữ liệu / Kiểm tra tính hợp lệ của dữ liệu This template provides a solid foundation for building a mock server in TypeScript. Remember to adapt it to your specific needs and add more features as required. Good luck!

ZiweiAI

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

Gong MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép Claude truy cập API của Gong để lấy bản ghi cuộc gọi và bản ghi (transcript) thông qua một giao diện tiêu chuẩn.

bizprint-mcp-server

Connect AI agents to physical printers. Print receipts, shipping labels, and packing slips to your existing BizPrint-connected printers from Claude and other MCP clients.

BLOT Nado MCP Server

Enables perpetuals trading on the Nado DEX via the Ink chain, featuring multi-wallet management and market data access. It supports automated strategies like pair trading and basis farming while earning DRIP rewards for all trades.

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.

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.

@networkselfmd/mcp

Expose a decentralized P2P agent as an MCP server so Claude Code and other AI tools can discover peers, create groups, and send encrypted messages without intermediaries.

Trusted GMail MCP Server

Máy chủ MCP đáng tin cậy đầu tiên chạy trên Môi trường Thực thi Tin cậy 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.

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.