Discover Awesome MCP Servers

suno-mcp

A RunAPI MCP server for the Suno music generation models, enabling task creation (text-to-music, covers, mashups, etc.), polling, and pricing lookup through a single API key.

ctx4-ai

MCP server for portable context management across AI assistants, providing tools to store and retrieve persistent context, instructions, and execute sandboxed bash commands with automatic git commits, using OAuth 2.1 and magic link authentication.

Mapify MCP Server

Enables AI assistants to generate interactive mind maps from text, YouTube videos, and web content using Mapify's API.

CloudForge MCP Server

Enables AI assistants to visualize cloud architecture diagrams, generate and import Terraform HCL, and manage infrastructure resources directly from chat through the CloudForge platform.

Deepgram Async MCP Server

Enables asynchronous transcription of long audio and video files using Deepgram's Speech-to-Text API with features like speaker diarization, sentiment analysis, topic detection, and summarization without timeout issues.

MCP RAG System

A Retrieval-Augmented Generation system that enables uploading, processing, and semantic search of PDF documents using vector embeddings and FAISS indexing for context-aware question answering.

Data.gov.il MCP Server

Enables AI assistants to search, discover, and analyze thousands of datasets from Israel's national open data portal. It provides tools for querying government ministries, municipalities, and public bodies using the CKAN API.

YouTube MCP Server

Enables AI agents to extract YouTube video metadata and generate high-quality multilingual transcriptions with voice activity detection, supporting 99 languages with translation capabilities and intelligent caching.

MCP TS Quickstart

Okay, here's a guide to creating a build-less TypeScript quickstart for an MCP (presumably Minecraft Protocol) server implementation. This approach prioritizes speed of setup and iteration, sacrificing some performance and type-checking rigor in the process. **Be aware that this is for quick prototyping and experimentation, not production.** **Important Considerations:** * **Performance:** Running TypeScript directly without compilation is significantly slower than running compiled JavaScript. This is fine for small-scale testing, but not for handling many concurrent players. * **Type Checking:** You'll lose some of the benefits of TypeScript's static type checking at runtime. You'll need to be extra careful with your code. * **Module Resolution:** This approach relies on browser-style module resolution, which might not be ideal for larger projects. * **Error Handling:** Runtime errors might be less informative than compile-time errors. **Steps:** 1. **Project Setup:** * Create a new directory for your project: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Initialize a `package.json` file (you can accept the defaults): ```bash npm init -y ``` * Install `ts-node` and `typescript` as development dependencies: ```bash npm install --save-dev ts-node typescript ``` * Create a `tsconfig.json` file. This is important for configuring TypeScript's behavior, even if we're not explicitly compiling. A minimal configuration is sufficient: ```json { "compilerOptions": { "target": "esnext", "module": "esnext", "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Important to prevent ts-node from writing files to source directory }, "include": ["src/**/*"] } ``` **Explanation of `tsconfig.json` options:** * `target`: Specifies the ECMAScript target version. `esnext` is generally a good choice for modern environments. * `module`: Specifies the module system. `esnext` allows for modern `import` and `export` syntax. * `moduleResolution`: `node` tells TypeScript to use Node.js-style module resolution. * `esModuleInterop`: Enables interoperability between CommonJS and ES modules. This is often necessary when working with Node.js packages. * `forceConsistentCasingInFileNames`: Helps prevent issues with case-sensitive file systems. * `strict`: Enables all strict type-checking options. This is highly recommended for catching errors early. * `skipLibCheck`: Skips type checking of declaration files (`.d.ts`). This can speed up compilation, but might hide some errors. * `outDir`: Specifies the output directory for compiled JavaScript files. This is important even though we're not explicitly compiling, as `ts-node` might still attempt to write files. Setting it to "dist" prevents it from writing to the source directory. * `include`: Specifies the files to include in the compilation. Here, we include all TypeScript files in the `src` directory. * Create a `src` directory: ```bash mkdir src ``` 2. **Basic Server Implementation (src/index.ts):** ```typescript import net from 'net'; const PORT = 25565; // Default Minecraft port const server = net.createServer((socket) => { console.log(`Client connected: ${socket.remoteAddress}:${socket.remotePort}`); socket.on('data', (data) => { console.log(`Received data: ${data.toString()}`); // TODO: Implement Minecraft protocol handling here socket.write('Hello from the server!\n'); // Example response }); socket.on('end', () => { console.log(`Client disconnected: ${socket.remoteAddress}:${socket.remotePort}`); }); socket.on('error', (err) => { console.error(`Socket error: ${err}`); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); server.on('error', (err) => { console.error(`Server error: ${err}`); }); ``` **Explanation:** * **`net` module:** This is Node.js's built-in networking module. * **`createServer`:** Creates a TCP server. The callback function is executed for each new client connection. * **`socket`:** Represents the connection to a client. * **`socket.on('data', ...)`:** Handles data received from the client. This is where you'll need to implement the Minecraft protocol parsing and handling. * **`socket.write(...)`:** Sends data back to the client. * **`socket.on('end', ...)`:** Handles client disconnection. * **`socket.on('error', ...)`:** Handles socket errors. * **`server.listen(PORT, ...)`:** Starts the server listening on the specified port. * **`server.on('error', ...)`:** Handles server errors. 3. **Running the Server:** * Add a `start` script to your `package.json`: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "ts-node": "^10.9.2", "typescript": "^5.3.3" } } ``` * Run the server: ```bash npm start ``` You should see the message "Server listening on port 25565" in your console. 4. **Testing (Optional):** * You can use `telnet` or a simple TCP client to connect to the server and send data. For example: ```bash telnet localhost 25565 ``` Type some text and press Enter. You should see the server log the received data and send back "Hello from the server!". 5. **Next Steps (Implementing the Minecraft Protocol):** * **Understand the Minecraft Protocol:** This is the most important part. Refer to the official Minecraft protocol documentation (search for "Minecraft Protocol" on the Minecraft Wiki or other resources). It's complex and involves packet structures, compression, encryption, and state management. * **Packet Parsing and Serialization:** You'll need to implement code to parse incoming data into Minecraft packets and serialize outgoing packets into binary data. Consider using a library for this, but for a quickstart, you might want to start with manual parsing. * **State Management:** Keep track of the client's state (e.g., handshake status, login status, game state). * **Authentication:** Implement authentication if you want to require players to log in with their Minecraft accounts. * **Game Logic:** Start implementing the core game logic (e.g., handling player movement, block updates, chat messages). **Example of Basic Packet Handling (Illustrative - Requires More Detail):** ```typescript // src/index.ts (modified) import net from 'net'; const PORT = 25565; const server = net.createServer((socket) => { console.log(`Client connected: ${socket.remoteAddress}:${socket.remotePort}`); socket.on('data', (data) => { console.log(`Received data: ${data.toString('hex')}`); // Log raw data as hex // **VERY BASIC EXAMPLE - REPLACE WITH PROPER PROTOCOL PARSING** if (data.length > 0) { const packetId = data[0]; // First byte is often the packet ID switch (packetId) { case 0x00: // Example: Handshake packet ID console.log("Received Handshake packet"); // TODO: Parse the handshake packet data socket.write(Buffer.from([0x00, 0x00])); // Example response break; default: console.log(`Unknown packet ID: ${packetId}`); break; } } }); socket.on('end', () => { console.log(`Client disconnected: ${socket.remoteAddress}:${socket.remotePort}`); }); socket.on('error', (err) => { console.error(`Socket error: ${err}`); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); server.on('error', (err) => { console.error(`Server error: ${err}`); }); ``` **Important Notes:** * **Error Handling:** Add robust error handling to your code. Catch exceptions and log errors appropriately. * **Security:** Be aware of security vulnerabilities, especially when handling network data. Sanitize inputs and protect against common attacks. * **Libraries:** Consider using libraries for tasks like: * **Protocol Parsing:** Libraries specifically designed for parsing the Minecraft protocol. * **Data Compression:** Libraries for handling zlib compression (used in the Minecraft protocol). * **Encryption:** Libraries for handling encryption (used for authentication). * **Refactoring:** As your project grows, refactor your code to improve readability, maintainability, and performance. Consider using classes, interfaces, and modules to organize your code. This quickstart provides a basic foundation for building an MCP server in TypeScript without a build step. Remember that this approach is best suited for rapid prototyping and experimentation. For production environments, you'll need to compile your TypeScript code to JavaScript and optimize your code for performance. Good luck!

서울시 교통 데이터 MCP 서버

서울시 교통 데이터 MCP 서버 - 실시간 교통 정보, 대중교통, 따릉이 등의 데이터를 제공하는 MCP 서버

CloakBrowser MCP Server

A stealth browser automation MCP server that wraps CloakBrowser's patched Chromium to bypass bot detection, providing 22 tools for web navigation, interaction, and session management.

Nuclino MCP Server

Provides access to Nuclino content through structured search and retrieval tools.

notebooklm-mcp-multiprofile

Enables AI agents to manage Google NotebookLM notebooks, sources, and generate podcasts/videos through the MCP protocol, with support for multiple Google accounts.

My MCP

TO DO microsoft

Highrise MCP Server by CData

This read-only MCP Server allows you to connect to Highrise data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

eShipz Tracking MCP Server

A Model Context Protocol (MCP) server that provides shipment tracking functionality through the eShipz API. This server enables Claude Desktop to track packages across multiple carriers with intelligent, status-aware formatting.

SEC EDGAR Filings MCP Server

Enables AI assistants to download, convert (HTML to PDF), and parse SEC EDGAR filings into Markdown, supporting filing types like 8-K, 10-Q, 10-K, and DEF 14A with Docker deployment and rate limiting.

mac-apps-launcher

fork from https://github.com/JoshuaRileyDev/mac-apps-launcher

PitchLense MCP

Enables comprehensive AI-powered startup investment risk analysis across 9 categories including market, product, team, financial, customer, operational, competitive, legal, and exit risks. Provides structured risk assessments, peer benchmarking, and investment recommendations using Google Gemini AI.

MariaDB MCP Server

Enables AI assistants to interact with MariaDB databases through schema exploration, query execution, and database statistics. Includes security features like read-only mode, parameterized queries, and connection pooling with support for both JSON and Markdown output formats.

Outlook OAuth MCP Server

Enables interaction with Microsoft Outlook for managing emails and calendars through OAuth2 delegated access. It provides a stateless, spec-compliant server that allows users to authenticate and perform mail and calendar operations with their own Microsoft accounts.

Intercom MCP Server

An MCP server that exposes Intercom tools to Claude Desktop and sends a daily support report via email.

Regen Compute

Enables AI coding assistants to estimate session energy footprint and retire verified ecocredits on Regen Network, providing on-chain proof of regenerative contribution.

Vibe Marketing MCP

Provides AI clients with access to proven social media hooks, copywriting frameworks, KOL archetypes, and real-time trending content across platforms like Twitter, Instagram, LinkedIn, TikTok, YouTube, and Facebook to humanize and optimize marketing content.

filesystem-mcp

A TypeScript-based MCP server that implements a simple notes system, allowing users to create, access, and generate summaries of text notes via URIs and tools.

mastr-mcp-server

MCP server for the German energy market master data register (MaStR), enabling querying of energy units, actors, grid connections, and more via 21 SOAP and public tools.

MCP MySQL Server

A containerized server that allows interaction with MySQL databases through Model Context Protocol (MCP), enabling SQL query execution, schema retrieval, and table listing via natural language.

MIST - Model Intelligence System for Tasks

Empowers AI assistants with real-world capabilities including note management, Gmail integration, Google Calendar and Tasks management, and Git repository operations through the Model Context Protocol.

container-tag-finder

Enables AI agents to retrieve the latest semantic version tags for container images from Docker Hub, GHCR, Quay, and other OCI registries, allowing them to pin specific versions for reproducible deployments.

Forward MCP

Enables agents to purchase verified growth outcomes such as qualified leads, sales meetings, and SEO content, with payment only for accepted results.