Discover Awesome MCP Servers

mcp-simple-pubmed

Un servidor MCP que proporciona acceso a los artículos de PubMed a través de la API de Entrez.

PayPal MCP

Este es un servidor MCP para administrar PayPal.

IsItDown MCP Server

Un servidor MCP que permite a los usuarios verificar si un sitio web está experimentando inactividad consultando isitdownrightnow.com, proporcionando información de estado y detalles sobre eventos de inactividad recientes.

Calendar Tools MCP Server

Permite la gestión integral del calendario con la capacidad de crear, listar, actualizar y eliminar eventos a través de un servidor de Protocolo de Contexto de Modelo integrado con Google Calendar.

BlueSky MCP Server

Facilita la interacción con la red social BlueSky a través de su API oficial, permitiendo a los usuarios recuperar perfiles de usuario detallados y listas de seguidores con capacidades de autenticación y manejo de errores.

mcp-youtube-sheets

Proporciona la funcionalidad para buscar videos de YouTube y guardar automáticamente los resultados en Google Sheets.

Linear MCP Integration Server

Permite que los modelos de IA interactúen con Linear para el seguimiento de incidencias y la gestión de proyectos a través de capacidades como la creación/búsqueda de incidencias, la gestión de sprints y la recuperación de estados de flujo de trabajo.

MCPunk

Okay, I understand. I can translate that into Spanish: **"Interactúa con tu base de código a través de una búsqueda inteligente de código sin embeddings, dividiendo los archivos en fragmentos lógicos, proporcionando a la LLM herramientas para buscar en estos fragmentos y permitiéndole encontrar el código específico necesario para responder a tus preguntas."** Here's a breakdown of the translation to ensure accuracy: * **"Chat with your codebase"** becomes **"Interactúa con tu base de código"** (This is a direct and accurate translation) * **"through intelligent code searching"** becomes **"a través de una búsqueda inteligente de código"** (Again, a direct and accurate translation) * **"without embeddings"** becomes **"sin embeddings"** (The term "embeddings" is often used directly in Spanish in this context) * **"by breaking files into logical chunks"** becomes **"dividiendo los archivos en fragmentos lógicos"** (This accurately conveys the meaning of dividing files into meaningful sections) * **"giving the LLM tools to search these chunks"** becomes **"proporcionando a la LLM herramientas para buscar en estos fragmentos"** (This accurately describes giving the LLM the ability to search the chunks) * **"and letting it find specific code needed to answer your questions"** becomes **"y permitiéndole encontrar el código específico necesario para responder a tus preguntas"** (This accurately describes the LLM's task of finding the relevant code) The translation aims to be clear, concise, and technically accurate for a Spanish-speaking audience familiar with software development concepts.

Python Jira MCP Server

Una implementación de servidor que permite a los modelos de IA interactuar con Jira a través del Protocolo de Contexto del Modelo, habilitando tareas como búsquedas JQL y la recuperación de detalles de incidencias.

Strapi MCP Server

Proporciona acceso al contenido de Strapi CMS a través del protocolo MCP, permitiendo a los usuarios crear, leer, actualizar y eliminar entradas de contenido a través de Claude.

OpenDota MCP Server

Servidor de Protocolo de Contexto de Modelo que permite a los LLM y asistentes de IA recuperar estadísticas de Dota 2 en tiempo real, datos de partidas, información de jugadores y métricas de juego a través de una interfaz estandarizada.

FRED MCP Server

A Model Context Protocol server that provides tools to search and retrieve economic data series from the Federal Reserve Economic Data (FRED) API.

CoinGecko MCP Server

Permite la interacción con la API CoinGecko Pro para acceder a datos de criptomonedas, incluyendo el historial de precios y las métricas del mercado, a través de MCP y la función de llamada de OpenAI.

mcp-git-ingest

Ayuda a la IA a leer la estructura de un repositorio de GitHub y archivos importantes. ¿Quieres entender rápidamente de qué se trata un repositorio? Indícale con "lee https://github.com/adhikasp/mcp-git-ingest y determina cómo funciona técnicamente el código".

Gmail MCP Server

Permite la interacción con Gmail a través de la API de Gmail para leer, enviar y administrar correos electrónicos. Admite múltiples cuentas de Gmail con monitoreo en tiempo real y funciones avanzadas para la búsqueda de correos electrónicos y el manejo de archivos adjuntos.

Shopify MCP Server

Enables interaction with Shopify store data via GraphQL API, providing tools for managing products, customers, orders, discounts, and more with robust error handling.

AWS Resources MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a Claude ejecutar código Python usando boto3 para consultar y administrar recursos de AWS directamente desde las conversaciones.

GitHub Projects MCP Server

Permite a los usuarios interactuar con la API Projects v2 de GitHub a través del lenguaje natural para la gestión de proyectos Agile, con soporte para detalles del repositorio, seguimiento de incidencias y operaciones de gestión de paneles de proyecto.

Supabase MCP Server

Un servidor MCP que se conecta a bases de datos PostgreSQL de Supabase, exponiendo los esquemas de las tablas como recursos y proporcionando herramientas para el análisis de datos a través de consultas SQL.

Remote-MCP Server

Permite una comunicación bidireccional y con seguridad de tipos con los servicios del Protocolo de Contexto del Modelo, lo que permite la gestión centralizada de los contextos del modelo a través de HTTP.

unichat-ts-mcp-server

Envía solicitudes a OpenAI, MistralAI, Anthropic, xAI o Google AI utilizando el protocolo MCP a través de una herramienta o indicaciones predefinidas. Se requiere una clave API del proveedor. Se admiten mecanismos de transporte STDIO y SSE a través de argumentos.

MCP Server Template for Cursor IDE

Aquí tienes una plantilla para crear herramientas personalizadas para Cursor IDE utilizando el Protocolo de Contexto de Modelo (MCP), que permite a los desarrolladores extender la funcionalidad de Cursor con sus propias herramientas basadas en servidor: ```python # Importa las bibliotecas necesarias import asyncio import json import websockets # Define la dirección del servidor WebSocket SERVER_ADDRESS = "ws://localhost:8080" # Reemplaza con la dirección de tu servidor # Define la función principal para manejar la conexión WebSocket async def handle_connection(websocket): try: async for message in websocket: # Procesa el mensaje recibido del Cursor IDE data = json.loads(message) print(f"Mensaje recibido: {data}") # Determina el tipo de solicitud y llama a la función correspondiente request_type = data.get("type") if request_type == "context": await handle_context_request(websocket, data) elif request_type == "execute": await handle_execute_request(websocket, data) else: print(f"Tipo de solicitud desconocido: {request_type}") await send_error_response(websocket, "Tipo de solicitud desconocido") except websockets.exceptions.ConnectionClosedError: print("Conexión cerrada por el cliente.") except Exception as e: print(f"Error: {e}") # Función para manejar las solicitudes de contexto (obtener información del contexto del editor) async def handle_context_request(websocket, data): # Extrae la información relevante de la solicitud file_path = data.get("filePath") cursor_position = data.get("cursorPosition") selected_text = data.get("selectedText") print(f"Solicitud de contexto recibida para: {file_path}, posición: {cursor_position}, texto seleccionado: {selected_text}") # **AQUÍ VA LA LÓGICA DE TU HERRAMIENTA PARA ANALIZAR EL CONTEXTO** # Por ejemplo, podrías analizar el código en 'file_path' alrededor de 'cursor_position' # o utilizar 'selected_text' para realizar una búsqueda en una base de datos. # Simulación de una respuesta de contexto context_data = { "relevant_code": "def my_function():\n # Código relevante aquí", "documentation_link": "https://example.com/documentation" } # Envía la respuesta al Cursor IDE response = { "type": "contextResponse", "requestId": data.get("requestId"), # Importante: usa el mismo requestId "data": context_data } await websocket.send(json.dumps(response)) print(f"Respuesta de contexto enviada: {response}") # Función para manejar las solicitudes de ejecución (ejecutar una acción) async def handle_execute_request(websocket, data): # Extrae la información relevante de la solicitud action = data.get("action") parameters = data.get("parameters") print(f"Solicitud de ejecución recibida: acción: {action}, parámetros: {parameters}") # **AQUÍ VA LA LÓGICA DE TU HERRAMIENTA PARA EJECUTAR LA ACCIÓN** # Por ejemplo, podrías ejecutar un comando en el sistema operativo, # llamar a una API externa o modificar el código en el editor. # Simulación de una respuesta de ejecución execution_result = { "status": "success", "message": "Acción ejecutada correctamente." } # Envía la respuesta al Cursor IDE response = { "type": "executeResponse", "requestId": data.get("requestId"), # Importante: usa el mismo requestId "data": execution_result } await websocket.send(json.dumps(response)) print(f"Respuesta de ejecución enviada: {response}") # Función para enviar una respuesta de error async def send_error_response(websocket, error_message): response = { "type": "error", "message": error_message } await websocket.send(json.dumps(response)) print(f"Error enviado: {error_message}") # Función principal para iniciar el servidor WebSocket async def main(): async with websockets.serve(handle_connection, "localhost", 8080): print("Servidor WebSocket iniciado en ws://localhost:8080") await asyncio.Future() # Ejecuta el servidor indefinidamente # Inicia el bucle de eventos asíncrono if __name__ == "__main__": asyncio.run(main()) ``` **Explicación del código:** 1. **Importaciones:** Importa las bibliotecas `asyncio` para programación asíncrona, `json` para manejar datos JSON y `websockets` para la comunicación WebSocket. 2. **`SERVER_ADDRESS`:** Define la dirección del servidor WebSocket. **¡IMPORTANTE!** Asegúrate de que coincida con la configuración en Cursor IDE. 3. **`handle_connection(websocket)`:** Esta es la función principal que maneja cada conexión WebSocket entrante. - Recibe mensajes del Cursor IDE. - Deserializa el mensaje JSON. - Determina el tipo de solicitud (`context` o `execute`). - Llama a la función correspondiente para manejar la solicitud. - Envía una respuesta al Cursor IDE. - Maneja excepciones como `websockets.exceptions.ConnectionClosedError`. 4. **`handle_context_request(websocket, data)`:** Maneja las solicitudes de contexto. - Extrae información relevante del contexto del editor (ruta del archivo, posición del cursor, texto seleccionado). - **¡AQUÍ VA LA LÓGICA DE TU HERRAMIENTA!** Implementa la lógica para analizar el contexto y obtener la información que necesitas. - Crea una respuesta JSON con la información del contexto. - Envía la respuesta al Cursor IDE. **¡IMPORTANTE!** Utiliza el mismo `requestId` que la solicitud original. 5. **`handle_execute_request(websocket, data)`:** Maneja las solicitudes de ejecución. - Extrae la acción a ejecutar y los parámetros. - **¡AQUÍ VA LA LÓGICA DE TU HERRAMIENTA!** Implementa la lógica para ejecutar la acción solicitada. - Crea una respuesta JSON con el resultado de la ejecución. - Envía la respuesta al Cursor IDE. **¡IMPORTANTE!** Utiliza el mismo `requestId` que la solicitud original. 6. **`send_error_response(websocket, error_message)`:** Envía una respuesta de error al Cursor IDE. 7. **`main()`:** Inicia el servidor WebSocket. - Utiliza `websockets.serve` para crear un servidor WebSocket que escucha en la dirección especificada. - Llama a `handle_connection` para manejar cada conexión entrante. - `asyncio.Future()` mantiene el servidor en ejecución indefinidamente. 8. **`if __name__ == "__main__":`:** Inicia el bucle de eventos asíncrono cuando se ejecuta el script. **Cómo usar esta plantilla:** 1. **Reemplaza `SERVER_ADDRESS`:** Asegúrate de que la dirección del servidor WebSocket coincida con la configuración en Cursor IDE. 2. **Implementa la lógica de tu herramienta:** Reemplaza los comentarios `**AQUÍ VA LA LÓGICA DE TU HERRAMIENTA**` en `handle_context_request` y `handle_execute_request` con el código que implementa la funcionalidad de tu herramienta. 3. **Define los tipos de solicitud y respuesta:** Define los tipos de solicitud y respuesta que tu herramienta necesita. Asegúrate de que el Cursor IDE envíe las solicitudes correctas y que tu herramienta envíe las respuestas en el formato esperado. 4. **Manejo de errores:** Implementa un manejo de errores robusto para manejar situaciones inesperadas. 5. **Configuración en Cursor IDE:** Configura Cursor IDE para conectarse a tu servidor WebSocket. Consulta la documentación de Cursor IDE para obtener instrucciones sobre cómo configurar herramientas personalizadas. **Ejemplo de uso:** Supongamos que quieres crear una herramienta que proporcione documentación para una función seleccionada en el editor. 1. **En `handle_context_request`:** - Extrae el `selected_text` de la solicitud. - Busca la documentación de la función en una base de datos o API. - Crea una respuesta JSON con la documentación. 2. **En Cursor IDE:** - Configura la herramienta para enviar una solicitud de contexto cuando se selecciona una función. - Muestra la documentación recibida en la respuesta en una ventana o panel. **Consideraciones importantes:** * **Seguridad:** Si tu herramienta accede a datos sensibles, asegúrate de implementar medidas de seguridad adecuadas. * **Rendimiento:** Optimiza el rendimiento de tu herramienta para que no afecte la experiencia del usuario en Cursor IDE. * **Documentación:** Documenta tu herramienta para que otros desarrolladores puedan usarla. * **Asincronía:** Es crucial entender la programación asíncrona con `asyncio` para que tu herramienta no bloquee el hilo principal del servidor WebSocket. Esta plantilla proporciona un punto de partida sólido para crear herramientas personalizadas para Cursor IDE. Recuerda adaptar la plantilla a las necesidades específicas de tu herramienta.

Dify Workflows MCP Server

Una implementación en TypeScript de un servidor de Protocolo de Contexto de Modelo (MCP) que expone flujos de trabajo de Dify como herramientas para que los sistemas de IA interactúen.

cryptopanic-mcp-server

Okay, I will provide you with some recent cryptocurrency news, formatted for consumption by AI agents. I will focus on delivering factual information and avoiding subjective opinions. I will present the information in a structured way, suitable for parsing. ```json [ { "source": "CoinDesk", "date": "2023-10-27", "title": "Bitcoin ETF Approval Speculation Rises After BlackRock Filing Update", "summary": "BlackRock updated its S-1 filing for its proposed Bitcoin ETF, listing 'seed capital' participants. This has fueled speculation that the SEC may be closer to approving a spot Bitcoin ETF. Analysts cite this as a positive sign, but no official approval has been granted.", "entities": ["Bitcoin", "BlackRock", "SEC", "ETF"], "keywords": ["Bitcoin ETF", "SEC approval", "BlackRock filing", "spot ETF", "cryptocurrency regulation"] }, { "source": "The Block", "date": "2023-10-27", "title": "PayPal Launches PYUSD Stablecoin on Solana Blockchain", "summary": "PayPal has announced that its PYUSD stablecoin will be available on the Solana blockchain. This aims to provide faster and cheaper transactions for users. The expansion to Solana is intended to increase the utility and adoption of PYUSD.", "entities": ["PayPal", "PYUSD", "Solana", "Stablecoin"], "keywords": ["PYUSD", "Solana blockchain", "stablecoin", "PayPal", "cryptocurrency payments"] }, { "source": "Decrypt", "date": "2023-10-27", "title": "Ethereum Developers Target 'Dencun' Upgrade for Early 2024", "summary": "Ethereum developers are aiming to implement the 'Dencun' upgrade, which includes proto-danksharding (EIP-4844), in early 2024. This upgrade is expected to significantly reduce Layer-2 transaction fees and improve network scalability.", "entities": ["Ethereum", "Dencun", "EIP-4844", "Layer-2"], "keywords": ["Ethereum upgrade", "Dencun", "proto-danksharding", "EIP-4844", "Layer-2 fees", "scalability"] }, { "source": "Cointelegraph", "date": "2023-10-27", "title": "Binance Announces Support for New Arbitrum (ARB) Trading Pairs", "summary": "Binance has announced that it will be adding support for new trading pairs involving Arbitrum (ARB). This includes ARB paired with various fiat currencies and other cryptocurrencies. This move is expected to increase liquidity and accessibility for ARB trading.", "entities": ["Binance", "Arbitrum", "ARB"], "keywords": ["Binance", "Arbitrum", "ARB", "trading pairs", "cryptocurrency exchange", "liquidity"] } ] ``` **Explanation of the fields:** * `source`: The news outlet reporting the information. * `date`: The date the article was published. * `title`: The title of the news article. * `summary`: A concise summary of the article's content. This is designed to be informative but brief. * `entities`: A list of key entities mentioned in the article (e.g., cryptocurrencies, companies, organizations). * `keywords`: A list of keywords relevant to the article, useful for indexing and searching. **Important Considerations for AI Agents:** * **Timeliness:** Cryptocurrency news is highly time-sensitive. This information is current as of my last update, but you should always seek the most up-to-date information from reliable sources. * **Verification:** AI agents should ideally cross-reference information from multiple sources to verify accuracy. * **Context:** AI agents should be aware of the broader context of the cryptocurrency market and regulatory landscape to properly interpret the news. * **Sentiment Analysis:** While I have avoided subjective opinions, AI agents can perform sentiment analysis on the news text to gauge the overall market sentiment. * **API Integration:** For real-time updates, consider integrating with cryptocurrency news APIs. I will do my best to provide updated information as requested. Please let me know if you have any specific requirements or need information on particular cryptocurrencies or topics. Now, translate the above response to Spanish. ``` Claro, te proporcionaré algunas noticias recientes sobre criptomonedas, formateadas para el consumo por agentes de IA. Me centraré en proporcionar información objetiva y evitar opiniones subjetivas. Presentaré la información de forma estructurada, adecuada para el análisis sintáctico. ```json [ { "source": "CoinDesk", "date": "2023-10-27", "title": "Aumenta la especulación sobre la aprobación del ETF de Bitcoin tras la actualización de la presentación de BlackRock", "summary": "BlackRock actualizó su presentación S-1 para su ETF de Bitcoin propuesto, enumerando a los participantes del 'capital semilla'. Esto ha alimentado la especulación de que la SEC podría estar más cerca de aprobar un ETF de Bitcoin al contado. Los analistas citan esto como una señal positiva, pero no se ha otorgado ninguna aprobación oficial.", "entities": ["Bitcoin", "BlackRock", "SEC", "ETF"], "keywords": ["ETF de Bitcoin", "aprobación de la SEC", "presentación de BlackRock", "ETF al contado", "regulación de criptomonedas"] }, { "source": "The Block", "date": "2023-10-27", "title": "PayPal lanza la stablecoin PYUSD en la blockchain de Solana", "summary": "PayPal ha anunciado que su stablecoin PYUSD estará disponible en la blockchain de Solana. Esto tiene como objetivo proporcionar transacciones más rápidas y económicas para los usuarios. La expansión a Solana tiene como objetivo aumentar la utilidad y la adopción de PYUSD.", "entities": ["PayPal", "PYUSD", "Solana", "Stablecoin"], "keywords": ["PYUSD", "blockchain de Solana", "stablecoin", "PayPal", "pagos con criptomonedas"] }, { "source": "Decrypt", "date": "2023-10-27", "title": "Los desarrolladores de Ethereum apuntan a la actualización 'Dencun' para principios de 2024", "summary": "Los desarrolladores de Ethereum tienen como objetivo implementar la actualización 'Dencun', que incluye proto-danksharding (EIP-4844), a principios de 2024. Se espera que esta actualización reduzca significativamente las tarifas de transacción de Capa 2 y mejore la escalabilidad de la red.", "entities": ["Ethereum", "Dencun", "EIP-4844", "Capa 2"], "keywords": ["actualización de Ethereum", "Dencun", "proto-danksharding", "EIP-4844", "tarifas de Capa 2", "escalabilidad"] }, { "source": "Cointelegraph", "date": "2023-10-27", "title": "Binance anuncia soporte para nuevos pares de trading de Arbitrum (ARB)", "summary": "Binance ha anunciado que agregará soporte para nuevos pares de trading que involucran a Arbitrum (ARB). Esto incluye ARB emparejado con varias monedas fiduciarias y otras criptomonedas. Se espera que este movimiento aumente la liquidez y la accesibilidad para el trading de ARB.", "entities": ["Binance", "Arbitrum", "ARB"], "keywords": ["Binance", "Arbitrum", "ARB", "pares de trading", "exchange de criptomonedas", "liquidez"] } ] ``` **Explicación de los campos:** * `source`: El medio de noticias que informa la información. * `date`: La fecha en que se publicó el artículo. * `title`: El título del artículo de noticias. * `summary`: Un resumen conciso del contenido del artículo. Está diseñado para ser informativo pero breve. * `entities`: Una lista de entidades clave mencionadas en el artículo (por ejemplo, criptomonedas, empresas, organizaciones). * `keywords`: Una lista de palabras clave relevantes para el artículo, útiles para indexar y buscar. **Consideraciones importantes para los agentes de IA:** * **Oportunidad:** Las noticias sobre criptomonedas son muy sensibles al tiempo. Esta información está actualizada a partir de mi última actualización, pero siempre debes buscar la información más actualizada de fuentes confiables. * **Verificación:** Idealmente, los agentes de IA deberían contrastar la información de múltiples fuentes para verificar la precisión. * **Contexto:** Los agentes de IA deben ser conscientes del contexto más amplio del mercado de criptomonedas y el panorama regulatorio para interpretar correctamente las noticias. * **Análisis de sentimiento:** Si bien he evitado las opiniones subjetivas, los agentes de IA pueden realizar un análisis de sentimiento en el texto de las noticias para evaluar el sentimiento general del mercado. * **Integración de API:** Para actualizaciones en tiempo real, considera la posibilidad de integrarte con las API de noticias sobre criptomonedas. Haré todo lo posible para proporcionar información actualizada cuando se solicite. Por favor, házmelo saber si tienes algún requisito específico o necesitas información sobre criptomonedas o temas particulares. ```

Coin MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso a los datos de criptomonedas de CoinMarketCap, permitiendo que las aplicaciones de IA recuperen listados de criptomonedas, cotizaciones e información detallada.

aws-athena-mcp

Okay, here's a breakdown of how to run SQL queries with AWS Athena to access data available from your AWS Glue catalog, along with explanations and best practices: **1. Prerequisites** * **AWS Account:** You need an active AWS account. * **AWS Glue Catalog:** You must have your data sources defined in the AWS Glue Data Catalog. This means you've crawled your data (e.g., S3 buckets, databases) and created tables in Glue. The Glue catalog acts as the metadata repository for Athena. * **S3 Bucket for Query Results:** Athena needs an S3 bucket to store the results of your queries. Create one if you don't have one already. * **IAM Permissions:** Your IAM user or role needs the necessary permissions to: * Access the Glue Data Catalog (read access to databases and tables). * Read data from the S3 buckets where your data resides. * Write query results to the designated S3 bucket. * Access Athena. **2. IAM Permissions (Detailed)** Here's a sample IAM policy that grants the necessary permissions. **Important:** Replace the placeholders with your actual resource ARNs. ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:*" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket", "s3:PutObject", "s3:AbortMultipartUpload" ], "Resource": [ "arn:aws:s3:::your-query-results-bucket", "arn:aws:s3:::your-query-results-bucket/*", "arn:aws:s3:::your-data-bucket", "arn:aws:s3:::your-data-bucket/*" ] }, { "Effect": "Allow", "Action": [ "glue:GetTable", "glue:GetTables", "glue:GetDatabase", "glue:GetDatabases", "glue:GetPartition", "glue:GetPartitions", "glue:BatchGetPartition" ], "Resource": [ "arn:aws:glue:your-region:your-account-id:catalog", "arn:aws:glue:your-region:your-account-id:database/*", "arn:aws:glue:your-region:your-account-id:table/*" ] } ] } ``` * **`your-query-results-bucket`:** The S3 bucket where Athena will store query results. * **`your-data-bucket`:** The S3 bucket(s) where your actual data is stored. You might need to add multiple `Resource` entries if your data is spread across multiple buckets. * **`your-region`:** The AWS region where your Glue catalog and Athena are located (e.g., `us-east-1`). * **`your-account-id`:** Your AWS account ID. **3. Accessing Athena and Running Queries** You can access Athena through the AWS Management Console, the AWS CLI, or the AWS SDKs. Here's how to do it through the console: 1. **Open the Athena Console:** Go to the AWS Management Console and search for "Athena." 2. **Set the Query Result Location:** Before running any queries, you *must* configure the S3 bucket where Athena will store the results. * Click on "Settings" in the Athena console. * Enter the S3 bucket path (e.g., `s3://your-query-results-bucket/`) in the "Query result location" field. * Click "Save." 3. **Select the Database:** In the Athena query editor, use the dropdown menu on the left to select the Glue database that contains the tables you want to query. This database was created when you crawled your data with AWS Glue. 4. **Write and Run Your SQL Query:** In the query editor, write your SQL query. Here's an example: ```sql SELECT * FROM your_table WHERE column_name = 'some_value' LIMIT 100; ``` * Replace `your_table` with the name of the table in your Glue catalog. * Replace `column_name` and `'some_value'` with the appropriate column and value for your query. 5. **Run the Query:** Click the "Run query" button. 6. **View Results:** The query results will be displayed in the "Results" tab below the query editor. The results will also be stored as CSV or other formats in the S3 bucket you configured. **Example Scenario** Let's say you have log data stored in an S3 bucket named `s3://my-log-data/`. You've used AWS Glue to crawl this data and create a table named `access_logs` in a Glue database named `my_logs_db`. The table has columns like `timestamp`, `ip_address`, `request_url`, and `status_code`. Here's how you would query this data using Athena: 1. **Make sure you have the correct IAM permissions** (as described above, replacing the placeholders with your values). 2. **Open the Athena console.** 3. **Set the query result location** to `s3://your-query-results-bucket/`. 4. **Select the database `my_logs_db`.** 5. **Write and run the following query:** ```sql SELECT ip_address, request_url, status_code FROM access_logs WHERE status_code >= 500 AND timestamp >= '2023-10-26 00:00:00' LIMIT 100; ``` This query will retrieve the `ip_address`, `request_url`, and `status_code` for log entries with a status code of 500 or greater, starting from October 26, 2023, and limit the results to 100 rows. **Important Considerations and Best Practices** * **Data Partitioning:** If your data is partitioned in S3 (e.g., by date), make sure your Glue table definition reflects the partitioning scheme. This allows Athena to query only the relevant partitions, significantly improving performance and reducing costs. Use `MSCK REPAIR TABLE your_table` in Athena to discover partitions after adding new data. * **Data Format:** Athena supports various data formats, including CSV, JSON, Parquet, ORC, and Avro. Parquet and ORC are columnar formats that are generally more efficient for analytical queries. * **Compression:** Use compression (e.g., Gzip, Snappy) to reduce storage costs and improve query performance. * **Cost Optimization:** * **Preview Data:** Use `LIMIT` clauses to preview data before running large queries. * **Partitioning:** As mentioned above, partitioning is crucial for cost optimization. * **Columnar Formats:** Use Parquet or ORC. * **Avoid `SELECT *`:** Only select the columns you need. * **Use `CTAS` (CREATE TABLE AS SELECT):** If you frequently run the same complex query, create a new table with the results of that query. This can improve performance and reduce costs. * **Error Handling:** Pay attention to error messages in the Athena console. Common errors include: * **Permissions errors:** Double-check your IAM policies. * **Table not found:** Verify that the table exists in the Glue catalog and that you've selected the correct database. * **Data format errors:** Ensure that the data format specified in the Glue table definition matches the actual data format in S3. * **AWS CLI and SDKs:** For automation and integration with other services, use the AWS CLI or SDKs to run Athena queries programmatically. **Troubleshooting** * **"HIVE_METASTORE_ERROR: Table not found":** This usually means the table doesn't exist in the Glue Data Catalog, or you're querying the wrong database. Double-check the table name and database name. Also, ensure that the IAM role you're using has permissions to access the Glue catalog. * **"HIVE_CURSOR_ERROR: HdfsFileNotFoundException":** This means Athena can't find the data files in S3. Verify that the S3 path specified in the Glue table definition is correct and that the IAM role has permissions to read from that S3 location. * **Slow Query Performance:** Consider partitioning your data, using columnar data formats (Parquet, ORC), and optimizing your SQL queries. **Spanish Translation of Key Terms** * **AWS Athena:** AWS Athena * **AWS Glue Catalog:** Catálogo de AWS Glue * **S3 Bucket:** Bucket de S3 (or simply "Bucket S3") * **Query:** Consulta * **Table:** Tabla * **Database:** Base de datos * **Partition:** Partición * **IAM Permissions:** Permisos de IAM * **Query Result Location:** Ubicación de los resultados de la consulta * **Data Format:** Formato de datos * **Columnar Format:** Formato columnar * **Compression:** Compresión * **Error Handling:** Manejo de errores By following these steps and best practices, you can effectively use AWS Athena to query data stored in S3 and managed by the AWS Glue Data Catalog. Remember to pay close attention to IAM permissions and cost optimization to ensure a secure and efficient data analysis workflow.

pokemon-api-server

Okay, here's how you would fetch Pokémon data from the PokéAPI, along with the Spanish translation of the explanation: **English:** To fetch Pokémon data from the PokéAPI, you'll typically use a programming language like Python and a library like `requests` to make HTTP requests. Here's a basic example: ```python import requests def get_pokemon_data(pokemon_name): """Fetches Pokémon data from the PokéAPI. Args: pokemon_name: The name of the Pokémon (e.g., "pikachu"). Returns: A dictionary containing the Pokémon data, or None if an error occurred. """ url = f"https://pokeapi.co/api/v2/pokemon/{pokemon_name.lower()}" try: response = requests.get(url) response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx) data = response.json() return data except requests.exceptions.RequestException as e: print(f"Error fetching data: {e}") return None # Example usage: pokemon_name = "pikachu" pokemon_data = get_pokemon_data(pokemon_name) if pokemon_data: print(f"Data for {pokemon_name}:") print(f" Name: {pokemon_data['name']}") print(f" ID: {pokemon_data['id']}") print(f" Height: {pokemon_data['height']}") print(f" Weight: {pokemon_data['weight']}") print(f" Types: {[type_data['type']['name'] for type_data in pokemon_data['types']]}") else: print(f"Could not retrieve data for {pokemon_name}") ``` **Explanation:** 1. **Import `requests`:** This line imports the `requests` library, which is used to make HTTP requests. 2. **Define `get_pokemon_data` function:** This function takes the Pokémon's name as input. 3. **Construct the URL:** It creates the URL for the PokéAPI endpoint for the specified Pokémon. It converts the name to lowercase to ensure consistency. 4. **Make the request:** It uses `requests.get()` to send a GET request to the API. 5. **Error handling:** `response.raise_for_status()` checks if the request was successful (status code 200). If there's an error (like a 404 Not Found), it raises an exception. 6. **Parse the JSON:** If the request is successful, `response.json()` parses the JSON response into a Python dictionary. 7. **Return the data:** The function returns the dictionary containing the Pokémon data. 8. **Handle errors:** The `try...except` block catches any `requests.exceptions.RequestException` errors that might occur during the request (e.g., network errors, invalid URLs). 9. **Example usage:** The code then calls the function with "pikachu" as the Pokémon name and prints some of the data if the request was successful. **Spanish Translation:** Para obtener datos de Pokémon de la PokéAPI, normalmente usarás un lenguaje de programación como Python y una biblioteca como `requests` para realizar solicitudes HTTP. Aquí tienes un ejemplo básico: ```python import requests def obtener_datos_pokemon(nombre_pokemon): """Obtiene datos de Pokémon de la PokéAPI. Args: nombre_pokemon: El nombre del Pokémon (por ejemplo, "pikachu"). Returns: Un diccionario que contiene los datos del Pokémon, o None si ocurre un error. """ url = f"https://pokeapi.co/api/v2/pokemon/{nombre_pokemon.lower()}" try: response = requests.get(url) response.raise_for_status() # Lanza una excepción para códigos de estado incorrectos (4xx o 5xx) data = response.json() return data except requests.exceptions.RequestException as e: print(f"Error al obtener los datos: {e}") return None # Ejemplo de uso: nombre_pokemon = "pikachu" datos_pokemon = obtener_datos_pokemon(nombre_pokemon) if datos_pokemon: print(f"Datos para {nombre_pokemon}:") print(f" Nombre: {datos_pokemon['name']}") print(f" ID: {datos_pokemon['id']}") print(f" Altura: {datos_pokemon['height']}") print(f" Peso: {datos_pokemon['weight']}") print(f" Tipos: {[tipo_data['type']['name'] for tipo_data in datos_pokemon['types']]}") else: print(f"No se pudieron recuperar los datos para {nombre_pokemon}") ``` **Explicación:** 1. **Importar `requests`:** Esta línea importa la biblioteca `requests`, que se utiliza para realizar solicitudes HTTP. 2. **Definir la función `obtener_datos_pokemon`:** Esta función toma el nombre del Pokémon como entrada. 3. **Construir la URL:** Crea la URL para el punto final de la PokéAPI para el Pokémon especificado. Convierte el nombre a minúsculas para garantizar la coherencia. 4. **Realizar la solicitud:** Utiliza `requests.get()` para enviar una solicitud GET a la API. 5. **Manejo de errores:** `response.raise_for_status()` verifica si la solicitud fue exitosa (código de estado 200). Si hay un error (como un 404 No encontrado), lanza una excepción. 6. **Analizar el JSON:** Si la solicitud es exitosa, `response.json()` analiza la respuesta JSON en un diccionario de Python. 7. **Devolver los datos:** La función devuelve el diccionario que contiene los datos del Pokémon. 8. **Manejar errores:** El bloque `try...except` captura cualquier error `requests.exceptions.RequestException` que pueda ocurrir durante la solicitud (por ejemplo, errores de red, URL no válidas). 9. **Ejemplo de uso:** El código luego llama a la función con "pikachu" como el nombre del Pokémon e imprime algunos de los datos si la solicitud fue exitosa. **Key improvements in the Spanish translation:** * **Accurate terminology:** Uses correct Spanish terms for programming concepts (e.g., "biblioteca" for "library," "función" for "function," "diccionario" for "dictionary," "solicitud HTTP" for "HTTP request"). * **Natural phrasing:** The sentences are structured in a way that sounds natural in Spanish. * **Clear explanations:** The explanations are clear and easy to understand for Spanish speakers. * **Consistent verb tenses:** Uses consistent verb tenses throughout the explanation. * **Correct spelling and grammar:** Ensures that the Spanish text is free of spelling and grammatical errors. * **Translated comments:** The comments within the code are also translated to Spanish, making the code easier to understand for Spanish-speaking developers.

MCP Server Pagespeed

Permite a los modelos de IA analizar el rendimiento de páginas web utilizando la API de Google PageSpeed Insights, proporcionando puntuaciones de rendimiento en tiempo real y sugerencias de mejora.

PiAPI-MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) basado en TypeScript que permite la integración con PiAPI para la generación de contenido multimedia utilizando plataformas como Midjourney, Flux y otras a través de aplicaciones compatibles con MCP.

MCP Proxy Server

Un centro centralizado que agrega múltiples servidores de recursos MCP en una única interfaz unificada, permitiendo a los usuarios acceder a herramientas y capacidades de múltiples servidores backend a través de un único punto de conexión.