Discover Awesome MCP Servers

MCP Vertica

Enables interaction with Vertica databases through SQL queries, schema management, and bulk data operations. Supports connection pooling, SSL/TLS security, and configurable permissions for database operations.

Google Drive MCP Server by CData

Google Drive MCP Server by CData

MCP Server Boilerplate

A starter template for building custom MCP (Model Context Protocol) servers that can integrate with Claude, Cursor, or other MCP-compatible AI assistants. Provides a clean foundation with TypeScript support, example implementations, and installation scripts for quickly creating custom tools, resources, and prompts.

Jokes MCP Server

An MCP server that provides jokes to Microsoft Copilot Studio, demonstrating how to deploy a Model Context Protocol server that delivers Chuck Norris and Dad jokes upon request.

Perplexity MCP Server

Servidor MCP que permite a Claude solicitar finalizaciones de chat con citas de la API de Perplexity.

Inventory MCP Server

Manages inventory operations using Supabase/PostgreSQL database, enabling users to add, remove, check stock levels, and list inventory items across multiple locations.

Newsbang MCP

Newsbang MCP is a powerful Model Context Protocol (MCP) server that provides access to real-time news intelligence through three essential tools: get_today_top_news,search_news,get_news_deep_report_and_analysis

Test MCP Server

Repositorio de prueba para la funcionalidad del servidor MCP.

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.

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

Microsoft Graph MCP Server

Provides read-only access to Microsoft 365 services including SharePoint, OneDrive, Outlook, Teams, and Calendar through the Microsoft Graph API, enabling users to search, browse, and retrieve content across their M365 suite.

Ant Design MCP Server

Fetches and structures Ant Design v4 component documentation into JSON format, enabling AI agents to search, analyze, and retrieve component metadata, APIs, and examples.

Stacks Clarity MCP Server

Enables comprehensive Stacks blockchain development with 30+ specialized tools for Clarity smart contracts, SIP compliance, security analysis, and performance optimization. Provides complete access to SIP standards, token development templates, security-first patterns with mandatory post-conditions, and full-stack dApp development guidance.

Typesense MCP Server

Espejo de

MCP Forensic Toolkit

A secure, AI-ready local server that provides digital forensics tools for analyzing logs, verifying file integrity, and generating audit-grade reports.

ens-mcp

About An MCP server that resolves, analyzes, and contextualizes ENS domain activity.

Coda MCP Server

A Model Context Protocol server that enables AI assistants to interact with Coda documents, allowing operations like listing, creating, reading, updating, and duplicating pages.

MCP Ping Server

Provides a ping tool to check connectivity and measure latency to any hostname or IP address across platforms.

Ref

Ref

mcp-server-zenn: Unofficial MCP server for Zenn (

Espejo de

Tokyo WBGT MCP Server

Provides access to Tokyo's WBGT (Wet Bulb Globe Temperature) heat index forecast and real-time data from multiple observation points using Japan's Ministry of the Environment official data for heat stroke prevention.

xmcp Application

A template/starter project for building MCP servers with structured directories for tools, prompts, and resources that are automatically discovered and registered.

GitLab Forum MCP

Enables searching, reading, and analyzing discussions on GitLab's community forum for troubleshooting CI/CD issues and GitLab features. Pre-configured with GitLab-specific search filters and optimized workflows for support scenarios.

MCP Translation Text

Provides text translation capabilities powered by NiuTrans API with support for 455+ languages. Includes translation tools and language catalog resources for seamless integration with MCP clients.

Carla MCP Server

Enables complete control over the Carla audio plugin host through natural language, providing 45 tools across session management, plugin control, audio routing, parameter automation, and real-time analysis for professional audio production workflows.

ClipToWSL MCP Server

Enables AI coding agents like Claude to read Windows clipboard contents (text and images) from within WSL environments, providing seamless cross-platform clipboard access through the Model Context Protocol.