Discover Awesome MCP Servers
Extend your agent with 84,517 capabilities via MCP servers.
- All84,517
- Developer Tools3,867
- Search1,714
- Research & Data1,557
- AI Integration Systems229
- Cloud Platforms219
- Data & App Analysis181
- Database Interaction177
- Remote Shell Execution165
- Browser Automation147
- Databases145
- Communication137
- AI Content Generation127
- OS Automation120
- Programming Docs Access109
- Content Fetching108
- Note Taking97
- File Systems96
- Version Control93
- Finance91
- Knowledge & Memory90
- Monitoring79
- Security71
- Image & Video Processing69
- Digital Note Management66
- AI Memory Systems62
- Advanced AI Reasoning59
- Git Management Tools58
- Cloud Storage51
- Entertainment & Media43
- Virtualization42
- Location Services35
- Web Automation & Stealth32
- Media Content Processing32
- Calendar Management26
- Ecommerce & Retail18
- Speech Processing18
- Customer Data Platforms16
- Travel & Transportation14
- Education & Learning Tools13
- Home Automation & IoT13
- Web Search Integration12
- Health & Wellness10
- Customer Support10
- Marketing9
- Games & Gamification8
- Google Cloud Integrations7
- Art & Culture4
- Language Translation3
- Legal & Compliance2
myscheme
Enables searching live myScheme.gov.in schemes by eligibility, keyword, and detail lookup through MCP tools.
SEFAZ PB: IPVA
MCP server for querying IPVA (vehicle tax) information from the official SEFAZ PB (Paraíba state) source, read-only, with prepaid per-query pricing.
Mediora MCP Server
Exposes a doctor-reviewed medical catalog of blood-test markers, clinical conditions, and patient symptoms as MCP tools in English, Russian, and Hebrew, supporting both anonymous queries and authenticated patient data analysis.
mcp-brasil
Connects AI agents to 28 Brazilian public APIs, providing over 200 tools to access data on economy, legislation, transparency, and the judiciary. It enables complex queries and cross-referencing of government datasets like IBGE, the Central Bank, and the National Congress through natural language.
kube-MCP
A Model Context Protocol server for Kubernetes that provides full resource coverage and advanced troubleshooting tools via HTTP chunked streaming. It enables users to manage clusters and diagnose complex issues like pod crashloops through specialized prompts and standard kubectl-like operations.
Windows MCP Server
An enterprise-grade automation server that enables AI assistants to control Windows PCs through intelligent UI element detection, window management, and system-level commands. It leverages the Windows UI Automation tree for reliable interaction, providing tools for mouse/keyboard control, application management, and high-performance screen state analysis.
orizn-visa-mcp
Check visa requirements for 39,585 passport-destination pairs in 15 languages. Returns visa type, required documents, application process, and travel tips from 136 official government sources. Free quick checks without API key.
mcp-init
Okay, here's a basic outline and code snippets to get you started with creating a new Minecraft Protocol (MCP) server in TypeScript, with some common "batteries included" features. This will be a simplified example, focusing on the core concepts. Building a full-fledged MCP server is a complex undertaking. **Conceptual Outline** 1. **Project Setup:** Initialize a TypeScript project with necessary dependencies. 2. **Networking:** Listen for incoming TCP connections on a specified port. 3. **Protocol Handling:** Parse and serialize Minecraft packets according to the MCP specification. 4. **Authentication (Optional):** Implement authentication to verify players. 5. **World Management (Simplified):** Handle basic world data (e.g., a simple flat world). 6. **Player Management:** Track connected players and their data. 7. **Game Logic (Basic):** Implement some basic game logic (e.g., chat). **1. Project Setup** ```bash mkdir mcp-server cd mcp-server npm init -y npm install typescript ts-node ws @types/ws --save-dev npx tsc --init # Creates tsconfig.json ``` **tsconfig.json (Example)** ```json { "compilerOptions": { "target": "es2020", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "sourceMap": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` **2. Networking (src/index.ts)** ```typescript import * as WebSocket from 'ws'; const PORT = 25565; // Default Minecraft port const wss = new WebSocket.Server({ port: PORT }, () => { console.log(`Server started on port ${PORT}`); }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { // Handle incoming messages (Minecraft packets) here console.log(`Received: ${message}`); // Example: Echo back the message ws.send(`Server received: ${message}`); }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); }); console.log('Starting server...'); ``` **3. Protocol Handling (Simplified - Example)** This is where things get complex. You'll need to understand the Minecraft protocol. Libraries exist to help with this, but for a basic example, let's assume a simple text-based protocol for chat. ```typescript // src/protocol.ts (Example) export function parsePacket(data: string): any { // In a real implementation, you'd parse binary data // according to the Minecraft protocol. This is a placeholder. try { return JSON.parse(data); // Assuming JSON for simplicity } catch (e) { console.error("Error parsing packet:", e); return null; } } export function createPacket(type: string, data: any): string { // In a real implementation, you'd serialize data into // the Minecraft protocol's binary format. This is a placeholder. return JSON.stringify({ type, data }); // Assuming JSON for simplicity } ``` **4. Integrating Protocol Handling (Back in src/index.ts)** ```typescript import * as WebSocket from 'ws'; import { parsePacket, createPacket } from './protocol'; // Import protocol functions const PORT = 25565; const wss = new WebSocket.Server({ port: PORT }, () => { console.log(`Server started on port ${PORT}`); }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { // Handle incoming messages (Minecraft packets) here console.log(`Received: ${message}`); const packet = parsePacket(message.toString()); // Convert to string and parse if (packet) { switch (packet.type) { case "chat": console.log(`Received chat message: ${packet.data.message}`); // Broadcast the message to all clients (very basic) wss.clients.forEach(client => { if (client !== ws && client.readyState === WebSocket.OPEN) { const broadcastPacket = createPacket("chat", { message: `[${packet.data.username}]: ${packet.data.message}` }); client.send(broadcastPacket); } }); break; default: console.log("Unknown packet type:", packet.type); } } else { console.log("Invalid packet received."); } }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); }); console.log('Starting server...'); ``` **5. Running the Server** ```bash npm run build # Compiles TypeScript to JavaScript (creates the 'dist' folder) node dist/index.js # Runs the server ``` **Important Considerations and "Batteries Included" Ideas** * **Minecraft Protocol Library:** Use a library like `prismarine-protocol` (Node.js) to handle the complex binary protocol. This is *essential* for a real server. Install with `npm install prismarine-protocol`. This will significantly change how you handle packets. * **Authentication:** Implement proper authentication using the Minecraft account system. This involves verifying player UUIDs and signatures. Libraries can help with this. * **World Generation:** Create a world generator. You can start with a simple flat world, but eventually, you'll want more complex terrain. Consider using a library for noise generation. * **Entity Management:** Track entities (players, mobs, items) in the world. * **Chunk Management:** Load and unload chunks of the world as players move around. * **Command System:** Implement a command system for server administration. * **Plugin System:** Design your server to be extensible with plugins. * **Logging:** Use a proper logging library (e.g., `winston`) for debugging and monitoring. * **Configuration:** Use a configuration file (e.g., JSON or YAML) to store server settings. * **Error Handling:** Implement robust error handling to prevent crashes. * **Concurrency:** Use asynchronous programming (async/await) to handle multiple clients efficiently. * **Data Storage:** Use a database (e.g., MongoDB, PostgreSQL) to store player data, world data, and other persistent information. **Example using `prismarine-protocol` (Illustrative - Requires Significant Adaptation)** ```typescript import * as WebSocket from 'ws'; import { createServer } from 'minecraft-protocol'; const PORT = 25565; const server = createServer({ 'online-mode': false, // Disable authentication for testing port: PORT, version: '1.18.2' // Or your desired Minecraft version }); server.on('login', (client) => { console.log(`${client.username} connected`); client.on('packet', (packet, meta) => { if (meta.name === 'chat') { console.log(`${client.username}: ${packet.message}`); // Broadcast the chat message to all other clients server.clients.forEach((otherClient) => { if (otherClient !== client) { otherClient.write('chat', { message: `<${client.username}> ${packet.message}`, position: 0, // Chat box sender: '00000000-0000-0000-0000-000000000000' // Server UUID }); } }); } }); client.on('end', () => { console.log(`${client.username} disconnected`); }); // Send initial game data (e.g., world information) // This is a very simplified example client.write('login', { entityId: 123, isHardcore: false, gameMode: 0, // Survival previousGameMode: -1, worldNames: ['minecraft:overworld'], dimensionCodec: { dimension: [], // Empty for now dimensionType: [] // Empty for now }, worldName: 'minecraft:overworld', hashedSeed: 0, maxPlayers: 20, viewDistance: 10, reducedDebugInfo: false, enableRespawnScreen: true, isDebug: false, isFlat: true }); client.write('position', { x: 0, y: 64, z: 0, yaw: 0, pitch: 0, flags: 0, teleportId: 0 }); client.write('entity_status', { entityId: 123, entityStatus: 24 // Set entity status to 24 (invisible) }); }); server.on('listening', () => { console.log(`Server listening on port ${PORT}`); }); server.on('error', (err) => { console.error('Server error:', err); }); ``` **Explanation of `prismarine-protocol` Example:** * **`createServer`:** Creates a Minecraft server instance. You configure the port, version, and whether to enable online mode (authentication). * **`server.on('login', ...)`:** This event is triggered when a client successfully connects and authenticates (or skips authentication if `online-mode` is false). * **`client.on('packet', ...)`:** This is the core of packet handling. `prismarine-protocol` parses the binary Minecraft packets for you. `meta.name` gives you the packet name (e.g., 'chat', 'position'). `packet` contains the packet data as a JavaScript object. * **`client.write(packetName, data)`:** This sends a packet to the client. `packetName` is the name of the packet (e.g., 'chat', 'position'), and `data` is the data to send. `prismarine-protocol` handles the serialization to the binary format. * **Initial Game Data:** The example sends a minimal set of packets to get the client into the game. This includes the login packet, position packet, and entity status packet. You'll need to send more data to create a proper game world. **Key Improvements with `prismarine-protocol`:** * **Binary Protocol Handling:** You don't have to manually parse and serialize binary data. * **Packet Definitions:** `prismarine-protocol` knows the structure of all Minecraft packets for the specified version. * **Easier Packet Manipulation:** You can work with packet data as JavaScript objects. **Next Steps:** 1. **Install `prismarine-protocol`:** `npm install minecraft-protocol` 2. **Study the `prismarine-protocol` Documentation:** Read the documentation carefully to understand how to use the library effectively. 3. **Implement World Generation:** Create a basic world generator. 4. **Handle Player Movement:** Process player movement packets and update their position in the world. 5. **Implement More Game Logic:** Add more game features, such as item handling, block breaking, and entity interactions. This is a starting point. Building a complete Minecraft server is a significant project. Good luck!
MCP Codebase Analyzer
Enables LLMs to explore codebases structurally via MCP tools for outlines, function sources, imports, complexity, git changes, and dead code detection, reducing token usage by avoiding raw file ingestion.
Recipes MCP
Wraps the TheMealDB API to search for recipes, get full meal details, random meal suggestions, and find recipes by ingredient.
Korean Stock MCP
Provides access to Korean stock market data, including stock listings, daily historical records, and 10-minute intraday candles via FinanceDataReader and Naver APIs. It enables users to search for stocks, retrieve detailed profiles, and calculate technical indicators locally.
Thoth MCP Server
Model Context Protocol (MCP) server for Thoth content creation platform. Enables AI assistants and tools to create and retrieve content through Thoth's API.
⚡️ mcpo
シンプルで安全な MCP から OpenAPI へのプロキシサーバー
cv-builder
Provides MCP tools for managing a CV as structured content, including a SQLite-backed snippet library with tools to list, create, update, and match job postings, compose role-tailored CV variants, and manage drafts.
rfcxml-mcp
A Model Context Protocol (MCP) server for structured understanding of RFC documents.
mcp-codestats
Enables fetching public Code::Stats user XP and activity data, including total XP, per-language breakdowns, and recent coding activity.
FastMCP Google Docs Manager
Enables interaction with Google Docs through a FastMCP server, allowing users to list, read, and create documents. It leverages the Google Docs and Drive APIs to provide seamless document management via Gemini-CLI.
mcp-patent
MCP server for USPTO patent prior-art search, enabling keyword search, ranking, and date filtering via Claude, Cursor, or Windsurf.
bsc-dex-spread
Provides a tool to get real-time cross-DEX price and spread data for PancakeSwap v2 and v3 on BSC, with a pay-per-call model settled via x402.
overleaf-mcp
Enables AI agents to read, edit, and compile LaTeX documents in Overleaf projects with tracked changes via the Model Context Protocol.
Web Search MCP Server
Enables AI agents to search the web and extract content using multiple search providers, with caching, retry logic, and options for JavaScript-heavy page rendering.
mcp-quotable
Wraps the Quotable API to search for quotes by keyword or phrase, returning matching quotes with author names and topic tags.
mcp-buzzword-density
Analyzes text for overused industry jargon, returning buzzword count, density score, severity level, and flagged terms. Optionally provides humorous critique in roast mode.
crypto-portfolio
Enables real-time cryptocurrency prices, search, and market data via the CoinGecko API without requiring an API key.
kwjm-mcp
MCP server that provides unified access to text, image, and video generation models via the kwjm.com API, with model discovery, capability validation, and clear error explanations.
MarkLogic MCP Server
MarkLogic のためのモデルコンテキストプロトコルサーバー。クライアントインターフェースを通して、CRUD操作とドキュメントのクエリ機能を有効にします。
wordpress-mcp
An MCP server for day-to-day WordPress maintenance across multiple client sites.
StatFlow
Enables AI assistants to perform statistical analysis on MySQL databases, generating formatted Excel reports with t-tests and effect sizes, and creating thesis-quality Word documents with AI-powered insights.
MCPishCode
A self-hosted MCP server that brings a Codex-style coding workflow to ChatGPT, allowing it to read, edit, search, and run code in your local projects.
Aionis MCP Server
Bridges Aionis execution memory to MCP clients, enabling governed memory context for AI agents.