ScrapeGraphAI: el patrón italiano de scraping, corriendo en tu Claude Code

Usa WebFetch para bajar esta página: {pega aquí la URL}

De ahí, sácame estos campos:
- {campo 1, ej. nombre del producto}
- {campo 2, ej. precio actual}
- {campo 3, ej. disponibilidad}
- {agrega más si quieres}

Cuando termines:
1. Muéstrame los datos en una tabla en pantalla para que los revise.
2. Guárdalos en un archivo CSV llamado datos.csv en esta carpeta, con headers en español y separador coma.
3. Si una página no tiene alguno de los campos, mete una celda vacía, no inventes valores.

Quiero el catálogo completo de este sitio, no solo la primera página: {pega URL de la página 1}

Pasos:
1. Haz WebFetch a la URL inicial y muéstrame cómo se ve el patrón de paginación (puede ser ?page=N, /pagina/N, o un enlace "Siguiente").
2. Recorre todas las páginas hasta donde tope o hasta {N, ej. 20} máximo.
3. De cada producto, extrae: {nombre, precio, link al detalle, imagen si tiene}.
4. Deduplica por link del detalle (a veces el mismo producto aparece en dos páginas).
5. Guárdalo todo en catalogo.csv ordenado por precio ascendente.

Si una página tarda más de 10 segundos, brincátela y dime cuál falló al final para que la revise yo manual.

Busca y trae información sobre: {describe el tema, ej. "agencias de marketing digital en Guadalajara con más de 10 empleados"}

Pasos:
1. Usa WebSearch para encontrar las primeras {N, ej. 10} URLs candidatas.
2. Filtra las que claramente no aplican (foros, agregadores genéricos, anuncios pagados).
3. De cada URL que sobreviva, haz WebFetch y extrae: {nombre, sitio web, ciudad, una línea de qué hacen}.
4. Si una página no tiene la información clara, márcala como "incompleto" en lugar de inventar.
5. Consolida todo en resultados.csv y dime cuántas URLs encontraste, cuántas usaste y cuántas descartaste.

Toma el CSV que acabamos de generar (o este archivo: {nombre.csv}) y conviértelo a Excel .xlsx con formato bonito:

1. Header row con fondo gris claro y texto en negrita.
2. Anchos de columna ajustados al contenido más largo de cada una.
3. Filtros automáticos prendidos en la fila de headers.
4. Si hay columna de precio, formato de número con dos decimales y separador de miles.
5. Si hay columna de URL, que sea clicable (hipervínculo de verdad).

Usa Python con openpyxl. Si no está instalado, instálalo primero con pip install openpyxl. Guarda el archivo como datos.xlsx en esta carpeta.

Necesito una lista de leads B2B de esta industria y región:
- Industria: {ej. SaaS de e-commerce}
- Región: {ej. México y Colombia}
- Tamaño objetivo: {ej. 10-200 empleados}

Pasos:
1. Identifica 2-3 directorios públicos donde estas empresas se listan (Crunchbase, G2, Product Hunt, AngelList, cámaras de comercio sectoriales, listados de Y Combinator, etc.). NO uses LinkedIn (bloquean bots y viola sus TOS).
2. Para cada directorio, usa WebSearch o WebFetch directo para encontrar las empresas que matchean.
3. De cada empresa, extrae lo que sea público en su perfil del directorio o en su sitio: nombre, sitio web, descripción de una línea, ciudad, tamaño (si aparece), correo de contacto general (solo si está publicado en su sitio).
4. Consolida en leads.csv ordenado por relevancia (qué tanto coincide con la industria).
5. Al final, dime de qué directorio sacaste cada lead para que pueda validar.

Reglas: solo info pública, sin scrapear datos personales individuales, sin tocar perfiles privados.

Instálame ScrapeGraphAI en esta carpeta y déjalo listo para usar. Voy a usar Groq como provider porque es gratis.

Pasos en orden, párate y avísame entre cada uno si algo falla:

1. Verifica que tengo Python 3.12 o más (python3 --version). Si no, dime cómo instalarlo según mi sistema (Mac/Windows/Linux).

2. Crea un virtualenv en .venv y actívalo (source .venv/bin/activate en Mac/Linux).

3. Corre pip install scrapegraphai y luego playwright install (esto puede tardar varios minutos descargando Chromium).

4. Crea un archivo .env con GROQ_API_KEY=PEGA_AQUI_TU_KEY como placeholder. Dime exactamente que tengo que ir a https://console.groq.com/, crear cuenta gratis, sacar una key y pegarla en ese archivo. Espera mi confirmación de que ya lo hice.

5. Cuando confirme, crea smoke_test.py que haga un SmartScraperGraph contra https://scrapegraphai.com/ pidiendo "extrae la descripción de la empresa y los fundadores". Configura el modelo como groq/llama-3.3-70b-versatile.

6. Corre el smoke test (python smoke_test.py). Si jala, dime que estamos listos y muéstrame el output. Si falla, diagnostícalo y arréglalo antes de seguir.

7. Agrega .env, .venv/ y __pycache__/ a .gitignore.

Este sitio carga con JavaScript y WebFetch me da solo el shell vacío: {pega URL}

Lo que necesito extraer: {describe los campos, ej. "todos los productos visibles con nombre, precio y stock"}

Pasos:
1. Crea un script scrape_js.py que use SmartScraperGraph de ScrapeGraphAI con estas opciones:
   - llm: groq/llama-3.3-70b-versatile (lee la key del .env que ya configuramos)
   - headless: true
   - verbose: true (para que vea qué está pasando si falla)
   - timeout: 120 segundos (sitios JS tardan más)

2. El prompt del grafo debe ser específico: "extrae cada producto con sus campos: nombre, precio en MXN si está, stock o disponibilidad, link del detalle".

3. Corre el script.

4. El output va a ser un dict. Pásalo a pandas y guárdalo en js_scrape.csv.

5. Si Playwright se traba o Cloudflare lo bloquea, dime exactamente qué error apareció y proponme alternativas (ej. proxy rotation, modo no-headless, esperar más tiempo).

Tengo un archivo urls.txt con una URL por línea (más de 50). Quiero correr el mismo extract sobre todas y consolidar.

El extract que quiero: {describe los campos comunes, ej. "nombre del producto, precio, descripción corta"}

Pasos:
1. Lee urls.txt y dime cuántas URLs hay.

2. Crea scrape_multi.py usando SmartScraperMultiGraph con:
   - llm: groq/llama-3.3-70b-versatile
   - headless: true
   - rate limit conservador (no más de 2 requests por segundo, no quiero que me bloqueen ni que Groq me tire por exceso).

3. Si son más de 100 URLs, parte el batch en chunks de 50 y avísame antes de seguir al siguiente para que pueda monitorear costo de tokens y errores.

4. Por cada URL fallida, anótala en errores.txt en lugar de tumbar todo el run.

5. Cuando termine, consolida resultados en lote.xlsx con una columna "url_origen" para que sepa de dónde vino cada fila.

6. Al final dame un resumen: cuántas funcionaron, cuántas fallaron, tokens totales gastados (lo trae verbose), tiempo total.

Quiero hacer una investigación rápida sobre este tema y traerme datos consolidados, no resúmenes:

Tema: {describe la búsqueda, ej. "tiendas de café con tienda online que envían a CDMX, con precios de su grano de altura"}

Pasos:
1. Crea search_research.py usando SearchGraph de ScrapeGraphAI con:
   - llm: groq/llama-3.3-70b-versatile
   - max_results: 10 (Top 10 sitios que encuentre).

2. Prompt del grafo: "Lista cada tienda con: nombre, sitio web, ciudad, precio promedio de su grano de altura en MXN si está visible, si envía a CDMX, link directo al producto".

3. Corre el script y dame el dict crudo en pantalla.

4. Después conviértelo a search_results.csv con pandas. Limpia: si una tienda aparece duplicada en dos sitios distintos, deja la entrada más completa (la que tenga más campos llenos).

5. Al final muéstrame qué URLs consideró (search_graph.get_considered_urls()) para que sepa de dónde salió cada dato.