Discover Awesome MCP Servers

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.

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

MCP Jira Server

Here are a few ways to translate "MCP to talk to Jira from cursor" into Spanish, depending on the intended meaning: **Option 1 (Most likely, assuming "MCP" is a specific tool/program):** * **"Usar MCP para interactuar con Jira desde Cursor."** (This is the most direct and likely translation. It assumes MCP is a tool and Cursor is the application you're using.) **Option 2 (If "MCP" is a general concept, like "a method" or "a process"):** * **"Un método/proceso para interactuar con Jira desde Cursor."** (This translates to "A method/process to interact with Jira from Cursor.") You would choose "método" or "proceso" depending on the specific context. **Option 3 (If you want to emphasize *how* MCP allows interaction):** * **"Integrar MCP para poder interactuar con Jira directamente desde Cursor."** (This translates to "Integrate MCP to be able to interact with Jira directly from Cursor.") **Important Considerations:** * **"Cursor"**: If "Cursor" is a specific application with a well-known name, you should keep it as "Cursor" in Spanish. If it's a more generic term (like "the cursor position"), you might need to rephrase the sentence. * **"MCP"**: If "MCP" is an acronym specific to your company or a niche field, it's best to leave it as "MCP" in the Spanish translation. If it's a more general term, you'll need to provide more context for a better translation. To give you the *best* translation, please provide more context about what "MCP" and "Cursor" refer to.

DateTime MCP Server

Provides tools to get the current date and time in various formats (ISO, Unix timestamp, human-readable, custom) with configurable timezone support.

ピティナニュースMCPサーバー

Here are a few options for translating "MCP Server for PTNA news feeds," depending on the context: **Option 1 (Most Literal):** * **Servidor MCP para fuentes de noticias PTNA** * This is a direct translation and suitable if you're talking about a specific server and its function. **Option 2 (More Descriptive):** * **Servidor MCP para la distribución de noticias de PTNA** * This emphasizes the distribution aspect of the news feeds. **Option 3 (If "MCP" needs clarification):** * **Servidor MCP para la recepción y distribución de noticias de PTNA** (MCP server for receiving and distributing PTNA news) **Important Considerations:** * **"MCP" Acronym:** If "MCP" is a well-known acronym within the Spanish-speaking context you're targeting, you can leave it as is. However, if it's not, you might need to provide a brief explanation of what it stands for the first time you use it. * **"PTNA" Acronym:** Same as above. If PTNA is not known, you may need to spell it out. Therefore, the best translation depends on the specific context and your audience. If you can provide more context, I can give you a more precise translation.

Docker Build MCP Server

A TypeScript server that fully implements the Model Context Protocol (MCP) standard, providing API access to Docker CLI operations like build, run, stop, and image management through compatible AI clients.

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.

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

Spec-driven Development MCP Server

Enables AI-guided spec-driven development workflow that transforms ideas into implementation through structured stages: goal collection, requirements gathering in EARS format, technical design documentation, task planning, and systematic code execution.

MCP Pokemon Server

An MCP server implementation that enables users to interact with the PokeAPI to fetch Pokemon information through natural language queries.

MCP Weather SSE Server

A Model Context Protocol server that provides real-time weather data to AI clients through Server-Sent Events, enabling them to fetch current weather conditions, multi-day forecasts, and location-based weather information.

Smart Search MCP

Provides 14 enhanced intelligent search tools for both international platforms (GitHub, StackOverflow, NPM, etc.) and Chinese platforms (CSDN, Juejin, WeChat docs, etc.). Each tool includes smart URL generation, search tips, and related suggestions for comprehensive technical research.

WordPress MCP Proxy

Enables interaction with multiple WordPress sites through a proxy that connects to the MCP Expose Abilities plugin. Allows discovering and executing WordPress abilities across configured sites with secure authentication.

MCP ShellKeeper

Enables AI assistants to maintain persistent SSH terminal sessions and transfer files to/from remote servers. Allows stateful command execution, natural language server management, and seamless file operations through SSH connections.

AITable MCP Server

AITable.ai Model Context Protocol Server enables AI agents to connect and work with AITable datasheets.

MariaDB MCP Server by CData

MariaDB MCP Server by CData

Razorpay MCP Server

Servidor MCP no oficial de Razorpay

Amplitude MCP Server

A Model Context Protocol server that enables AI assistants like Claude to track events, page views, user signups, set user properties, and track revenue in Amplitude analytics.

mcpservers

MCP Servers es una plataforma centrada en mostrar y conectar servidores de Protocolo de Contexto de Modelos (MCP), proporcionando a los desarrolladores servicios convenientes de descubrimiento e integración de servidores MCP.

Conclave MCP

Provides access to multiple frontier LLM models (GPT, Claude, Gemini, Grok, DeepSeek) for consulting a "conclave" of AI perspectives, enabling peer-ranked evaluations and synthesized consensus answers for important decisions.

Puppeteer Real Browser MCP Server

A Model Context Protocol server that enables AI assistants to control a real web browser with stealth capabilities, avoiding bot detection while performing tasks like clicking, filling forms, taking screenshots, and extracting data.

Kunobi MCP Server

Exposes Kunobi's application data and store querying capabilities to AI assistants by bridging stdio to Kunobi's local HTTP MCP endpoint. It features dynamic tool discovery and automatic reconnection to ensure tools like query_store and app_info are always available when Kunobi is running.

MCP Developer Server

Provides instant access to 700+ programming documentation sources and creates isolated Docker containers for safe code testing and experimentation. Combines comprehensive documentation lookup with containerized development environments for enhanced development workflows.

EduChain MCP Server

Enables AI-powered generation of educational content including multiple-choice questions, lesson plans, and flashcards on any topic through integration with the EduChain library and DeepSeek model via OpenRouter.

Netlify MCP Server

Enables code agents to interact with Netlify services through the Model Context Protocol, allowing them to create, build, deploy, and manage Netlify resources using natural language prompts.