Discover Awesome MCP Servers

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.

🤖 nostr-code-snippet-mcp

Here are a few ways to interpret "code snippet mcp server" and their corresponding Spanish translations, along with some context: **1. Assuming "MCP" refers to the Minecraft Protocol (used for Minecraft servers):** * **English:** Code snippet for a Minecraft server. * **Spanish:** Fragmento de código para un servidor de Minecraft. (More general) * **Spanish:** Snippet de código para un servidor de Minecraft. (Using the English word "snippet" which is common in programming) * **Spanish:** Trozo de código para un servidor de Minecraft. (Less common, but still correct) **2. Assuming "MCP" refers to a Mod Configuration Protocol (or similar, less common protocol):** * **English:** Code snippet for an MCP server (assuming MCP is a specific protocol). * **Spanish:** Fragmento de código para un servidor MCP (assuming MCP is a specific protocol). * **Spanish:** Snippet de código para un servidor MCP (assuming MCP is a specific protocol). **3. Assuming "MCP" is an abbreviation for something else entirely (without context, this is difficult to know):** * **English:** Code snippet for an MCP server (where MCP is unknown). * **Spanish:** Fragmento de código para un servidor MCP (donde MCP es desconocido). * **Spanish:** Snippet de código para un servidor MCP (donde MCP es desconocido). **Important Considerations:** * **Context is Key:** The best translation depends entirely on what "MCP" refers to. If you can provide more context about what "MCP" means in your situation, I can give you a much more accurate translation. * **"Snippet" vs. "Fragmento":** The word "snippet" is often used directly in Spanish programming contexts, especially among programmers familiar with English terminology. "Fragmento" is a more general Spanish word for "fragment." * **"Trozo":** While correct, "trozo" is less common in technical contexts. **Example with more context (assuming Minecraft):** * **English:** "I need a code snippet to handle player connections on my Minecraft server." * **Spanish:** "Necesito un fragmento de código para manejar las conexiones de jugadores en mi servidor de Minecraft." * **Spanish:** "Necesito un snippet de código para manejar las conexiones de jugadores en mi servidor de Minecraft." Therefore, to give you the *best* translation, please provide more information about what "MCP" means in your context.

MCP Git Server

A Model Context Protocol server that enables LLMs to interact with Git repositories, providing tools to read, search, and manipulate Git repositories through commands like status, diff, commit, and branch management.

Government of Canada Open Data MCP Servers

Provides access to 250,000+ Canadian government datasets and specialized querying of transportation infrastructure including bridges, airports, cycling networks, transit systems, railways, and tunnels across multiple provinces.

MultiBaas MCP Server

Enables AI assistants to interact with blockchain data and smart contracts through Curvegrid's MultiBaas platform, providing seamless access to blockchain operations and contract functionality.

Outscraper MCP Server

A Model Context Protocol server that provides access to Outscraper's data extraction services, implementing 8 tools for extracting data from Google services and domains including Maps, Reviews, Search, and contact information.

Lemonade Stand MCP Server

A Model Context Protocol server that enables Claude Desktop to play the classic Lemonade Stand business simulation game with dynamic weather, pricing strategies, and inventory management.

OpenReview MCP Server

Connects Claude to OpenReview to facilitate conference reviewer and area chair workflows through the Model Context Protocol. It enables users to manage paper assignments, read submissions and reviews, and perform write actions like submitting reviews or comments using a preview-and-confirm system.

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.

Orbination AI Desktop Vision & Control

Native Windows MCP server that gives AI agents full desktop control. 45+ tools using UIAutomation + OCR with automatic dark theme enhancement instead of screenshots. Features batch action sequencing (run_sequence), window occlusion detection, menu navigation, PrintWindow capture, and embedded AI workflow instructions. Single .NET 8 executable — no Python, no Node, no Selenium.

🚀 Model Context Protocol (MCP) Server Python Template 🐍

Espejo de

MCP + LangGraph Agent

Okay, I understand. Please provide me with the English text of the LangGraph agent tutorial that you want me to adapt for use with MCP (presumably referring to a specific type of server or configuration). I will then translate the adapted text into Spanish. **Important Considerations Before You Provide the Text:** * **What is MCP?** Please provide more context about what "MCP servers" refers to. Knowing the specific technology or platform will allow me to make more accurate and relevant adaptations. For example, is it a specific cloud provider, a type of database, or a custom server setup? * **What adaptations are needed?** Be as specific as possible about the changes required to make the tutorial work with MCP servers. For example: * Are there different connection strings or authentication methods? * Do you need to use specific libraries or APIs? * Are there any performance considerations or limitations? * **Target Audience:** Who is the intended audience for this translated tutorial? Knowing their level of technical expertise will help me choose the appropriate vocabulary and level of detail. Once you provide the English text and the necessary details about MCP and the required adaptations, I will: 1. **Adapt the English text** to incorporate the MCP-specific information. 2. **Translate the adapted English text into Spanish.** 3. **Provide the Spanish translation to you.** I look forward to helping you with this!

juba-mcp

An MCP server for searching the Jurisprudencia de Buenos Aires (JUBA) database for legal summaries and full-text judicial rulings. It enables AI assistants to perform advanced searches across various legal matters from the Supreme Court of the Province of Buenos Aires.

infomesh

Fully decentralized P2P web search engine for LLMs. Crawls, indexes, and searches the web via a peer-to-peer network — no API key, no billing. Exposes 5 MCP tools: web_search, fetch_page, crawl_url, fact_check, and status.

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.

Basic Math MCP Server

A simple server that provides basic mathematical operations (sum and subtraction) through the Model Context Protocol.

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.

SME Copilot MCP Server

Generates business action reports for SMEs by retrieving company profiles through web search and LLM summarization, combining legal articles from e-Gov API and regional statistics from e-Stat API.

mcp-turo

An MCP server for automating Turo peer-to-peer car rental interactions using stealth browser automation. It enables users to search for vehicles, view detailed listing and host information, and create or manage car bookings.

FEGIS

FEGIS es un servidor de Protocolo de Contexto de Modelos que proporciona a los LLM memoria estructurada, persistente y portátil a través de herramientas cognitivas personalizables definidas en un esquema.

my-mcp-server

Un prototipo que utiliza mcp-framework para construir herramientas para IAs.

Severalnines CCX MCP Server

Enables management of CCX database clusters through AI assistants, supporting operations such as datastore creation, scaling, and performance monitoring. It provides a comprehensive toolset for handling backups, database users, and firewall rules across various database engines including PostgreSQL, MySQL, and Redis.

Recursive Companion MCP

An MCP server that implements iterative refinement of responses through self-critique cycles, breaking the process into discrete steps to avoid timeouts and show progress.

Hyperion MCP Server

Enables seamless interaction with the Hyperion blockchain, including wallet management, token transactions, ERC20 token deployment, and smart contract operations through standardized MCP endpoints.

ProofBase MCP Server

An AI-powered server that generates realistic, customizable customer testimonials with specific tones, roles, and performance metrics. It enables users to create authentic social proof content through simple natural language prompts.

Race MCP Server

Enables AI-powered racing coaching and telemetry analysis for iRacing, providing real-time racing advice, car spotting, lap analysis, and conversational interaction with racing data through live telemetry streaming.

cloudflare-dns-mcp-server

A token-efficient MCP server for managing Cloudflare DNS zones and records with full CRUD support and bulk operations. It can be deployed locally via stdio or as a Cloudflare Worker for remote HTTP access.