Discover Awesome MCP Servers

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.

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.

systemprompt-mcp-interview

Un servidor especializado de Protocolo de Contexto de Modelo (MCP) que permite escenarios de juego de roles de entrevistas impulsados por IA para practicar con retroalimentación conversacional realista.

cloudflare-browser-rendering-mcp

Este servidor MCP proporciona herramientas para interactuar con Cloudflare Browser Rendering, permitiéndote obtener y procesar contenido web para usarlo como contexto en LLMs directamente desde Cline o Claude Desktop.

mcp-dingdingbot-server

Here are a few possible translations, depending on the context you're looking for: * **General Translation:** "Webhook DingDing servidor MCP" * **More Technical/Literal Translation:** "Webhook de DingDing para servidor MCP" * **If you're talking about a server *on* MCP:** "Servidor MCP con webhook de DingDing" **Explanation of Choices:** * **DingDing:** This is usually left as is, as it's a proper noun (the name of the platform). * **Webhook:** This term is often used directly in Spanish, especially in technical contexts. "Enlace web" or "gancho web" are possible alternatives, but "webhook" is more common. * **MCP Server:** "Servidor MCP" is the most straightforward translation. MCP likely refers to a specific technology or platform, so it's best to keep it as is unless you have more context. * **"para" vs. direct noun:** "Webhook *para* servidor" implies the webhook is *for* the server. Using the nouns directly ("Webhook DingDing servidor") is also common, especially in shorter descriptions. * **"con"**: If the server *has* a DingDing webhook, "con" (with) is appropriate. To give you the *best* translation, please provide more context. For example: * What is the purpose of the webhook? * What is the MCP server doing? * Are you setting up a webhook *for* the server, or is the server *using* a webhook? With more information, I can provide a more accurate and helpful translation.

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.

Deepseek MCP Server

Una implementación de servidor del Protocolo de Control de Modelos que permite a Claude Desktop usar modelos Deepseek que se ejecutan en Docker, lo que permite una integración perfecta entre Claude Desktop y los modelos de lenguaje de Deepseek.

MCP Terminal Server

Un servidor seguro para ejecutar comandos de terminal dentro de rutas predefinidas, permitiendo una interacción segura de los Modelos de Lenguaje Grandes con entornos de sistemas operativos.

Vercel MCP

Un servidor MCP que proporciona herramientas para interactuar con la API de Vercel, permitiendo la gestión de despliegues, registros DNS, dominios, proyectos y variables de entorno a través del lenguaje natural.

AQICN MCP Server

Permite la interacción con el Índice Mundial de Calidad del Aire para obtener datos de calidad del aire en tiempo real para ciudades y coordenadas de todo el mundo a través del Protocolo de Contexto del Modelo (MCP).

Retrieval-Augmented Thinking MCP Server

Mejora las capacidades de los modelos de IA con procesos de pensamiento estructurados y aumentados por recuperación que permiten cadenas de pensamiento dinámicas, rutas de exploración paralelas y ciclos de refinamiento recursivos para un razonamiento mejorado.

Metal MCP Server

Permite la interacción con el framework Metal al proporcionar búsqueda de documentación y capacidades de generación de código utilizando consultas en lenguaje natural.

MCP Server: Scalable OpenAPI Endpoint Discovery and API Request Tool

Este servidor facilita el descubrimiento y la ejecución escalables de endpoints OpenAPI mediante búsqueda semántica y procesamiento de alto rendimiento, superando las limitaciones del manejo de especificaciones grandes para interacciones API optimizadas.

Scryfall MCP Server

Permite la interacción con la API de Scryfall, lo que permite a los usuarios buscar detalles de cartas de Magic: The Gathering, recuperar reglas de cartas y acceder a información de precios utilizando el Protocolo de Contexto del Modelo.

Linear MCP Server

Permite la interacción con los recursos de Linear a través de una interfaz MCP, ofreciendo funcionalidad para la gestión de incidencias y la recuperación de recursos con soporte para la limitación de velocidad y el manejo de errores.

ClickUp MCP Server

Permite integraciones de IA con las tareas de ClickUp, facilitando la gestión de recursos, las operaciones de tareas, la organización del espacio de trabajo y las recomendaciones de tareas impulsadas por IA a través de un protocolo estandarizado.

Wegene Assistant MCP Server

Aprovecha los modelos de lenguaje grandes para analizar los informes de pruebas genéticas WeGene de los usuarios, proporcionando acceso a los datos del informe a través de esquemas URI personalizados y permitiendo la gestión de perfiles e informes mediante la autenticación OAuth y la utilización de API.

Backlog MCP Server

Integra la gestión de proyectos de Backlog con Claude a través del Protocolo de Contexto de Modelos, permitiendo el acceso a proyectos, incidencias y páginas wiki mediante interacciones en lenguaje natural.

Monday.com MCP Server

Permite a los clientes MCP interactuar con los tableros de Monday.com, permitiendo la creación y gestión de elementos, subelementos, comentarios y la recuperación de información del tablero.

Overseerr MCP Server

Permite que Claude interactúe con Overseerr, lo que permite a los usuarios buscar, solicitar y administrar contenido multimedia para su biblioteca de Plex a través del lenguaje natural.

Cloudinary MCP Server

Este servidor proporciona herramientas para subir imágenes y videos directamente a Cloudinary usando Claude/Cline, facilitando la gestión de recursos con opciones personalizables como el tipo de recurso y el ID público.

Telegram MCP Server

Un puente que permite a Claude Desktop acceder a chats y mensajes de Telegram a través del Protocolo de Contexto del Modelo, proporcionando capacidades de solo lectura para recuperar diálogos y mensajes de Telegram.

Kibela MCP Server

Permite la integración con la API de Kibela para buscar y recuperar notas, lo que permite a los LLM interactuar con el contenido de Kibela sin problemas.

ChatGPT MCP Server

A Model Context Protocol server that enables Docker container management through natural language interactions using a custom GPT interface.

Code Explainer MCP

Un Cloudflare Worker que analiza código fuente para proporcionar explicaciones exhaustivas, incluyendo diagramas de arquitectura, análisis de la funcionalidad principal y desglose de componentes en múltiples lenguajes de programación.

Deep Research MCP Server

Permite la investigación profunda iterativa integrando agentes de IA con motores de búsqueda, web scraping y modelos de lenguaje grandes para una recopilación de datos eficiente y la elaboración de informes exhaustivos.

mcp-simple-arxiv

Un servidor MCP que proporciona acceso a los artículos de arXiv a través de su API.

gitlab mcp

GitLab MCP translates to: **GitLab MCP**