Discover Awesome MCP Servers
Extend your agent with 84,517 capabilities via MCP servers.
- All84,517
- Developer Tools3,867
- Search1,714
- Research & Data1,557
- AI Integration Systems229
- Cloud Platforms219
- Data & App Analysis181
- Database Interaction177
- Remote Shell Execution165
- Browser Automation147
- Databases145
- Communication137
- AI Content Generation127
- OS Automation120
- Programming Docs Access109
- Content Fetching108
- Note Taking97
- File Systems96
- Version Control93
- Finance91
- Knowledge & Memory90
- Monitoring79
- Security71
- Image & Video Processing69
- Digital Note Management66
- AI Memory Systems62
- Advanced AI Reasoning59
- Git Management Tools58
- Cloud Storage51
- Entertainment & Media43
- Virtualization42
- Location Services35
- Web Automation & Stealth32
- Media Content Processing32
- Calendar Management26
- Ecommerce & Retail18
- Speech Processing18
- Customer Data Platforms16
- Travel & Transportation14
- Education & Learning Tools13
- Home Automation & IoT13
- Web Search Integration12
- Health & Wellness10
- Customer Support10
- Marketing9
- Games & Gamification8
- Google Cloud Integrations7
- Art & Culture4
- Language Translation3
- Legal & Compliance2
semfora-error-reporter
Provides tools for logging, confirming, and triaging issues with the semfora-engine, enabling AI agents to report bugs discovered during workflows.
Understand-Anything MCP Server
Bridges codebase structural analysis, architectural rules, and CI/CD validation with MCP clients, enabling LLMs to check blast radius and prevent breaking changes.
Ollama_MCP_Guidance
Un servidor de Protocolo de Contexto de Modelo que proporciona interfaces estandarizadas para interactuar con la API de Ollama, ofreciendo respuestas JSON, manejo de errores y orientación inteligente para llamadas a la API basadas en LLM.
tickiti-mcp
An MCP server that exposes the Tickiti helpdesk API to AI assistants, enabling ticket management and helpdesk operations via natural language.
CO2 Sensor MCP Server
A Node.js application that provides a JSON-RPC interface to interact with CO2 sensor data, working in both simulation mode and with real Raspberry Pi Pico hardware connections.
trinity-local
Enables running AI councils across Claude, GPT, and Gemini, synthesizing answers based on your personal taste lens, all locally without an API key.
mcpo-docker
Okay, here's an example Dockerfile and some accompanying explanation to help you create a Docker image for `mcpo` (assuming it's a command-line tool that exposes MCP servers as OpenAPI endpoints for OpenWebUI). I'll make some reasonable assumptions about how `mcpo` works, but you'll need to adapt this to your specific needs. **Dockerfile** ```dockerfile # Use a base image with Python (e.g., slim version for smaller size) FROM python:3.11-slim-bookworm AS builder # Set a working directory inside the container WORKDIR /app # Copy the mcpo requirements file (if you have one) COPY requirements.txt . # Install mcpo dependencies (if any) RUN pip install --no-cache-dir -r requirements.txt # Copy the mcpo source code COPY . . # --- Final Image --- FROM python:3.11-slim-bookworm # Set a working directory inside the container WORKDIR /app # Copy the mcpo executable from the builder stage COPY --from=builder /app . # Expose the port mcpo will listen on (adjust as needed) EXPOSE 8000 # Define the command to run mcpo when the container starts CMD ["python", "mcpo.py", "--host", "0.0.0.0", "--port", "8000"] ``` **Explanation:** 1. **`FROM python:3.11-slim-bookworm AS builder`**: * This line specifies the base image for the Docker image. We're using a Python 3.11 slim image based on Debian Bookworm. The `slim` version is smaller than the full Python image, which is good for reducing the image size. The `AS builder` part gives this stage a name, "builder," which we'll use later. 2. **`WORKDIR /app`**: * Sets the working directory inside the container to `/app`. All subsequent commands will be executed relative to this directory. 3. **`COPY requirements.txt .`**: * Copies the `requirements.txt` file (if you have one) from your local directory to the `/app` directory inside the container. This file should list all the Python packages that `mcpo` depends on. If you don't have a `requirements.txt` file, you can create one using `pip freeze > requirements.txt` in your local `mcpo` development environment. 4. **`RUN pip install --no-cache-dir -r requirements.txt`**: * Installs the Python packages listed in `requirements.txt`. The `--no-cache-dir` option prevents `pip` from caching downloaded packages, which helps reduce the image size. 5. **`COPY . .`**: * Copies all the files and directories from your current directory (where the Dockerfile is located) to the `/app` directory inside the container. This includes the `mcpo.py` script (or whatever the main `mcpo` executable is called), any configuration files, and other necessary files. 6. **`FROM python:3.11-slim-bookworm`**: * Starts a new stage in the Docker build. This is important for creating a smaller final image. We're using the same base image as before. 7. **`WORKDIR /app`**: * Sets the working directory for the new stage. 8. **`COPY --from=builder /app .`**: * This is the key to multi-stage builds. It copies the contents of the `/app` directory from the `builder` stage to the `/app` directory in the current stage. This means we're only copying the compiled code and dependencies, not the build tools or intermediate files. 9. **`EXPOSE 8000`**: * Declares that the container will listen on port 8000. This is just metadata; it doesn't actually publish the port. You'll need to use the `-p` option when running the container to map the container's port 8000 to a port on your host machine. Adjust the port number if `mcpo` uses a different port. 10. **`CMD ["python", "mcpo.py", "--host", "0.0.0.0", "--port", "8000"]`**: * Specifies the command to run when the container starts. This assumes that `mcpo` is a Python script named `mcpo.py`. The `--host 0.0.0.0` option tells `mcpo` to listen on all network interfaces, which is necessary for accessing it from outside the container. The `--port 8000` option tells `mcpo` to listen on port 8000. **You'll need to adjust this command to match the actual command-line arguments that `mcpo` requires.** For example, you might need to specify a configuration file or other options. **How to Build and Run the Image:** 1. **Save the Dockerfile:** Save the above code as a file named `Dockerfile` in the same directory as your `mcpo` source code and `requirements.txt` (if you have one). 2. **Build the Image:** Open a terminal in that directory and run the following command: ```bash docker build -t mcpo-image . ``` * `docker build`: The Docker command to build an image. * `-t mcpo-image`: Tags the image with the name `mcpo-image`. You can choose any name you like. * `.`: Specifies that the Dockerfile is in the current directory. 3. **Run the Container:** After the image is built, run it with the following command: ```bash docker run -d -p 8000:8000 mcpo-image ``` * `docker run`: The Docker command to run a container. * `-d`: Runs the container in detached mode (in the background). * `-p 8000:8000`: Maps port 8000 on your host machine to port 8000 inside the container. This allows you to access `mcpo` from your host machine. If `mcpo` uses a different port, adjust this accordingly. * `mcpo-image`: The name of the image to run. 4. **Access `mcpo`:** Once the container is running, you should be able to access the `mcpo` server in your web browser or using `curl` at `http://localhost:8000` (or whatever port you mapped). The exact URL will depend on how `mcpo` exposes its OpenAPI endpoint. You'll likely need to consult the `mcpo` documentation to determine the correct URL. **Important Considerations and Customization:** * **`mcpo` Command-Line Arguments:** The `CMD` instruction in the Dockerfile is crucial. Make sure you replace the example command with the correct command-line arguments for `mcpo`. This might include specifying a configuration file, API keys, or other options. * **Dependencies:** Ensure that your `requirements.txt` file includes all the necessary Python packages for `mcpo`. If you're missing dependencies, the container will likely fail to start. * **Port:** Adjust the `EXPOSE` and `-p` options to match the port that `mcpo` uses. * **Volumes:** If `mcpo` needs to access files on your host machine (e.g., configuration files, data files), you can use Docker volumes to mount directories from your host machine into the container. For example: ```bash docker run -d -p 8000:8000 -v /path/to/config:/app/config mcpo-image ``` This would mount the `/path/to/config` directory on your host machine to the `/app/config` directory inside the container. * **Environment Variables:** You can use environment variables to configure `mcpo` at runtime. For example: ```dockerfile ENV API_KEY=your_api_key CMD ["python", "mcpo.py", "--api-key", "$API_KEY"] ``` Then, when you run the container, you can set the `API_KEY` environment variable: ```bash docker run -d -p 8000:8000 -e API_KEY=another_api_key mcpo-image ``` * **Logging:** Consider how `mcpo` logs its output. You might want to configure logging to a file or to standard output so that you can easily monitor the container's activity. * **Security:** If `mcpo` handles sensitive data, be sure to take appropriate security measures, such as using HTTPS, restricting access to the container, and protecting API keys. * **OpenWebUI Integration:** This Dockerfile focuses on running `mcpo`. You'll need to configure OpenWebUI to connect to the `mcpo` server. This typically involves specifying the URL of the `mcpo` server in OpenWebUI's settings. This comprehensive example should give you a solid starting point for creating a Docker image for `mcpo`. Remember to adapt it to your specific needs and consult the `mcpo` documentation for more information.
cortex-mcp
An MCP server for the Cortex observable analysis and active response engine. It enables LLMs to automate security investigations by running analyzers on observables like IPs and URLs and executing automated response actions.
CreatorOS AI
MCP server that enables AI-powered content generation in multiple formats using Google Gemini and Tavily real-time research, accessible via MCP-compatible clients.
cadex-mcp
MCP server for CAD Exchanger SDK that enables loading, inspecting, and exporting CAD models via a path-based cache.
Zoho Inventory MCP Server by CData
This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Zoho Inventory (beta): https://www.cdata.com/download/download.aspx?sku=KZZK-V&type=beta
mcp-server-steam
Integrates with Steam Web API to enable querying user profiles, game libraries, store data, and community features like reviews and workshop items.
Tesouro Nacional: Capacidade de Pagamento (CAPAG)
Enables consulting the Brazilian Treasury's Payment Capacity (CAPAG) data through an MCP server, providing official information via natural language.
claude-memory
A persistent memory MCP server for Claude Code that enables long-term recall across sessions via hybrid search, code intelligence, and tools for reading/writing memory.
Go-MCP-File-Server
tripwire-guard
Provides a local, read-only MCP server that scans untrusted text for prompt-injection and returns an allow/review/block decision with evidence. It runs entirely on-device with no network requests and redacts sensitive strings by default.
Mailing Manager MCP
Enables AI assistants to manage multiple email accounts with secure credentials, local full-text search, thread-aware replies, and automation.
Fetch MCP Server
Enables LLMs to retrieve and process web content by fetching URLs and converting HTML to markdown, with support for chunked reading and customizable user-agents.
Dokmatiq DocGen
PDF/DOCX/Excel generation from HTML/Markdown with stationery overlay, ZUGFeRD/XRechnung e-invoicing, digital signing, form filling, and AI receipt OCR with DATEV/SKR03 export.
YRB-HES Evidence MCP
A read-only MCP server for evidence retrieval in Yellow River Basin human–earth systems reviews, exposing PostgreSQL-backed tools for searching and comparing evidence, entities, and spatiotemporal data while preserving source provenance.
Mnemosyne
Provides persistent memory for LLM applications, enabling AI assistants to remember user preferences, facts, and conversation history across sessions.
MkDocs Material MCP Server
Enables searching and retrieving documentation from MkDocs Material-powered sites.
Scopus MCP Server
Provides access to the Elsevier Scopus API, enabling AI assistants to search for academic papers, retrieve detailed abstracts, and look up author profiles. It facilitates bibliometric research and scholarly data analysis through natural language commands.
JedSearch MCP Server
Enables web search and page content extraction with JavaScript rendering via Playwright, with HTTP fallback and retry logic.
Notion MCP Server
Un servidor de Protocolo de Contexto de Modelo que conecta asistentes de IA como Claude a espacios de trabajo de Notion, permitiéndoles ver, buscar, crear y actualizar bases de datos, páginas y bloques de contenido de Notion.
Jokes MCP Server
Enables users to fetch various types of jokes including Chuck Norris and Dad jokes through an MCP server that integrates with Microsoft Copilot Studio and GitHub Copilot.
spectra-mcp
An MCP server that provides LLMs with a fingerprint-randomized Firefox browser for web browsing, clicking, typing, and taking screenshots, using invisible_playwright.
N-central MCP Server
Exposes N-able N-central REST API as MCP tools for managing devices, organizations, users, and more, with support for read-only, write, and full write modes.
Capacities MCP Server
Provides seamless integration with Capacities knowledge management system, allowing Claude to list spaces, retrieve space information, search content, save weblinks, and add content to daily notes.
DuckDuckGo MCP Agent
A minimal, production-ready MCP server enabling LLMs to perform web searches via DuckDuckGo without API keys, supporting SSE streaming and LM Studio compatibility.