Discover Awesome MCP Servers

dune-mcp

Dune MCP Server connects your AI assistant to Dune Analytics, the leading platform for blockchain data. Execute SQL queries across Ethereum, Solana, and 20+ chains to analyze DEX trades, token transfers, NFT sales, and wallet activity. Manage saved queries, upload custom datasets, and access curate

cisa-kev-mcp

MCP server to query and manage CISA Known Exploited Vulnerabilities catalog with EPSS overlay, enabling vulnerability checks and remediation deadline tracking.

OutlookMaster-MCP

A comprehensive MCP server for Microsoft Outlook email management, enabling mail operations, smart search, statistical analysis, and more via natural language.

Ek-Chuah MCP

Read-only MCP server that serves the Archivo Epistemico (epistemic graph), enabling AI to read and query the epistemic path autonomously via tools like search, get_via, resolve, and get_necesidad.

MCP Jieba Server

Provides high-performance Chinese text segmentation, POS tagging, and keyword extraction using Rust-based Jieba implementation. Supports both local STDIO and remote HTTP deployment modes.

requirements-risk-analyser

AI-powered pipeline that analyzes user stories and PRDs for gaps, ambiguities, and missing acceptance criteria before coding, with MCP tools for requirement analysis and risk reporting.

TensorFeed

Real-time AI industry intelligence MCP server. 6 free tools (news, status, pricing, today summary, agent activity, MCP registry snapshot) plus 13 paid tools (routing, news search, history series, cost projection, deep-dive, comparison, webhook watches). Pay-per-call in USDC on Base, no accounts.

Pega DX MCP Server

Transforms complex Pega Platform interactions into intuitive, conversational experiences by exposing Pega DX APIs through the standardized Model Context Protocol, enabling AI applications to interact with Pega through natural language.

pgmcp

Enables AI agents to perform PostgreSQL administration, web crawling, and knowledge base management through a unified FastMCP server.

DevBot

A Flask-based chatbot using Gemini 2.5 Flash and MCP tools to manage GitHub repositories and LinkedIn profiles via natural language.

MWAA MCP Server

Enables management of Amazon Managed Workflows for Apache Airflow (MWAA) environments and operations including DAG management, workflow execution monitoring, and access to Airflow connections and variables through a unified interface.

grafema-mcp

Grafema builds a queryable knowledge graph of your codebase and allows you to enforce structural invariants and query the system using Datalog or Cypher.

Microsoft 365 Core MCP Server

Provides comprehensive management of Microsoft 365 services including Exchange, SharePoint, Teams, Azure AD, Intune device management, security & compliance frameworks, and universal access to 1000+ Microsoft Graph API endpoints with advanced features like batch operations, delta queries, and real-time webhooks.

interminal

MCP server for SSH and local terminal access. Supports interactive commands, long-running processes, and TUI apps like tmux/zellij

computer-control-mcp

Enables computer control via mouse, keyboard, OCR, and screen/window management, similar to Anthropic's computer-use.

z/OS FTP MCP Server

Enables interaction with z/OS mainframe systems via FTP, including dataset listing/download/upload, JCL job submission and monitoring, with advanced text processing and pagination support.

MBTA Worcester Line MCP Server

Provides real-time train schedule information and live predictions for all 18 stations on the MBTA Worcester Line. It enables users to query upcoming departures and filter by direction or date through natural language.

seo-data-api-mcp-server

Enables to access SE Ranking SEO data through natural language queries, providing keyword analysis, competitor research, and performance tracking.

Schulmanager Online MCP Server

A local MCP server that enables LLMs like Claude to access Schulmanager Online data including schedules, homework, exams, grades, and parental letters.

Nokia SR OS NETCONF MCP Server

Enables managing Nokia SR OS devices via NETCONF from Claude Desktop, supporting MD-CLI commands, configuration retrieval and editing, candidate workflow with commit/rollback, and multi-device sessions.

remark-mcp

Enables AI assistants to browse and read documents from a reMarkable tablet connected via USB, rendering PDF pages as images for the AI to see.

doc-tools-mcp

Here are a few ways to approach implementing Word document reading and writing with MCP (presumably referring to Message Passing Concurrency) in Node.js, along with considerations and code snippets: **Understanding the Challenge** * **Word Processing Libraries:** Node.js doesn't have built-in Word processing capabilities. You'll need a library like `docx`, `mammoth`, or `officegen`. These libraries handle the complexities of the DOCX format. * **Message Passing Concurrency (MCP):** Node.js is single-threaded. To achieve concurrency, you'll typically use techniques like: * **Child Processes:** Spawn separate Node.js processes to handle document processing tasks. Use `child_process.fork` or `child_process.spawn`. * **Worker Threads:** (Node.js 12+) Use `worker_threads` for true parallelism within the same Node.js process. This is often more efficient than child processes for CPU-bound tasks. * **Message Queues (Redis, RabbitMQ):** Decouple the main application from the document processing tasks. The main app puts document processing requests onto a queue, and worker processes/threads consume and process them. **General Architecture** 1. **Main Process/Thread:** * Receives requests to read or write Word documents (e.g., from an HTTP endpoint). * Serializes the document data and any processing instructions. * Sends a message to a worker process/thread or a message queue. 2. **Worker Process/Thread (or Queue Consumer):** * Receives the message. * Uses a Word processing library (`docx`, `mammoth`, `officegen`) to perform the read or write operation. * Serializes the result (e.g., extracted text, success/failure status). * Sends a message back to the main process/thread (or updates a database). 3. **Main Process/Thread:** * Receives the result from the worker. * Sends a response back to the client (e.g., the extracted text, a confirmation message). **Example using Child Processes and `docx` (for reading)** ```javascript // main.js (Main process) const { fork } = require('child_process'); const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); // for parsing application/json app.post('/extract-text', (req, res) => { const filePath = req.body.filePath; // Get the file path from the request if (!filePath) { return res.status(400).send({ error: 'File path is required' }); } const worker = fork('./worker.js'); // Path to the worker script worker.send({ type: 'extractText', filePath: filePath }); worker.on('message', (message) => { if (message.type === 'textExtracted') { res.send({ text: message.text }); worker.kill(); // Terminate the worker after processing } else if (message.type === 'error') { res.status(500).send({ error: message.error }); worker.kill(); } }); worker.on('exit', (code) => { if (code !== 0) { console.error(`Worker process exited with code ${code}`); } }); }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` ```javascript // worker.js (Worker process) const docx = require('docx'); const fs = require('fs').promises; // Use promises for async file operations process.on('message', async (message) => { if (message.type === 'extractText') { const filePath = message.filePath; try { const buffer = await fs.readFile(filePath); const document = new docx.Document({ sections: [{ properties: {}, children: [], }], }); const text = await docx.extractRawText(buffer); process.send({ type: 'textExtracted', text: text }); } catch (error) { console.error('Error extracting text:', error); process.send({ type: 'error', error: error.message }); } } }); ``` **Explanation:** * **`main.js`:** * Sets up an Express.js server with a `/extract-text` endpoint. * When a request is received, it uses `child_process.fork` to create a new Node.js process running `worker.js`. * It sends a message to the worker with the file path. * It listens for messages from the worker: * `textExtracted`: Sends the extracted text back to the client. * `error`: Sends an error response. * It kills the worker process after processing. * **`worker.js`:** * Listens for messages from the parent process. * When it receives an `extractText` message: * Reads the Word document using `fs.readFile`. * Uses `docx.extractRawText` to extract the text. * Sends the extracted text back to the parent process. * Handles errors and sends an error message back to the parent. **How to Run:** 1. **Install dependencies:** ```bash npm install express docx ``` 2. **Create `main.js` and `worker.js`** (as shown above). 3. **Run the server:** ```bash node main.js ``` 4. **Send a POST request to `http://localhost:3000/extract-text`** with a JSON body like: ```json { "filePath": "/path/to/your/document.docx" } ``` (Replace `/path/to/your/document.docx` with the actual path to your Word document.) **Important Considerations:** * **Error Handling:** Robust error handling is crucial. Catch errors in both the main process and the worker process and send appropriate error messages. * **Security:** Be very careful about accepting file paths from the client. Validate the file path to prevent malicious users from accessing arbitrary files on your server. Consider using a dedicated upload directory and generating unique filenames. * **Resource Management:** Word processing can be memory-intensive. Limit the size of documents that can be processed to prevent your server from running out of memory. Terminate worker processes after they've finished their task to release resources. * **Scalability:** For high-volume document processing, consider using a message queue (like Redis or RabbitMQ) to distribute the workload across multiple worker processes/threads. This will improve the scalability and resilience of your application. * **Choosing a Library:** * **`docx`:** Good for creating and manipulating DOCX files programmatically. Also has some text extraction capabilities. * **`mammoth`:** Specifically designed for converting DOCX files to HTML. Excellent for extracting formatted text. * **`officegen`:** Another option for creating Office documents (DOCX, PPTX, XLSX). * **Worker Threads:** If you're using Node.js 12 or later, `worker_threads` can be a more efficient alternative to child processes, especially for CPU-bound tasks. The code structure is similar, but you'll use `worker_threads.Worker` instead of `child_process.fork`. Be mindful of data sharing between threads (use `TransferArrayBuffer` for efficient data transfer). **Example using Worker Threads (Node.js 12+)** ```javascript // main.js (Main thread) const { Worker } = require('worker_threads'); const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); app.post('/extract-text', (req, res) => { const filePath = req.body.filePath; if (!filePath) { return res.status(400).send({ error: 'File path is required' }); } const worker = new Worker('./worker.js'); worker.postMessage({ type: 'extractText', filePath: filePath }); worker.on('message', (message) => { if (message.type === 'textExtracted') { res.send({ text: message.text }); } else if (message.type === 'error') { res.status(500).send({ error: message.error }); } }); worker.on('error', (err) => { console.error('Worker error:', err); res.status(500).send({ error: 'Worker error' }); }); worker.on('exit', (code) => { if (code !== 0) { console.error(`Worker stopped with exit code ${code}`); } }); }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` ```javascript // worker.js (Worker thread) const { parentPort } = require('worker_threads'); const docx = require('docx'); const fs = require('fs').promises; parentPort.on('message', async (message) => { if (message.type === 'extractText') { const filePath = message.filePath; try { const buffer = await fs.readFile(filePath); const document = new docx.Document({ sections: [{ properties: {}, children: [], }], }); const text = await docx.extractRawText(buffer); parentPort.postMessage({ type: 'textExtracted', text: text }); } catch (error) { console.error('Error extracting text:', error); parentPort.postMessage({ type: 'error', error: error.message }); } } }); ``` **Key Differences with Worker Threads:** * **`worker_threads` module:** Uses `require('worker_threads')`. * **`Worker` constructor:** `new Worker('./worker.js')`. * **`parentPort`:** The worker thread uses `parentPort` to communicate with the main thread. * **`postMessage`:** Uses `postMessage` to send messages. **Choosing Between Child Processes and Worker Threads:** * **Child Processes:** * **Pros:** Good isolation (each process has its own memory space). More robust if a worker crashes (it won't bring down the main process). * **Cons:** Higher overhead (process creation, inter-process communication). * **Worker Threads:** * **Pros:** Lower overhead (threads share the same memory space). Potentially faster for CPU-bound tasks. * **Cons:** Less isolation (a crash in a worker thread can crash the entire process). Requires careful synchronization to avoid race conditions when sharing data. **Message Queues (Advanced)** For a more scalable and robust solution, use a message queue like Redis or RabbitMQ. The main process publishes messages to the queue, and worker processes/threads consume messages from the queue. This decouples the main application from the document processing tasks, allowing you to scale the workers independently. **Example (Conceptual with Redis):** 1. **Main Process:** * Receives a request to extract text. * Pushes a message onto a Redis queue (e.g., `docx_extraction_queue`) with the file path. 2. **Worker Process/Thread:** * Subscribes to the `docx_extraction_queue` in Redis. * When a message arrives, it extracts the text from the Word document. * Pushes a message onto another Redis queue (e.g., `docx_extraction_results`) with the extracted text and a correlation ID (to match the result to the original request). 3. **Main Process:** * Subscribes to the `docx_extraction_results` queue. * When a message arrives, it uses the correlation ID to find the original request and send the extracted text back to the client. This approach is more complex to set up but provides significant benefits in terms of scalability, resilience, and decoupling. **Summary** Implementing Word document reading and writing with concurrency in Node.js requires careful consideration of the trade-offs between child processes, worker threads, and message queues. Choose the approach that best suits your application's requirements for performance, scalability, and robustness. Remember to prioritize error handling, security, and resource management.

DB Query MCP

Query SQLite databases via AI — safe read-only mode

advanced-seo-mcp

Provides AI agents with professional-grade SEO capabilities including on-page analysis, technical audits, PageSpeed insights, and Ahrefs data integration.

MCP Inventory

Enables CRUD and analytical operations on a SQLite inventory database, including product management and value calculations.

Useful-mcps

Aquí tienes una lista de pequeños servidores MCP útiles, incluyendo: * docx\_replace: reemplazar etiquetas en documentos de Word * yt-dlp: extraer capítulos y subtítulos basándose en los capítulos * mermaid: generar y renderizar imágenes usando la API de mermaidchart.com

Fact Check MCP

Verifies claims with verdicts (supported/disputed/unverifiable), confidence scores, and cited sources by cross-referencing FoundryNet Data Network and web search.

HPE Aruba Networking Central MCP Server

Exposes 90 production-grade tools for interacting with the complete HPE Aruba Networking Central REST API surface, including network inventory, configuration, and security management. It features enterprise-ready OAuth2 handling and semantic tool filtering for optimized performance with both hosted and local LLMs.

Org-roam MCP Server

Enables interaction with org-roam knowledge bases, allowing search, retrieval, creation, and linking of notes while respecting org-roam's file structure and conventions.

FastMCP Document Analyzer

A comprehensive document analysis server that performs sentiment analysis, keyword extraction, readability scoring, and text statistics while providing document management capabilities including storage, search, and organization.