Discover Awesome MCP Servers

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 a focus on including common "batteries" (features and libraries) for a more complete experience. This will be a simplified example, and you'll need to expand upon it for a fully functional server. **Conceptual Outline** 1. **Project Setup:** Initialize a TypeScript project with necessary dependencies. 2. **Networking:** Establish a TCP server to listen for incoming Minecraft client connections. 3. **Protocol Handling:** Implement the Minecraft protocol (MCP) handshake, status, login, and play phases. This is the most complex part. 4. **Data Structures:** Define data structures for players, worlds, chunks, entities, etc. 5. **Game Logic:** Implement basic game logic (e.g., player movement, block placement, chat). 6. **Command Handling:** Add a system for server commands. 7. **Logging:** Implement logging for debugging and monitoring. 8. **Configuration:** Load server configuration from a file. **Code Snippets (Illustrative)** **1. Project Setup (using `npm` and `ts-node`)** ```bash mkdir minecraft-server cd minecraft-server npm init -y npm install typescript ts-node @types/node ws bufferutil utf-8-validate --save-dev npm install minecraft-protocol --save npx tsc --init ``` * `minecraft-protocol`: A popular library for handling the Minecraft protocol. * `ws`: A WebSocket library (useful if you want to support WebSockets for clients). * `bufferutil` and `utf-8-validate`: Native dependencies for `ws` to improve performance. * `@types/node`: TypeScript definitions for Node.js. **2. `tsconfig.json` (Example)** ```json { "compilerOptions": { "target": "es2020", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` **3. `src/index.ts` (Basic Server Setup)** ```typescript import * as net from 'net'; import { createServer } from 'minecraft-protocol'; import { Server, Client } from 'minecraft-protocol'; const serverOptions = { 'online-mode': false, // Disable online authentication for testing host: '0.0.0.0', port: 25565, version: '1.19.4', // Or your desired Minecraft version maxPlayers: 10, motd: 'My TypeScript Minecraft Server' }; const server: Server = createServer(serverOptions); server.on('login', (client: Client) => { console.log(`Client connected: ${client.username}`); client.on('end', () => { console.log(`Client disconnected: ${client.username}`); }); client.on('error', (err) => { console.error(`Client error: ${err}`); }); // Send initial game data (e.g., join game packet, player position) client.write('login', { entityId: 1, isHardcore: false, gameMode: 0, previousGameMode: -1, worldNames: ['minecraft:overworld'], dimensionCodec: { dimension: { type: 'compound', name: 'dimension', value: { type: 'list', name: 'value', value: { type: 'compound', value: { name: { type: 'string', value: 'minecraft:overworld' }, id: { type: 'int', value: 0 }, element: { type: 'compound', value: { fixed_time: { type: 'long', value: 6000 }, has_skylight: { type: 'byte', value: 1 }, has_ceiling: { type: 'byte', value: 0 }, ultrawarm: { type: 'byte', value: 0 }, natural: { type: 'byte', value: 1 }, ambient_light: { type: 'float', value: 0.0 }, infiniburn: { type: 'string', value: 'minecraft:infiniburn_overworld' }, respawn_anchor_works: { type: 'byte', value: 0 }, has_raids: { type: 'byte', value: 0 }, is_spooky: { type: 'byte', value: 0 }, is_monster_generation_suppressed: { type: 'byte', value: 0 }, is_piglin_safe: { type: 'byte', value: 0 }, bed_works: { type: 'byte', value: 1 }, effects: { type: 'string', value: 'minecraft:overworld' }, min_y: { type: 'int', value: -64 }, height: { type: 'int', value: 384 }, logical_height: { type: 'int', value: 256 }, coordinate_scale: { type: 'double', value: 1.0 }, piglin_safe: { type: 'byte', value: 0 }, monster_spawn_block_light_limit: { type: 'int', value: 0 }, monster_spawn_light_level: { type: 'int', value: 7 } } } } } } } }, dimension: 'minecraft:overworld', seed: BigInt(0), maxPlayers: serverOptions.maxPlayers, hardcore: false, isFlat: false, enableRespawnScreen: true, isDebug: false, isSuperflat: false }); client.write('position', { x: 0, y: 64, z: 0, yaw: 0, pitch: 0, flags: 0, teleportId: 0 }); client.write('chat', { message: JSON.stringify({ translate: 'chat.type.announcement', with: [ 'Server', 'Welcome to the server!' ] }), position: 0, sender: '00000000-0000-0000-0000-000000000000' }); client.on('chat', (packet) => { console.log(`[CHAT] ${client.username}: ${packet.message}`); server.broadcast(JSON.stringify({ translate: 'chat.type.text', with: [ client.username, packet.message ] }), 'chat'); }); }); server.on('listening', () => { console.log(`Server listening on ${serverOptions.host}:${serverOptions.port}`); }); server.on('error', (err) => { console.error(`Server error: ${err}`); }); ``` **4. Running the Server** ```bash npx ts-node src/index.ts ``` **Explanation and "Batteries Included" Considerations** * **`minecraft-protocol`:** This library handles the low-level details of the Minecraft protocol, making it much easier to work with. It parses packets, serializes data, and handles compression. * **Configuration:** Instead of hardcoding server options, load them from a JSON or YAML file using libraries like `js-yaml` or `config`. This allows you to easily change settings without recompiling. * **Logging:** Use a proper logging library like `winston` or `pino` for structured logging. This makes it easier to filter, search, and analyze logs. * **Command Handling:** Implement a command system. You can use a simple string parsing approach or a more sophisticated library like `commander.js` to define commands and arguments. * **World Generation:** For a real server, you'll need to generate or load world data. Consider using a library for procedural generation or loading existing Minecraft world files. * **Entity Management:** Create a system for managing entities (players, mobs, items). This will involve tracking their positions, properties, and interactions. * **Plugin System:** Design your server with a plugin system in mind. This allows you to extend the server's functionality without modifying the core code. Consider using a dependency injection container like `tsyringe` to manage plugin dependencies. * **Database Integration:** If you need to store persistent data (e.g., player inventories, world data), integrate with a database like MongoDB, PostgreSQL, or SQLite. Use an ORM like TypeORM or Sequelize to simplify database interactions. * **Asynchronous Operations:** Use `async/await` and Promises to handle asynchronous operations (e.g., network I/O, database queries) efficiently. * **Error Handling:** Implement robust error handling to prevent the server from crashing due to unexpected errors. Use `try/catch` blocks and logging to catch and handle errors gracefully. * **Performance Optimization:** Profile your server and identify performance bottlenecks. Use techniques like caching, object pooling, and multithreading to improve performance. Consider using a profiler like `clinic.js`. * **Security:** Implement security measures to protect your server from attacks. This includes validating user input, preventing unauthorized access, and protecting against denial-of-service attacks. **Example: Configuration Loading (using `config`)** 1. **Install:** `npm install config --save` 2. **Create `config/default.json`:** ```json { "server": { "onlineMode": false, "host": "0.0.0.0", "port": 25565, "version": "1.19.4", "maxPlayers": 10, "motd": "My Configured Server" } } ``` 3. **Modify `src/index.ts`:** ```typescript import * as net from 'net'; import { createServer } from 'minecraft-protocol'; import { Server, Client } from 'minecraft-protocol'; import config from 'config'; const serverConfig = config.get('server') as any; // Type assertion const serverOptions = { 'online-mode': serverConfig.onlineMode, host: serverConfig.host, port: serverConfig.port, version: serverConfig.version, maxPlayers: serverConfig.maxPlayers, motd: serverConfig.motd }; // ... rest of the server code using serverOptions ... ``` **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and changes with each version. Using a library like `minecraft-protocol` is highly recommended. * **Game Logic:** Implementing game logic (world generation, entity behavior, etc.) is a significant undertaking. * **Performance:** Minecraft servers can be resource-intensive. Pay attention to performance optimization. * **Security:** Protect your server from exploits and attacks. This is a starting point. Building a full-fledged Minecraft server is a complex project that requires a significant amount of time and effort. 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-to-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.