Discover Awesome MCP Servers

MariaDB MCP Server by CData

MariaDB MCP Server by CData

mcp-zuul

An MCP server for Zuul CI. Debug build failures by asking questions, not clicking through web UIs. Read-only access to any Zuul instance — builds, logs, pipelines, jobs, and live status. Works with Claude Code, Claude Desktop, Cursor, and any MCP-compatible client.

SuperDB MCP Server

Enables AI assistants to execute SuperSQL queries on data files and SuperDB databases without shell escaping issues. Supports querying, schema inspection, database pool management, and provides LSP features for code completion and documentation.

MCP Homescan Server

Enables local network discovery and security scanning to identify connected devices, manufacturers, and potential risks. It allows users to track network changes and export inventories into Markdown or Obsidian-compatible formats.

yuexia_test

yuexia\_test

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.

Intervals.icu MCP Server

Enables AI assistants to interact with Intervals.icu fitness tracking and wellness data, allowing users to fetch, filter, and group activities or health metrics. It provides structured summaries of workouts and physical well-being through natural language queries.

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.

Google Calendar MCP Server

Enables management of Google Calendar events across multiple calendars with natural language support, including searching events, checking availability, creating/updating/deleting events, responding to invitations, and auto-generating Google Meet links.

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 서버

Polish Academic MCP

Provides tools for AI models to search and retrieve information from five major Polish academic and government databases, including scientific articles and research datasets. It enables users to query platforms like Biblioteka Nauki and Repozytorium UJ through a standardized interface hosted on Cloudflare Workers.

PostgreSQL Remote Cloudflare MCP Worker

A Cloudflare Worker that provides a Model Context Protocol (MCP) interface for PostgreSQL databases, allowing AI assistants like Claude and Cursor to interact with PostgreSQL databases through natural language.

langfuse-mcp-java

Query Langfuse traces, schema and datasets, scores and metrics, debug exceptions, analyze sessions, and manage prompts. Full observability toolkit for LLM applications.

MCP Server on Cloudflare Workers

A proof of concept implementation of Model Context Protocol server running on Cloudflare's edge network with bearer token authentication, allowing deployed AI models to access tools via serverless architecture.

Twitter MCP Server

Enables LLM agents to interact with Twitter (X) for searching tweets, posting content with images, analyzing engagement, and extracting topics using the Twitter API.

IB Analytics MCP Server

Enables comprehensive analysis of Interactive Brokers portfolios through automated data fetching and multi-dimensional analytics. Provides performance, tax, cost, risk, and bond analysis across multiple accounts with rich reporting capabilities.

Freelo MCP Server

Integrates with Freelo project management API to retrieve task details, list subtasks with completion status, and download files from task comments.

Shopmium MCP Server

A custom MCP server that provides high-level tools for controlling Shopmium and Quoty apps on Android emulators, allowing for automated app navigation, interaction, and testing without needing to handle low-level implementation details.

Junipr MCP Server

Enables AI assistants to capture webpage screenshots, generate PDFs from URLs or HTML, and extract rich metadata like Open Graph and JSON-LD data. It provides tools for web-to-image/PDF conversion and structured data extraction through the Junipr API.

MCP Container Tools

An MCP server for managing and monitoring Docker, Docker Compose, and Kubernetes environments alongside Azure Application Insights. It enables advanced log filtering, container lifecycle management, and querying of cloud application traces and metrics.

Pure Data MCP Server

Um servidor de Protocolo de Contexto de Modelo (MCP) para Pure Data, uma linguagem de programação visual de código aberto e ambiente patchável para música computacional em tempo real.

ClickUp MCP Server

Provides integration with ClickUp's API, allowing you to retrieve task information and manage ClickUp data through MCP-compatible clients.

QAE-Claude-mcp-example

Deterministic pre-execution safety certification for autonomous AI agents. Evaluates proposed actions across scope, reversibility, and sensitivity constraints — returns Certified, Warning, Escalate, or Blocked decisions with cryptographic audit trails. 3 tools: certify_action, check_budget, get_certification_history. Built on the QAE Safety Kernel (Rust + PyO3 bindings, pip install qae-safety).

Claude Talk to Figma MCP

Enables Claude Desktop and other AI tools to interact directly with Figma, allowing for powerful AI-assisted design capabilities through natural language commands.

Wolfram Alpha MCP Server

Provides access to Wolfram Alpha's computational knowledge engine for mathematical calculations, scientific computing, data analysis, and factual information through natural language queries.

Igloo MCP

Enables AI assistants to interact with Snowflake databases through SQL queries, table previews, and metadata operations. Features built-in safety checks that block destructive operations and intelligent error handling optimized for AI workflows.

Tavily MCP Server

Provides AI assistants with real-time web search, intelligent data extraction from web pages, website mapping, and web crawling capabilities through Tavily's API. Enables comprehensive web research and content analysis through natural language interactions.

Tokopedia MCP Server

Enables AI assistants to search for products and manage order history on Tokopedia using the Model Context Protocol. It supports advanced filtering, sorting discovery, and authenticated session management via a dual MCP and web interface.