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

Here's a build-less TypeScript quickstart for an MCP (Minecraft Protocol) server implementation, focusing on simplicity and ease of setup. This approach is suitable for small projects, prototyping, or learning the basics. Keep in mind that for larger, production-ready servers, a build process (using `tsc` and a bundler like esbuild or webpack) is highly recommended for performance and maintainability. **1. Project Setup** Create a new directory for your project: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` **2. `package.json` (for dependencies and scripts)** Create a `package.json` file: ```bash npm init -y ``` Then, edit `package.json` to add the necessary dependencies and a start script: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "A quickstart Minecraft Protocol server in TypeScript (build-less)", "main": "index.js", "scripts": { "start": "node --loader ts-node/esm src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": ["minecraft", "server", "typescript", "mcp"], "author": "You", "license": "MIT", "dependencies": { "minecraft-protocol": "^1.50.0" }, "devDependencies": { "@types/node": "^20.0.0", "ts-node": "^10.0.0", "typescript": "^5.0.0" }, "type": "module" } ``` **Explanation:** * **`dependencies`**: * `minecraft-protocol`: The core library for handling Minecraft protocol communication. Adjust the version as needed. * **`devDependencies`**: * `@types/node`: TypeScript type definitions for Node.js. * `ts-node`: Allows you to execute TypeScript files directly without compiling them to JavaScript first. Crucial for this build-less approach. * `typescript`: The TypeScript compiler. We still need it for type checking, even if we're not explicitly compiling. * **`scripts`**: * `start`: This is the key. It uses `ts-node/esm` to execute your `src/index.ts` file directly. The `--loader ts-node/esm` flag tells Node.js to use `ts-node` as a module loader, enabling TypeScript execution. * **`type`: "module"`**: This is *essential* for using ES modules (import/export) in your TypeScript code. Without this, you'll have to use CommonJS (`require`) which is less modern. **3. Install Dependencies** ```bash npm install ``` **4. Create the Source File (`src/index.ts`)** Create a directory named `src`: ```bash mkdir src ``` Then, create a file named `src/index.ts` with the following content: ```typescript import { createServer } from 'minecraft-protocol'; const server = createServer({ 'online-mode': false, // Set to true for authenticating with Mojang servers host: '0.0.0.0', // Listen on all interfaces port: 25565, // Default Minecraft port version: '1.19.4', // Minecraft version to emulate maxPlayers: 10, motd: '§aMy Awesome TypeScript Server\n§bRunning build-less!' }); server.on('login', (client) => { console.log(`${client.username} connected`); client.on('end', () => { console.log(`${client.username} disconnected`); }); client.on('error', (err) => { console.error(`Client ${client.username} error:`, err); }); // Send a chat message to the client client.write('chat', { message: JSON.stringify({ translate: 'chat.type.announcement', with: [ 'Server', 'Welcome to the server!' ] }), position: 0, // Chat box sender: '0' }); }); server.on('listening', () => { console.log(`Server listening on port ${server.socketServer.address().port}`); }); server.on('error', (err) => { console.error('Server error:', err); }); ``` **Explanation:** * **`import { createServer } from 'minecraft-protocol';`**: Imports the necessary function from the `minecraft-protocol` library. * **`createServer(...)`**: Creates the Minecraft server instance. The options object configures the server: * `online-mode`: Whether to authenticate players with Mojang. Set to `false` for testing or LAN servers. **Important: Setting this to `false` makes your server vulnerable to impersonation.** * `host`: The IP address to listen on. `0.0.0.0` means listen on all interfaces. * `port`: The port to listen on (default Minecraft port is 25565). * `version`: The Minecraft version the server will emulate. This is crucial for compatibility with clients. Make sure it matches the version you want to support. Check the `minecraft-protocol` documentation for supported versions. * `maxPlayers`: The maximum number of players allowed on the server. * `motd`: The message of the day displayed in the Minecraft client's server list. Use Minecraft color codes (e.g., `§a` for green, `§b` for aqua). * **`server.on('login', (client) => { ... });`**: This is the event handler that's called when a client successfully logs in. The `client` object represents the connected player. * `client.on('end', ...)`: Handles client disconnects. * `client.on('error', ...)`: Handles client errors. * `client.write('chat', ...)`: Sends a chat message to the client. The message format is a JSON string that conforms to Minecraft's chat message format. * **`server.on('listening', ...)`**: Called when the server starts listening for connections. * **`server.on('error', ...)`**: Handles server-level errors. **5. Run the Server** ```bash npm start ``` This will execute your `src/index.ts` file using `ts-node/esm`. You should see output in your console indicating that the server is running. **6. Connect with a Minecraft Client** Start your Minecraft client and connect to `localhost:25565`. Make sure the client version matches the `version` specified in your `src/index.ts` file. If `online-mode` is `false`, you can use any username. **Important Considerations and Improvements:** * **Error Handling:** The example provides basic error handling, but you should implement more robust error handling in a real-world application. * **Configuration:** Hardcoding server settings in the code is not ideal. Use environment variables or a configuration file to make the server more configurable. * **Asynchronous Operations:** Minecraft protocol operations are often asynchronous. Use `async/await` to handle asynchronous operations cleanly. * **Protocol Version:** The `version` option in `createServer` is critical. Make sure it matches the Minecraft version you want to support. Refer to the `minecraft-protocol` documentation for a list of supported versions. * **Security:** If you set `online-mode` to `false`, your server is vulnerable to impersonation. Only do this for testing or LAN servers. For public servers, always enable `online-mode`. * **Build Process (Recommended for Production):** While this build-less approach is convenient for quick starts, it's not recommended for production servers. A build process using `tsc` and a bundler (like esbuild or webpack) will: * Improve performance by compiling TypeScript to optimized JavaScript. * Bundle your code into a single file, making deployment easier. * Allow you to use more advanced TypeScript features and libraries. **Example with a Build Process (Brief Overview):** 1. **Install Build Tools:** ```bash npm install -D typescript esbuild ``` 2. **`tsconfig.json`:** ```json { "compilerOptions": { "target": "esnext", "module": "esnext", "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Output directory }, "include": ["src/**/*"] } ``` 3. **`build` script in `package.json`:** ```json "scripts": { "build": "tsc && node dist/index.js", "start": "npm run build" } ``` 4. **Run `npm run build`:** This will compile your TypeScript code to JavaScript in the `dist` directory and then run the resulting JavaScript file. This more complex setup is highly recommended for any serious Minecraft server project. It provides better performance, maintainability, and scalability. The build-less approach is primarily for learning and experimentation. **Portuguese Translation of Key Concepts:** * **Build-less:** Sem compilação (literalmente "without compilation") or "sem processo de construção". * **TypeScript:** TypeScript (the same name is used in Portuguese). * **MCP (Minecraft Protocol):** Protocolo Minecraft (the same name is often used, or you can say "protocolo de comunicação do Minecraft"). * **Server:** Servidor. * **Implementation:** Implementação. * **Dependencies:** Dependências. * **Development Dependencies:** Dependências de desenvolvimento. * **Script:** Script (the same name is used in Portuguese). * **Module:** Módulo. * **Compile:** Compilar. * **Authentication:** Autenticação. * **Vulnerable:** Vulnerável. * **Impersonation:** Impersonificação. * **Configuration:** Configuração. * **Environment Variables:** Variáveis de ambiente. * **Asynchronous:** Assíncrono. * **Optimized:** Otimizado. * **Bundler:** Empacotador (although "bundler" is often used directly). * **Deployment:** Implantação. * **Maintainability:** Manutenibilidade. * **Scalability:** Escalabilidade. This comprehensive guide should get you started with a build-less TypeScript Minecraft server. Remember to consult the `minecraft-protocol` documentation for more advanced features and protocol details. 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.