Discover Awesome MCP Servers

Harmonic MCP Server

Provides tools to interact with the Harmonic AI API for company and person enrichment, specifically focusing on venture capital deal flow. It enables users to search for companies using natural language, find similar businesses, and retrieve detailed information on organizations and individuals.

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!

GitHub GraphQL API MCP

Enables querying and exploring the GitHub GraphQL API schema and executing optimized GraphQL queries to retrieve precise GitHub data (repositories, issues, PRs, users) with reduced token consumption.

MCP Tools

An MCP (Model Context Protocol) server implementation using HTTP SSE (Server-Sent Events) connections with built-in utility tools including echo, time, calculator, and weather query functionality.

Zerodha Trading Bot MCP

An automated trading bot that interfaces with Zerodha to execute stock trades, manage positions, and access market information through natural language commands.

Data Analysis MCP Server

Provides comprehensive statistical analysis tools for industrial data including time series analysis, correlation calculations, stationarity tests, outlier detection, causal analysis, and forecasting capabilities. Enables data quality assessment and statistical modeling through a FastAPI-based MCP architecture.

MCP Ctl

プラットフォームを跨いで、全ての Minecraft: Java Edition サーバーを管理するためのパッケージマネージャー

Agoragentic

Agent-to-agent marketplace where AI agents discover, invoke, and pay for services from other agents using USDC on Base L2. 72+ services, free tools, x402 micropayments.

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.

Aareguru MCP Server

Provides Swiss Aare river swimming data including water temperature, flow rates, safety assessments, and forecasts. Enables AI assistants to answer questions about current conditions, compare cities, and provide safety recommendations based on official BAFU thresholds.

OpenProject MCP Server

Enables AI agents to interact with OpenProject's APIv3 for autonomous project management, including task tracking, member administration, and project configuration. It supports comprehensive operations for managing work packages, projects, and reference data like statuses and priorities.

ID Generator MCP

Provides AI assistants with capabilities to generate collision-resistant unique identifiers using UUID v4 and CUID2 algorithms.

mcp-openmsx

This MCP provides comprehensive tools and resources for MSX software development, testing, and automation through openMSX emulator.

Schwab MCP Server

A read-only MCP server that provides access to Charles Schwab account data and market information, including portfolio positions, real-time quotes, options chains, price history, and account balances through AI assistants.

Pearch

Best people search engine that reduces the time spent on talent discovery

Basic MCP Server

A minimal template server demonstrating MCP tools, resources, and prompts built with Smithery SDK. Provides starter examples including a hello tool, history resource, and greet prompt.

Test MCP

テスト用のシンプルなMCPサーバー

Oracle DB Context

Provides contextual Oracle database schema information to AI assistants, enabling them to understand and work with large databases containing thousands of tables. Supports multi-database connections, smart schema caching, table lookups, and relationship mapping.

Get My Notion MCP Server

Provides access to a specific GitHub repository (my-notion) allowing AI assistants to browse files, read content, and track commit information. Enables real-time interaction with repository data through the GitHub API without authentication requirements.

trident-mcp

AI 3D model generation and post-processing MCP server — text/image/multiview-to-3D via Tripo, retopology, format conversion (GLB/FBX/OBJ/STL/USDZ), and stylization. Single Go binary, 10 tools.

Feifei Proxy MCP

A service that converts existing MCP protocols (stdio/sse) to streamable\_http transmission type, allowing compatibility between different MCP implementations.

Cloudflare Playwright MCP

A Model Control Protocol server that enables AI assistants to control a browser through tools for web automation tasks like navigation, typing, clicking, and taking screenshots.

iRacing Data MCP Server

Provides seamless access to iRacing's racing simulation data, enabling AI assistants to retrieve driver profiles, career statistics, and team information. It features automatic authentication and tools for real-time driver lookups and season performance analysis.

MCP MeloTTS Audio Generator

Enables AI assistants to convert text to high-quality speech audio using MeloTTS. Automatically splits long texts into segments, generates WAV files, and merges them using ffmpeg with support for multiple languages and customizable speech parameters.

QuantPlay MCP Server

Provides access to the QuantPlay trading API for managing broker accounts, tracking positions, and analyzing holdings. It enables users to interact with their trading data through MCP-compatible clients like Claude Desktop.

ABAP-ADT-API MCP-Server

An MCP server that enables seamless communication between ABAP systems and MCP clients using the ABAP Development Tools (ADT) API. It provides tools for managing ABAP objects, handling transport requests, and performing code analysis directly through MCP-compatible interfaces.

eFax to JSON MCP Server

Converts eFax documents (PDF, TIFF, CCD XML) from OpenText Fax Server Software into structured JSON format with OCR support, metadata extraction, and batch processing capabilities.

mcp-server-bash

Bash スクリプトで書かれた最小限の MCP サーバー

Alpaca MCP Server

MCP server that exposes Alpaca Market Data & Broker API as tools, enabling access to financial data like stock bars, assets, market days, and news through the Message Control Protocol.