Discover Awesome MCP Servers

RAG_MCP

A Retrieval-Augmented Generation server that enables semantic PDF search with OCR capabilities, allowing users to query document content through any MCP client and receive intelligent answers.

Rubber Duck MCP

Brings rubber duck debugging to AI-powered IDEs by providing a tool for articulating problems and clarifying logic in natural language. It helps developers and AI agents reveal hidden assumptions and surface solutions through structured self-explanation and reflection.

Wellness Pulse

WellPulse MCP is a privacy-first AI layer that transforms wellbeing data into real-time insights, benchmarks, and actionable summaries for faster decision-making.

freee会計 MCP Server

Enables AI assistants to access and manage accounting data through the freee accounting API, supporting operations like transaction management, financial analysis, and account item management.

RAPID MCP Server

A local server that provides powerful code analysis and search capabilities for software projects, helping AI assistants and development tools understand codebases for tasks like code generation and refactoring.

PersonalMcp

Repositorio para la configuración personal del servidor mcp

Cortex Resource Manager

Manages resource allocation, MCP server lifecycle, and Kubernetes workers in cortex automation systems. Provides tools for requesting/releasing job resources, starting/stopping/scaling MCP servers, and provisioning/destroying burst workers with TTL management.

Atlassian MCP Server

Enables AI assistants to interact with Jira by executing commands through the Atlassian CLI. It supports searching issues with JQL, managing comments, updating statuses, and handling issue assignments through natural language.

Weather MCP Server

Provides real-time weather data and current conditions for major Chinese cities and global locations using the wttr.in API. This HelloAgents-based server enables querying of temperature, humidity, and weather status without requiring an external API key.

MCP ASCII Charts

A Model Context Protocol server that generates lightweight ASCII charts directly in terminal environments, supporting line charts, bar charts, scatter plots, histograms, and sparklines without GUI dependencies.

d2-mcp

Enables AI assistants to compile, validate, and explore D2 diagrams using the official D2 WASM package. It provides tools for generating SVGs with custom layouts, themes, and icons directly from D2 source code.

mcp-remote-server

A Model Context Protocol server that provides tools for fetching xkcd comics and resources for dynamic data retrieval, WebSocket echo functionality, and static JSON data testing.

Custom MCP Servers

Servidores MCP personalizados

MCP Pentest

An automated penetration testing framework that enables intelligent security assessments through reconnaissance, vulnerability scanning, and controlled exploitation. Features AI-driven workflow management with comprehensive reporting for authorized security testing.

Anki MCP Server

Enables AI assistants to manage Anki flashcard collections by creating, searching, and updating cards through a standardized interface. It supports media handling, batch operations, and review scheduling via the AnkiConnect add-on.

Progressive Skills MCP

MCP server implementing progressive disclosure for skill instructions, loading skills on-demand for token efficiency.

act-testing-mcp

MCP server for testing GitHub Actions workflows locally using nektos/act.

Money Lover MCP Server

Enables AI assistants to query and manage personal finance data through the unofficial Money Lover REST API. It provides 27 tools covering authentication, wallets, categories, transactions, events, debts, and static configuration with both read and write capabilities.

Xero MCP Server by CData

Xero MCP Server by CData

mcp-dev-record

A dedicated MCP (Model Context Protocol) server for recording and organizing conversation content, providing templated recording functionality.

Feishu Access Token MCP

Manages and automatically refreshes Feishu (Lark) app access tokens and user access tokens, enabling secure authentication with Feishu APIs through session-based configuration.

CallHub

CallHub MCP is a Python-based tool that allows you to interact with the CallHub API through Claude. This tool provides a comprehensive set of functions for managing contacts, phonebooks, agents, teams, campaigns, and other CallHub resources.

inspect-logs-mcp

Enables LLMs to explore and analyze UK Government BEIS inspect_ai evaluation logs directly from tools like Claude Code and Cursor. It provides capabilities to list logs, view evaluation summaries, and inspect conversation histories for specific samples.

MySQL MCP Server

Provides MySQL database integration for AI assistants and other MCP clients, allowing them to list tables, read table data, and execute SQL queries.

YearAtAGlance MCP Server

Integrates the YearAtAGlance calendar with AI assistants to manage events, categories, and event density heatmaps. It enables users to perform CRUD operations on calendar data and utilize AI-powered features like natural language milestone creation and yearly analysis.

TradingView MCP Bridge

Personal AI assistant for your TradingView Desktop charts. Connects Claude Code to your locally running TradingView app via Chrome DevTools Protocol for AI-assisted chart analysis, Pine Script development, and workflow automation.

Test MCP Server

A dual-transport MCP server that exposes your API as tools to LLM clients, supporting both stdio transport for local clients like Claude Desktop and HTTP/SSE transport for remote clients like OpenAI's Responses API.

Zillow56 MCP Server

Enables access to the Zillow56 API to search for real estate listings and rental market trends using locations, coordinates, or specific property filters. It also provides comprehensive housing market snapshots and historical data based on the Zillow Home Value Index (ZHVI).

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.

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.