Discover Awesome MCP Servers

MCP Predictive Market

Aggregates prediction market data from 5 major platforms (Manifold, Polymarket, Metaculus, PredictIt, Kalshi), enabling users to search markets, compare odds across platforms, detect arbitrage opportunities, and track predictions through natural language.

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.

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.

Audius MCP Server

Cho phép tương tác với API của nền tảng âm nhạc Audius, hỗ trợ các hoạt động liên quan đến người dùng, bài hát và danh sách phát thông qua Giao thức Ngữ cảnh Mô hình.

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.

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

This server is to precess files for LNR.

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アプリケーションです。

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.

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.

Finance MCP Server

A Model Context Protocol server built with FastMCP that provides financial data tools for AI agents, enabling them to access and analyze stock market information from Yahoo Finance through natural language queries.

mcp-hub

A self-hosted remote MCP server that provides reusable prompts and development conventions across various AI tools. It features a modular architecture for organizing and namespacing custom prompts to streamline AI-assisted coding workflows.

Facebook Ads Management Control Panel

A Node.js Express server that integrates with Facebook Marketing API to provide a platform for managing ad campaigns, analyzing performance, and receiving optimization recommendations.

GCP MCP

Enables AI assistants to interact with Google Cloud Platform resources through natural language queries. Supports querying and managing GCP services like Compute Engine, Cloud Storage, BigQuery, and more across multiple projects and regions.

bbkt

A Bitbucket CLI and MCP server written in Go for managing workspaces, repositories, pull requests, pipelines, issues, and source code. Supports stdio and HTTP transport.

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.

mcplex

An MCP server that bridges local Ollama models and ChromaDB vector memory to MCP clients like Claude Code. It enables local text generation, vision-based image analysis, and semantic memory storage without requiring external API keys.

Cube.js MCP Server

Enables AI assistants to query and analyze data from Cube.js analytics platforms, allowing natural language access to cubes, measures, dimensions, and complex analytics queries.

Hugging Face MCP Server

An MCP server that provides Hugging Face Hub API and Search endpoints through multiple transport protocols (STDIO, SSE, StreamableHTTP, and StreamableHTTPJson), enabling integration with AI model capabilities.

Acknowledgments

Gương của

Gmail MCP Server

Connects to Gmail accounts to search emails, retrieve full email content, and parse receipts from services like Swiggy, Zomato, and Uber with read-only access.

MCP Server Demo

A minimal Model Context Protocol server demo that exposes tools through HTTP API, including greeting, weather lookup, and HTTP request capabilities. Demonstrates MCP server implementation with stdio communication and HTTP gateway functionality.

YouTube Knowledge Base MCP

Builds a searchable knowledge base from YouTube video transcripts with hybrid semantic and keyword search. Allows LLM assistants to search, organize, and retrieve timestamped information from videos you've watched.

MCP Platform

A scalable execution platform that enables users to interact with HR, ERP, and DevOps domains through a chat interface powered by LlamaIndex and the Model Context Protocol. It provides a configuration-driven architecture for orchestrating LLM-suggested actions with authoritative tool execution and domain isolation.