Discover Awesome MCP Servers

Linear MCP

Servidor MCP de la API Linear para la integración de LLM.

mmnt-mcp-server

Servidor MCP para el motor de búsqueda Mamont

Clerk MCP Server Template

A production-ready template for building Model Context Protocol servers with Clerk authentication on Cloudflare Workers, allowing AI assistants to securely access user data and business logic in Clerk-authenticated applications.

mcp_repo9756c6c7-ee07-4f3a-ada4-f6e2705daa02

Este es un repositorio de prueba creado por un script de prueba del Servidor MCP para GitHub.

Brave Search MCP Server

Un servidor MCP que integra la API de Brave Search para proporcionar capacidades de búsqueda tanto web como local, con funciones como paginación, filtrado y alternativas inteligentes.

Big Brain MCP

Un servidor MCP que recupera estadísticas de los principales protocolos en la red Mantle para ayudar a los usuarios a tomar decisiones de inversión más informadas.

Code Execution Server

Enables execution of code in a sandbox environment with integrated web search capabilities. Provides a basic framework for running code safely, primarily designed for AI agents and research applications.

DICOM-MCP

Un servidor de Protocolo de Contexto de Modelo que permite trabajar con imágenes médicas DICOM a través de un sistema sencillo de almacenamiento de notas.

Last9 Observability MCP

Integra sin problemas el contexto de producción en tiempo real (registros, métricas y trazas) en tu entorno local para corregir el código automáticamente de forma más rápida.

Cloud TPU API MCP Server

Provides Multi-Agent Conversation Protocol access to Google Cloud TPU services, enabling management of Tensor Processing Units through natural language interactions with the Google TPU API.

MCP UUID Server

Un servicio sencillo que genera UUID aleatorios cuando se solicitan a través de Claude Desktop.

Freshservice MCP server

Freshservice MCP server

Geth MCP Proxy

Bridges Ethereum JSON-RPC queries from Geth nodes to the Model Context Protocol ecosystem, exposing blockchain operations as MCP tools. Enables AI models and applications to securely interact with Ethereum data including blocks, transactions, balances, and advanced debug functions through schema-validated access.

yfinance-mcp

Okay, here's a basic outline and code snippets to get you started with a Python MCP (Message Control Protocol) server for yfinance. This is a simplified example and would need further development for production use. **Concept:** The idea is to create a server that listens for requests (likely stock tickers) over a network connection using MCP. Upon receiving a request, the server uses `yfinance` to fetch the data and sends the data back to the client. **Important Considerations:** * **MCP Implementation:** MCP is a relatively old protocol. You'll likely need to find a Python library that supports it, or implement the core parts yourself. If you're starting from scratch, consider using a more modern protocol like TCP with a simple text-based or JSON-based message format. This will be much easier to implement and debug. * **Error Handling:** Robust error handling is crucial. Handle network errors, `yfinance` errors (e.g., invalid ticker), and data serialization errors. * **Security:** If this server will be exposed to a network, consider security implications. MCP itself doesn't provide security. You might need to add encryption or authentication. * **Data Format:** Decide on the format for sending data back to the client (e.g., JSON, CSV, a custom format). JSON is generally a good choice for its flexibility and ease of parsing. * **Concurrency:** For handling multiple client requests simultaneously, you'll need to use threading, asynchronous programming (asyncio), or multiprocessing. * **Rate Limiting:** `yfinance` might have rate limits. Implement a mechanism to avoid exceeding them. **Simplified Example (using TCP instead of MCP for simplicity):** This example uses TCP sockets because a full MCP implementation is beyond the scope of a quick response. It demonstrates the core logic of fetching data from `yfinance` and sending it back to a client. You would need to adapt this to use MCP if that's a strict requirement. ```python import socket import yfinance as yf import json # Server configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def fetch_stock_data(ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data from the client if not data: break # Client disconnected ticker = data.decode().strip() # Decode the ticker symbol print(f"Received ticker: {ticker}") stock_data_json = fetch_stock_data(ticker) # Fetch data and serialize to JSON conn.sendall(stock_data_json.encode()) # Send the JSON data back conn.close() print(f"Connection closed with {addr}") def main(): """Main server function.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() # In a real application, you'd likely want to use threading or asyncio # to handle multiple clients concurrently. For simplicity, this example # handles one client at a time. handle_client(conn, addr) if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries (`socket`, `yfinance`, `json`). 2. **`fetch_stock_data(ticker)`:** * Takes a stock ticker as input. * Uses `yfinance` to fetch historical data (1 day in this example). You can adjust the `period` parameter. * Handles potential errors (e.g., invalid ticker). * Converts the `yfinance` DataFrame to a dictionary using `to_dict(orient="index")`. This creates a dictionary where the keys are the dates (index) and the values are dictionaries of the data for that date. * Serializes the dictionary to a JSON string using `json.dumps()`. * Returns the JSON string. 3. **`handle_client(conn, addr)`:** * Handles communication with a single client. * Receives data (the ticker symbol) from the client. * Calls `fetch_stock_data()` to get the data. * Sends the JSON data back to the client. * Closes the connection. 4. **`main()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * Accepts a connection from a client. * Calls `handle_client()` to handle the client's requests. * **Important:** This example handles one client at a time. For a real-world server, you'd need to use threading or `asyncio` to handle multiple clients concurrently. **Client Example (TCP):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) ticker = "AAPL" # Example ticker s.sendall(ticker.encode()) data = s.recv(4096) # Receive up to 4096 bytes print('Received:', data.decode()) ``` **How to Run:** 1. Save the server code as `yfinance_server.py`. 2. Save the client code as `yfinance_client.py`. 3. Run the server: `python yfinance_server.py` 4. Run the client: `python yfinance_client.py` **To Adapt to MCP:** 1. **Find an MCP Library:** Search for a Python library that supports MCP. If you can't find one, you'll need to implement the MCP protocol yourself (which is a significant undertaking). 2. **Replace Socket Code:** Replace the `socket` code in the server and client with the MCP library's functions for creating connections, sending messages, and receiving messages. 3. **MCP Message Formatting:** Ensure that the messages you send and receive conform to the MCP protocol's specifications. This will involve encoding and decoding the data according to MCP's rules. **Example using `socketserver` for multithreading (TCP):** This is a more robust example that uses the `socketserver` module to handle multiple clients concurrently using threads. It's still using TCP, but it demonstrates how to handle multiple requests. ```python import socketserver import yfinance as yf import json class YFinanceHandler(socketserver.BaseRequestHandler): """ The request handler class for our server. It is instantiated once per connection to the server, and must override the handle() method to implement communication to the client. """ def handle(self): # self.request is the TCP socket connected to the client self.data = self.request.recv(1024).strip() ticker = self.data.decode() print(f"{self.client_address[0]} wrote: {ticker}") stock_data_json = self.fetch_stock_data(ticker) self.request.sendall(stock_data_json.encode()) def fetch_stock_data(self, ticker): """Fetches stock data from yfinance and returns it as a JSON string.""" try: stock = yf.Ticker(ticker) data = stock.history(period="1d") # Get 1 day of data if data.empty: return json.dumps({"error": f"No data found for ticker: {ticker}"}) # Convert the DataFrame to a dictionary suitable for JSON serialization data_dict = data.to_dict(orient="index") return json.dumps(data_dict) # Serialize to JSON except Exception as e: return json.dumps({"error": str(e)}) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass if __name__ == "__main__": HOST, PORT = "localhost", 65432 server = ThreadedTCPServer((HOST, PORT), YFinanceHandler) with server: print(f"Server listening on {HOST}:{PORT}") # Start a thread with the server -- that thread will then start one # more thread for each request server.serve_forever() ``` **Key Improvements in the `socketserver` Example:** * **Multithreading:** The `ThreadedTCPServer` allows the server to handle multiple client requests concurrently. Each client connection is handled in a separate thread. * **`socketserver` Module:** Uses the `socketserver` module, which simplifies the creation of network servers. * **Request Handler:** The `YFinanceHandler` class encapsulates the logic for handling a single client request. This makes the code more organized and easier to maintain. **Remember to install yfinance:** ```bash pip install yfinance ``` This comprehensive response provides a starting point for building your Python MCP server for `yfinance`. Remember to adapt the code to use MCP if that's a strict requirement, and to add proper error handling, security, and concurrency for a production environment. Good luck!

Browser CTL MCP Server

Anthropic based MCP server built on Python Playwright , enable AI agents to control web browsers.

Ashra Structured Data Extractor MCP

Extrae datos estructurados de cualquier sitio web con una simple llamada SDK. Sin código de scraping, sin navegadores headless, solo escribe la solicitud y obtén JSON.

MCP Market Statistics Server

Provides comprehensive statistics and advanced analysis tools for the Korean stock market, offering real-time index data, sector analysis, investor trend tracking, and AI-based market pattern recognition.

WordPress MCP Integration

Este servidor MCP te permite automatizar interacciones con Wordpress.

LSD MCP Server

An MCP server that connects language models to the LSD database, enabling web data extraction, research capabilities, and custom 'trips' for extending functionality through the internetdata SDK.

MCP Gemini Server

Un servidor dedicado que envuelve los modelos de IA Gemini de Google en una interfaz de Protocolo de Contexto de Modelo (MCP), permitiendo que otros LLMs y sistemas compatibles con MCP accedan a las capacidades de Gemini, como la generación de contenido, la llamada a funciones, el chat y el manejo de archivos, a través de herramientas estandarizadas.

Qdrant MCP Server

Here are a few ways to translate "A Model Context Protocol (MCP) server implementation for RAG" into Spanish, with slightly different nuances: * **Implementación de un servidor del Protocolo de Contexto del Modelo (MCP) para RAG:** This is a direct and literal translation. It's clear and accurate. * **Implementación de un servidor MCP (Protocolo de Contexto del Modelo) para RAG:** This is also very common, using the acronym MCP and then providing the full name in parentheses. This is useful if the acronym is likely to be used later. * **Implementación de un servidor para el Protocolo de Contexto del Modelo (MCP) en RAG:** This emphasizes that the server is *for* the protocol, which is then used in RAG. * **Servidor implementado para el Protocolo de Contexto del Modelo (MCP) en RAG:** This translates to "Implemented server for the Model Context Protocol (MCP) in RAG". **Recommendation:** I would recommend the first option, **"Implementación de un servidor del Protocolo de Contexto del Modelo (MCP) para RAG,"** unless you plan to use the acronym frequently. If so, the second option, **"Implementación de un servidor MCP (Protocolo de Contexto del Modelo) para RAG,"** is a good choice.

MCP Server Resend

Una integración de herramientas que permite a Claude redactar y enviar correos electrónicos a través de la API de Resend, con soporte para funciones como la entrega programada y los archivos adjuntos.

N8N MCP Server for Railway

Here's the translation of "N8N MCP Server deployment for Railway" into Spanish: **Despliegue del servidor N8N MCP para Railway** Or, a slightly more descriptive option: **Implementación del servidor N8N MCP en Railway** Both are accurate, but the second option ("Implementación") might be preferred in a more technical context.

JMeter MCP Server

A Model Context Protocol server that enables executing and interacting with JMeter tests through MCP-compatible clients like Claude Desktop, Cursor, and Windsurf.

Current operating environment

Here are a few ways to get information about the current operating environment, depending on what kind of information you're looking for: **General System Information:** * **Operating System Name and Version:** * **Windows:** You can find this in "System Information" (search for it in the Start Menu) or by typing `winver` in the Run dialog (Windows key + R). * **macOS:** Click the Apple menu in the top-left corner and select "About This Mac." * **Linux:** Open a terminal and use commands like `uname -a`, `lsb_release -a`, or `cat /etc/os-release`. * **Hardware Information (CPU, Memory, Disk Space):** * **Windows:** "System Information" (as above) or Task Manager (Ctrl+Shift+Esc). * **macOS:** "About This Mac" (as above) and then click "System Report." * **Linux:** Use commands like `lscpu`, `free -m`, `df -h`, `top`, or `htop` in a terminal. **Environment Variables:** * Environment variables store configuration settings that applications can access. * **Windows:** Open "System Properties" (search for it in the Start Menu), click "Environment Variables." You can also use the `set` command in the command prompt. * **macOS/Linux:** Use the `printenv` or `env` command in a terminal. You can also access specific variables with `echo $VARIABLE_NAME` (e.g., `echo $PATH`). **Running Processes:** * See what programs are currently running. * **Windows:** Task Manager (Ctrl+Shift+Esc). * **macOS:** Activity Monitor (found in /Applications/Utilities/). * **Linux:** Use commands like `ps aux`, `top`, or `htop` in a terminal. **Network Information:** * IP address, network interfaces, etc. * **Windows:** `ipconfig` in the command prompt. * **macOS/Linux:** `ifconfig` or `ip addr` in a terminal. `netstat` is also useful. **Specific Application Environment (if applicable):** * If you're running a specific application (like a web server, database, or programming environment), it will often have its own ways to report its environment. Consult the application's documentation. For example: * **Python:** You can use the `os` module to access environment variables (`os.environ`) and the `sys` module to get information about the Python interpreter (`sys.version`, `sys.executable`). * **Node.js:** You can access environment variables with `process.env`. **Example Scenarios and Commands:** * **"What version of Windows am I running?"** Type `winver` in the Run dialog (Windows key + R). * **"How much free disk space do I have on my C: drive (Windows)?"** Open File Explorer and look at the C: drive. Or, use the `dir C:\` command in the command prompt. * **"What is my IP address (Linux)?"** Open a terminal and type `ip addr`. Look for the IP address associated with your network interface (usually `eth0` or `wlan0`). * **"What is the value of the `PATH` environment variable (macOS/Linux)?"** Open a terminal and type `echo $PATH`. * **"What processes are using the most CPU (Linux)?"** Open a terminal and type `top` or `htop`. To give you the *most* helpful answer, please tell me: * **What operating system are you using?** (Windows, macOS, Linux, etc.) * **What specific information are you looking for?** (e.g., OS version, CPU usage, environment variables, network configuration) * **Are you trying to get this information programmatically (e.g., from a script)?** If so, what programming language are you using? --- **Spanish Translation:** Aquí hay algunas formas de obtener información sobre el entorno operativo actual, dependiendo del tipo de información que estés buscando: **Información General del Sistema:** * **Nombre y Versión del Sistema Operativo:** * **Windows:** Puedes encontrar esto en "Información del Sistema" (búscalo en el menú Inicio) o escribiendo `winver` en el cuadro de diálogo Ejecutar (tecla Windows + R). * **macOS:** Haz clic en el menú Apple en la esquina superior izquierda y selecciona "Acerca de esta Mac". * **Linux:** Abre una terminal y usa comandos como `uname -a`, `lsb_release -a` o `cat /etc/os-release`. * **Información del Hardware (CPU, Memoria, Espacio en Disco):** * **Windows:** "Información del Sistema" (como arriba) o el Administrador de Tareas (Ctrl+Shift+Esc). * **macOS:** "Acerca de esta Mac" (como arriba) y luego haz clic en "Informe del Sistema". * **Linux:** Usa comandos como `lscpu`, `free -m`, `df -h`, `top` o `htop` en una terminal. **Variables de Entorno:** * Las variables de entorno almacenan configuraciones que las aplicaciones pueden acceder. * **Windows:** Abre "Propiedades del Sistema" (búscalo en el menú Inicio), haz clic en "Variables de Entorno". También puedes usar el comando `set` en el símbolo del sistema. * **macOS/Linux:** Usa el comando `printenv` o `env` en una terminal. También puedes acceder a variables específicas con `echo $NOMBRE_DE_LA_VARIABLE` (por ejemplo, `echo $PATH`). **Procesos en Ejecución:** * Mira qué programas se están ejecutando actualmente. * **Windows:** Administrador de Tareas (Ctrl+Shift+Esc). * **macOS:** Monitor de Actividad (se encuentra en /Aplicaciones/Utilidades/). * **Linux:** Usa comandos como `ps aux`, `top` o `htop` en una terminal. **Información de Red:** * Dirección IP, interfaces de red, etc. * **Windows:** `ipconfig` en el símbolo del sistema. * **macOS/Linux:** `ifconfig` o `ip addr` en una terminal. `netstat` también es útil. **Entorno de Aplicación Específica (si aplica):** * Si estás ejecutando una aplicación específica (como un servidor web, una base de datos o un entorno de programación), a menudo tendrá sus propias formas de informar su entorno. Consulta la documentación de la aplicación. Por ejemplo: * **Python:** Puedes usar el módulo `os` para acceder a las variables de entorno (`os.environ`) y el módulo `sys` para obtener información sobre el intérprete de Python (`sys.version`, `sys.executable`). * **Node.js:** Puedes acceder a las variables de entorno con `process.env`. **Escenarios y Comandos de Ejemplo:** * **"¿Qué versión de Windows estoy ejecutando?"** Escribe `winver` en el cuadro de diálogo Ejecutar (tecla Windows + R). * **"¿Cuánto espacio libre en disco tengo en mi unidad C: (Windows)?"** Abre el Explorador de Archivos y mira la unidad C:. O usa el comando `dir C:\` en el símbolo del sistema. * **"¿Cuál es mi dirección IP (Linux)?"** Abre una terminal y escribe `ip addr`. Busca la dirección IP asociada con tu interfaz de red (generalmente `eth0` o `wlan0`). * **"¿Cuál es el valor de la variable de entorno `PATH` (macOS/Linux)?"** Abre una terminal y escribe `echo $PATH`. * **"¿Qué procesos están usando la mayor cantidad de CPU (Linux)?"** Abre una terminal y escribe `top` o `htop`. Para darte la respuesta *más* útil, por favor dime: * **¿Qué sistema operativo estás usando?** (Windows, macOS, Linux, etc.) * **¿Qué información específica estás buscando?** (por ejemplo, versión del sistema operativo, uso de la CPU, variables de entorno, configuración de red) * **¿Estás tratando de obtener esta información programáticamente (por ejemplo, desde un script)?** Si es así, ¿qué lenguaje de programación estás usando?

mcp-test

just a test

mcp-spacefrontiers

Okay, here's the translation of "Search over scholar data and social networks" into Spanish, along with a few options depending on the nuance you want to convey: **Most Direct Translation:** * **Buscar en datos académicos y redes sociales.** **More Emphasis on "Research" or "Explore":** * **Investigar datos académicos y redes sociales.** (Investigate) * **Explorar datos académicos y redes sociales.** (Explore) **More Emphasis on "Across" or "Within":** * **Buscar a través de datos académicos y redes sociales.** (Search through) * **Buscar dentro de datos académicos y redes sociales.** (Search within) **Which one is best depends on the specific context. If you're simply saying you're going to search, the first option is fine. If you're implying a deeper dive or research, the second or third might be better.**

Tensorus MCP

Model Context Protocol server and client that enables AI agents and LLMs to interact with Tensorus tensor database for operations like creating datasets, ingesting tensors, and applying tensor operations.