Discover Awesome MCP Servers

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.

ufind-mcp

An MCP server for the University of Vienna's course catalogue (u:find), enabling natural language queries for courses, programmes, staff, and schedules. Read-only, no account or API key required.

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-server-synology

An MCP server that exposes a Synology NAS through the official DSM WebAPI, covering File Station, Download Station, Synology Photos, Container Manager, and system management with curated tools and a generic bridge for other APIs.

MCP-ndl-search

Enables natural language search of Japan's National Diet Library bibliographic database via Claude Desktop, allowing users to find books and academic materials using intuitive Japanese queries.

Copus MCP Server

An MCP server that allows AI assistants to search and retrieve human-curated content recommendations from Copus.

Copywriting MCP Server

Provides 10 validation tools for direct response copywriting, including blind critique, emotional stress test, semantic memory search, and more.

mcp-septa

Provides real-time SEPTA transit data via the keyless SEPTA API, enabling users to query schedules, routes, and arrivals for Philadelphia's public transit system.

meta-ads-mcp

MCP server for Meta Ads (Facebook Ads) that provides tools for account discovery, campaign/adset/ad creation, custom audiences, status updates, performance reporting, and A/B testing.

N8N MCP Server

Production-ready MCP server that brings N8N workflow automation to both Claude.ai and ChatGPT. Supports multi-tenant OAuth/SSE integration with dynamic N8N instance configuration.

Evolution API MCP Server

Exposes the Evolution API v2 (WhatsApp) as 121 tools for MCP clients, enabling management of instances, messages, chats, groups, profiles, labels, webhooks, and integrations.

Domain Check MCP Server

Okay, here's a translation of the English text "A Model Context Protocol (MCP) server for checking domain availability using IONOS endpoints" into Spanish, along with a few options depending on the nuance you want to convey: **Option 1 (Most Direct):** * Un servidor de Protocolo de Contexto de Modelo (MCP) para verificar la disponibilidad de dominios utilizando los endpoints de IONOS. **Option 2 (Slightly More Explanatory):** * Un servidor MCP (Protocolo de Contexto de Modelo) para la comprobación de la disponibilidad de dominios a través de los endpoints de IONOS. **Option 3 (Focus on Functionality):** * Un servidor basado en el Protocolo de Contexto de Modelo (MCP) para la verificación de la disponibilidad de dominios, utilizando los endpoints de IONOS. **Explanation of Choices:** * **"Servidor"** translates directly to "server." * **"Protocolo de Contexto de Modelo (MCP)"** is kept as is, assuming "MCP" is a well-known acronym in the target audience. If not, you might consider adding a brief explanation in parentheses the first time it's used. * **"Verificar la disponibilidad de dominios"** is the most common and direct translation of "checking domain availability." "Comprobación de la disponibilidad de dominios" is also correct and slightly more formal. * **"Utilizando los endpoints de IONOS"** is a direct and clear translation of "using IONOS endpoints." "A través de los endpoints de IONOS" is also a good alternative. * **"Basado en el Protocolo de Contexto de Modelo (MCP)"** emphasizes that the server's functionality is built upon the MCP protocol. **Which option is best depends on the context:** * If you're writing technical documentation, Option 1 or 2 are likely the best. * If you're trying to emphasize the server's purpose, Option 3 might be more suitable. I hope this helps!

dispatch-mcp

MCP server for tier-based dispatch delegation via OmniRoute, enabling message dispatching to various AI model tiers and health monitoring.

WalletTriage MCP

Real-time exploit-exposure check for EVM wallets with x402 USDC payments, no signup needed.

intervals-icu-mcp

MCP server that connects AI agents to Intervals.icu, enabling access to training data such as activities, wellness metrics, calendar events, gear, power curves, and custom items. Includes a running coach AI template for automated post-session analysis.

Forward MCP

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

Shanhai MCP Server

An out-of-the-box multi-tenant MCP server that lets MCP clients access knowledge retrieval, task dispatch, deliverable management, and multi-agent consultation services via SSE or stdio.

FreeTaxUSA MCP Server

Enables AI agents to file taxes through FreeTaxUSA by automating a browser, allowing form filling, navigation, and refund checks via natural language.

SP Database MCP Server

A Model Context Protocol server that provides real-time database schema information to AI assistants, supporting both low-code system schema queries and traditional database metadata queries.

git-log-mcp

Enables querying git commit history to analyze when and why code changes happened, providing authorship context and diffs for specific modules.

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.

GPT Image Playground MCP

Enables agents to generate images through the GPT Image Playground via a browser extension, supporting task submission, status tracking, and downloading generated images with reference image support.

youtube-mcp

MCP server for YouTube Data API v3 enabling video search, channel lookup, trending content, comments, and playlist management.

My MCP

TO DO microsoft

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!

nomad-mcp

Exposes a HashiCorp Nomad cluster as MCP tools for AI agents, enabling read-only inspection of jobs, allocations, nodes, and deployments, with optional write operations like stopping jobs, scaling task groups, restarting allocations, and registering jobs.

서울시 교통 데이터 MCP 서버

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