Discover Awesome MCP Servers

Remote Demo MCP

A local MCP server that automates the deployment of static directories to remote hosts using rsync. It features support for interactive SSH authentication including MFA/OTP flows and provides tools to verify reachable URLs after deployment.

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.

Marcus Local MCP Server

Enables AI assistants to semantically search through indexed documentation websites and local code repositories using OpenAI embeddings and ChromaDB vector storage.

Sequa MCP

Enables AI assistants to access contextual knowledge from multiple repositories through Sequa's Contextual Knowledge Engine. Provides architecture-aware code understanding and cross-repository context for more accurate, production-ready code generation.

Beeper MCP Server

Enables interaction with blockchain chains through a note storage system that allows adding, accessing, and summarizing notes via custom URI schemes.

Host Terminal MCP

Enables AI assistants to execute terminal commands on a host machine with configurable, granular permission controls and safety protections. It features multiple security modes, including allowlists and manual approval, to ensure safe command execution within specified directories.

MCP-CEP

A server for querying Brazilian postal codes (CEPs) using the ViaCEP public API, compatible with Goose as a command-line extension.

QuickSight MCP Server

An auto-generated MCP server that enables interaction with AWS QuickSight services through the Model Context Protocol. Provides programmatic access to QuickSight's business intelligence and analytics capabilities via the AWS QuickSight OpenAPI specification.

Grove's MCP Server for Pocket Network

Provides blockchain data access across 70+ networks including Ethereum, Solana, Cosmos, and Sui through Grove's public endpoints. Enables natural language queries for token analytics, transaction inspection, domain resolution, and multi-chain comparisons.

Fourth Brain Demo

An MCP server that connects Claude.ai to a Notion-based marketing knowledge base, enabling search and retrieval across specialized domains like enterprise platforms and competitive positioning. It provides tools for RAG-style Q\&A and content browsing to assist with drafting RFPs and value propositions.

TanukiMCP

A comprehensive MCP server for WordPress automation that enables users to manage content, themes, and site configurations using AI-driven workflows and the WordPress REST API. It provides a wide array of tools for site planning, management, and optimization compatible with tools like Cursor and Claude.

Begagnad MCP

Enables AI agents to search and retrieve listings from Sweden's largest second-hand marketplaces, Blocket and Tradera. Returns unified data including prices, images, seller information, and direct links to listings.

mcp-gitlab

mcp-gitlab

Maven Version Server

An MCP server for managing Maven dependency versions using direct metadata parsing from Maven Central. It provides tools to fetch latest stable versions, list version history, and compare versions with upgrade recommendations.

Interactive Automation MCP Server

A comprehensive Model Context Protocol server that enables Claude Code to perform expect/pexpect-style automation for interactive programs, supporting complex interactions with terminal programs, SSH sessions, databases, and debugging workflows.

Dice Rolling MCP Server

Provides cryptographically secure random dice rolls for AI assistants, supporting standard and advanced dice notation for tabletop RPGs and games.

MCP PC Control Server

Provides comprehensive PC control capabilities including file operations (read, write, edit, delete), directory management, file search, and shell command execution through the Model Context Protocol.

uptodoc

Enables AI assistants in IDEs to query custom documentation databases for more relevant and up-to-date information about libraries and frameworks. Improves coding suggestions by providing project-specific documentation through a configurable endpoint.

Codex LSP Bridge

Exposes Language Server Protocol (LSP) features as MCP tools, enabling IDE-grade semantic navigation including go-to-definition, find references, hover info, and symbols across multiple programming languages (Python, Rust, C/C++, TypeScript/JavaScript, React, HTML, CSS).

Limitless MCP Server

Provides advanced analysis of conversations from Limitless Pendant recordings, including intelligent meeting detection, action item extraction, natural language time queries, and comprehensive conversation analytics with smart pagination support.

FastAPI MCP Application

A REST API built with FastAPI that exposes endpoints via Model Context Protocol (MCP), allowing clients to interact with CRUD operations through MCP interfaces.

programmatic-mcp

A meta MCP server that orchestrates other MCP servers by lazily connecting to them and exposing their tools as JavaScript libraries. It allows users to execute JavaScript code that programmatically interacts with multiple MCP servers within a unified environment.

Physics MCP Server

Provides 55 specialized tools for precise physics calculations and rigid-body simulations, covering mechanics, fluid dynamics, and rotational motion. It enables LLMs to perform realistic motion analysis and trajectory modeling with support for real-world factors like drag, wind, and altitude.

Clinical Trials MCP Server

Enables searching and querying clinical trials from ClinicalTrials.gov with intelligent filtering for recruiting studies, geographic search, and detailed trial information including contacts and eligibility criteria.

ChainAware Behavioural Prediction MCP Server

The Behavioural Prediction MCP Server provides AI-powered tools to analyze wallet behaviour prediction,fraud detection and rug pull prediction.

Paper MCP Server

An MCP server that connects to the Paper WebSocket API for managing canvas node operations. It enables users to list, create, update, and delete nodes and documents on the Paper platform.

Seats.aero Cloudflare MCP

Enables the deployment of a remote Model Context Protocol server on Cloudflare Workers for flight availability searches via seats.aero. It provides a framework for hosting MCP tools that can be accessed by local clients or the Cloudflare AI Playground.

free-web-search-ultimate

Universal Search-First Knowledge Acquisition Plugin for LLMs. Enables real-time web search and deep page browsing via MCP or CLI. Zero-cost, privacy-first, supports DuckDuckGo, Bing, Google, Brave, Wikipedia, Arxiv, YouTube, Reddit and more.

Teamwork

Official Teamwork.com MCP server.