Discover Awesome MCP Servers

obsidian-mcp

Give Claude (and any MCP client) real agent access to your Obsidian vault — graph traversal, Dataview queries, daily-note awareness, and more.

MCP Database Manager

Enables AI assistants to interact with and manage multiple database types (PostgreSQL, MySQL, SQLite, SQL Server, MongoDB, Redis) through natural language, supporting query analysis, schema management, data analysis, backup/restore, and security analysis.

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.

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.

Influship MCP

Enables AI-native creator discovery for influencer marketing, including creator search, lookalikes, profile lookup, and Instagram post transcript analysis.

FreightUtils MCP Server

AI agent access to 11 freight calculation and reference tools — LDM, CBM, chargeable weight, pallet fitting, ADR dangerous goods (2,939 entries), airline codes (6,352), HS codes (6,940), INCOTERMS, container specs, unit converter, and ADR 1.1.3.6 exemption calculator.

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.

quiz-it

Provides 100 IT/programming quiz questions with tools to retrieve questions by category, get random questions, check answers, and list categories, usable via Claude Desktop MCP or REST API.

pdf-reader-mcp

MCP server for extracting text from PDF files, supporting local files and URLs.

Browser Control MCP

Một máy chủ MCP kết hợp với một tiện ích mở rộng Firefox cho phép các ứng dụng LLM điều khiển trình duyệt của người dùng, hỗ trợ quản lý tab, tìm kiếm lịch sử và đọc nội dung.

admitad-mcp

Enables AI assistants to browse Admitad affiliate programs, discover product feeds, and search products directly from chat.

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.

io.github.stucchi/telnyx

Enables interaction with the Telnyx API for billing, phone numbers, and messaging.

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

caldera-mcp

Connects MCP-compatible AI clients to a MITRE Caldera adversary emulation platform, enabling natural language construction of attack scenarios, agent inspection, and operation management.

doit-mcp-server

Máy chủ MCP cho doit (pydoit)

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.

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.

DuckPond MCP Server

MCP server for multi-tenant DuckDB management with R2/S3 cloud storage, enabling AI agents to manage per-user databases with automatic cloud persistence.

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.

threadwork

A multi-agent collaboration tool for Claude Code that supports hot-swappable role YAML, persistent memory with SQLite and FTS5, and step-level replay in a single-file HTML viewer.

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

figma-docs-mcp

Local MCP server that transforms Figma documentation and business rules into a semantically searchable index, exposed as a tool for Claude Code to query via natural language.

Weather MCP Agent

Enables querying real-time weather data for Israeli cities through natural language, using Playwright to scrape weather2day and Gemini LLM to answer.