theus-cli 0.2.83 → 0.2.84

package/vendor/theus-arsenal/skills/agente-scraper-datos/SKILL.md

@@ -1,771 +0,0 @@
----
-name: agente-scraper-datos
-description: Construye un agente de recolección de datos totalmente automatizado para cualquier
-  fuente pública — bolsas de trabajo, precios, noticias, GitHub, deportes, lo que sea. Corre con
-  cronograma, enriquece los datos con un LLM, guarda resultados en Notion/Sheets/Supabase y aprende
-  del feedback del usuario. Corre gratis en GitHub Actions. Úsala cuando el usuario quiera
-  monitorear, recolectar o rastrear datos públicos automáticamente.
----
-
-# Agente scraper de datos
-
-Construye un agente de recolección de datos listo para producción, potenciado con IA, para cualquier fuente de datos pública.
-Corre con cronograma, enriquece los resultados con un LLM, guarda en una base de datos y mejora con el tiempo.
-
-**Stack: Python · API de LLM (capa gratuita o de bajo costo) · GitHub Actions (gratis) · Notion / Sheets / Supabase**
-
-## Cuándo activarla
-
-- El usuario quiere recopilar o monitorear cualquier sitio web o API pública.
-- El usuario dice "construye un bot que revise...", "monitoréame X", "recolecta datos de...".
-- El usuario quiere rastrear empleos, precios, noticias, repos, marcadores deportivos, eventos, avisos.
-- El usuario pregunta cómo automatizar la recolección de datos sin pagar hosting.
-- El usuario quiere un agente que se vuelva más inteligente con base en sus decisiones.
-
-## Conceptos clave
-
-### Las tres capas
-
-Todo agente de recolección de datos tiene tres capas:
-
-```
-RECOLECTAR → ENRIQUECER → GUARDAR
-    │             │            │
- Scraper       IA (LLM)     Base de datos
- corre con     puntúa/       Notion /
- cronograma    resume y      Sheets /
-               clasifica     Supabase
-```
-
-### Stack de bajo costo
-
-| Capa | Herramienta | Por qué |
-|---|---|---|
-| **Scraping** | `requests` + `BeautifulSoup` | Sin costo, cubre el 80 % de los sitios públicos |
-| **Sitios renderizados con JS** | `playwright` (gratis) | Cuando el fetch de HTML falla |
-| **Enriquecimiento con IA** | API REST de LLM del proveedor que configures | Muchos proveedores ofrecen capa gratuita o modelos ligeros muy baratos |
-| **Almacenamiento** | API de Notion | Capa gratuita, gran UI para revisar |
-| **Cronograma** | Cron de GitHub Actions | Gratis para repos públicos |
-| **Aprendizaje** | Archivo JSON de feedback en el repo | Cero infraestructura, persiste en git |
-
-### Cadena de fallback de modelos
-
-Construye el agente para hacer fallback automático entre modelos cuando se agote la cuota. Define la cadena en configuración, del modelo más ligero/barato al de respaldo:
-
-```
-modelo-ligero-preferido →
-modelo-ligero-alternativo →
-modelo-estandar →
-modelo-de-respaldo
-```
-
-### Llamadas a la API en lote para eficiencia
-
-Nunca llames al LLM una vez por ítem. Siempre agrupa:
-
-```python
-# MAL: 33 llamadas a la API para 33 ítems
-for item in items:
-    result = call_ai(item)  # 33 llamadas → golpea el límite de tasa
-
-# BIEN: 7 llamadas a la API para 33 ítems (lotes de 5)
-for batch in chunks(items, size=5):
-    results = call_ai(batch)  # 7 llamadas → se mantiene dentro de la capa gratuita
-```
-
----
-
-## Flujo de trabajo
-
-### Paso 1: entiende el objetivo
-
-Pregunta al usuario:
-
-1. **Qué recolectar:** "¿Qué fuente de datos? ¿URL / API / RSS / endpoint público?"
-2. **Qué extraer:** "¿Qué campos importan? ¿Título, precio, URL, fecha, puntaje?"
-3. **Dónde guardar:** "¿A dónde van los resultados? ¿Notion, Google Sheets, Supabase o archivo local?"
-4. **Cómo enriquecer:** "¿Quieres que la IA puntúe, resuma, clasifique o empareje cada ítem?"
-5. **Frecuencia:** "¿Cada cuánto debe correr? ¿Cada hora, diario, semanal?"
-
-Ejemplos comunes para orientar:
-- Bolsas de trabajo → puntuar relevancia contra el CV
-- Precios de productos → alertar cuando bajen
-- Repos de GitHub → resumir releases nuevos
-- Feeds de noticias → clasificar por tema y sentimiento
-- Resultados deportivos → extraer estadísticas a un tracker
-- Calendario de eventos → filtrar por interés
-
----
-
-### Paso 2: diseña la arquitectura de recolección
-
-Genera esta estructura de directorios para el usuario:
-
-```
-mi-agente/
-├── config.yaml              # El usuario personaliza esto (keywords, filtros, preferencias)
-├── profile/
-│   └── context.md           # Contexto del usuario que usa la IA (CV, intereses, criterios)
-├── scraper/
-│   ├── __init__.py
-│   ├── main.py              # Orquestador: scrapear → enriquecer → guardar
-│   ├── filters.py           # Pre-filtro por reglas (rápido, antes de la IA)
-│   └── sources/
-│       ├── __init__.py
-│       └── source_name.py   # Un archivo por fuente de datos
-├── ai/
-│   ├── __init__.py
-│   ├── client.py            # Cliente REST del LLM con fallback de modelos
-│   ├── pipeline.py          # Análisis de IA en lotes
-│   ├── jd_fetcher.py        # Traer el contenido completo desde las URL (opcional)
-│   └── memory.py            # Aprender del feedback del usuario
-├── storage/
-│   ├── __init__.py
-│   └── notion_sync.py       # O sheets_sync.py / supabase_sync.py
-├── data/
-│   └── feedback.json        # Historial de decisiones del usuario (auto-actualizado)
-├── .env.example
-├── setup.py                 # Creación de BD/esquema por única vez
-├── enrich_existing.py       # Rellenar puntajes de IA en filas antiguas
-├── requirements.txt
-└── .github/
-    └── workflows/
-        └── scraper.yml      # Cronograma de GitHub Actions
-```
-
----
-
-### Paso 3: construye el conector de fuente
-
-Plantilla para cualquier fuente de datos:
-
-```python
-# scraper/sources/my_source.py
-"""
-[Nombre de la fuente] — recopila [qué] desde [dónde].
-Método: [API REST / scraping de HTML / feed RSS]
-"""
-import requests
-from bs4 import BeautifulSoup
-from datetime import datetime, timezone
-from scraper.filters import is_relevant
-
-HEADERS = {
-    "User-Agent": "Mozilla/5.0 (compatible; research-bot/1.0)",
-}
-
-
-def fetch() -> list[dict]:
-    """
-    Devuelve una lista de ítems con esquema consistente.
-    Cada ítem debe tener como mínimo: name, url, date_found.
-    """
-    results = []
-
-    # ---- Fuente de API REST ----
-    resp = requests.get("https://api.example.com/items", headers=HEADERS, timeout=15)
-    if resp.status_code == 200:
-        for item in resp.json().get("results", []):
-            if not is_relevant(item.get("title", "")):
-                continue
-            results.append(_normalise(item))
-
-    return results
-
-
-def _normalise(raw: dict) -> dict:
-    """Convierte los datos crudos de API/HTML al esquema estándar."""
-    return {
-        "name": raw.get("title", ""),
-        "url": raw.get("link", ""),
-        "source": "MySource",
-        "date_found": datetime.now(timezone.utc).date().isoformat(),
-        # agrega aquí campos específicos del dominio
-    }
-```
-
-**Patrón de fetch de HTML:**
-```python
-soup = BeautifulSoup(resp.text, "lxml")
-for card in soup.select("[class*='listing']"):
-    title = card.select_one("h2, h3").get_text(strip=True)
-    link = card.select_one("a")["href"]
-    if not link.startswith("http"):
-        link = f"https://example.com{link}"
-```
-
-**Patrón de feed RSS:**
-```python
-import xml.etree.ElementTree as ET
-root = ET.fromstring(resp.text)
-for item in root.findall(".//item"):
-    title = item.findtext("title", "")
-    link = item.findtext("link", "")
-```
-
----
-
-### Paso 4: construye el cliente del LLM
-
-Cliente genérico contra un endpoint estilo *chat completions* (la mayoría de proveedores y pasarelas exponen uno compatible; configura URL, clave y modelos por variables de entorno):
-
-```python
-# ai/client.py
-import os, json, time, requests
-
-_last_call = 0.0
-
-# Cadena de fallback: del modelo más barato al de respaldo.
-# Se configura por entorno, p. ej. LLM_MODELS="modelo-lite,modelo-estandar"
-def _model_chain() -> list[str]:
-    raw = os.environ.get("LLM_MODELS", "")
-    return [m.strip() for m in raw.split(",") if m.strip()]
-
-
-def generate(prompt: str, model: str = "", rate_limit: float = 7.0) -> dict:
-    """Llama al LLM con fallback automático ante 429. Devuelve JSON parseado o {}."""
-    global _last_call
-
-    api_key = os.environ.get("LLM_API_KEY", "")
-    base_url = os.environ.get("LLM_API_URL", "")  # p. ej. https://<proveedor>/v1/chat/completions
-    if not api_key or not base_url:
-        return {}
-
-    elapsed = time.time() - _last_call
-    if elapsed < rate_limit:
-        time.sleep(rate_limit - elapsed)
-
-    chain = _model_chain()
-    models = [model] + [m for m in chain if m != model] if model else chain
-    _last_call = time.time()
-
-    for m in models:
-        payload = {
-            "model": m,
-            "messages": [{"role": "user", "content": prompt}],
-            "response_format": {"type": "json_object"},
-            "temperature": 0.3,
-            "max_tokens": 2048,
-        }
-        try:
-            resp = requests.post(
-                base_url,
-                json=payload,
-                headers={"Authorization": f"Bearer {api_key}"},
-                timeout=30,
-            )
-            if resp.status_code == 200:
-                return _parse(resp)
-            if resp.status_code in (429, 404):
-                time.sleep(1)
-                continue
-            return {}
-        except requests.RequestException:
-            return {}
-
-    return {}
-
-
-def _parse(resp) -> dict:
-    try:
-        text = (
-            resp.json()
-            .get("choices", [{}])[0]
-            .get("message", {})
-            .get("content", "")
-            .strip()
-        )
-        if text.startswith("```"):
-            text = text.split("\n", 1)[-1].rsplit("```", 1)[0]
-        return json.loads(text)
-    except (json.JSONDecodeError, KeyError):
-        return {}
-```
-
----
-
-### Paso 5: construye el pipeline de IA (en lotes)
-
-```python
-# ai/pipeline.py
-import json
-import yaml
-from pathlib import Path
-from ai.client import generate
-
-def analyse_batch(items: list[dict], context: str = "", preference_prompt: str = "") -> list[dict]:
-    """Analiza ítems en lotes. Devuelve los ítems enriquecidos con campos de IA."""
-    config = yaml.safe_load((Path(__file__).parent.parent / "config.yaml").read_text())
-    model = config.get("ai", {}).get("model", "")
-    rate_limit = config.get("ai", {}).get("rate_limit_seconds", 7.0)
-    min_score = config.get("ai", {}).get("min_score", 0)
-    batch_size = config.get("ai", {}).get("batch_size", 5)
-
-    batches = [items[i:i + batch_size] for i in range(0, len(items), batch_size)]
-    print(f"  [IA] {len(items)} ítems → {len(batches)} llamadas a la API")
-
-    enriched = []
-    for i, batch in enumerate(batches):
-        print(f"  [IA] Lote {i + 1}/{len(batches)}...")
-        prompt = _build_prompt(batch, context, preference_prompt, config)
-        result = generate(prompt, model=model, rate_limit=rate_limit)
-
-        analyses = result.get("analyses", [])
-        for j, item in enumerate(batch):
-            ai = analyses[j] if j < len(analyses) else {}
-            if ai:
-                score = max(0, min(100, int(ai.get("score", 0))))
-                if min_score and score < min_score:
-                    continue
-                enriched.append({**item, "ai_score": score, "ai_summary": ai.get("summary", ""), "ai_notes": ai.get("notes", "")})
-            else:
-                enriched.append(item)
-
-    return enriched
-
-
-def _build_prompt(batch, context, preference_prompt, config):
-    priorities = config.get("priorities", [])
-    items_text = "\n\n".join(
-        f"Item {i+1}: {json.dumps({k: v for k, v in item.items() if not k.startswith('_')})}"
-        for i, item in enumerate(batch)
-    )
-
-    return f"""Analiza estos {len(batch)} ítems y devuelve un objeto JSON.
-
-# Ítems
-{items_text}
-
-# Contexto del usuario
-{context[:800] if context else "No provisto"}
-
-# Prioridades del usuario
-{chr(10).join(f"- {p}" for p in priorities)}
-
-{preference_prompt}
-
-# Instrucciones
-Devuelve: {{"analyses": [{{"score": <0-100>, "summary": "<2 oraciones>", "notes": "<por qué encaja o no>"}} por cada ítem en orden]}}
-Sé conciso. Puntaje 90+=encaje excelente, 70-89=bueno, 50-69=aceptable, <50=débil."""
-```
-
----
-
-### Paso 6: construye el sistema de aprendizaje por feedback
-
-```python
-# ai/memory.py
-"""Aprende de las decisiones del usuario para mejorar la puntuación futura."""
-import json
-from pathlib import Path
-
-FEEDBACK_PATH = Path(__file__).parent.parent / "data" / "feedback.json"
-
-
-def load_feedback() -> dict:
-    if FEEDBACK_PATH.exists():
-        try:
-            return json.loads(FEEDBACK_PATH.read_text())
-        except (json.JSONDecodeError, OSError):
-            pass
-    return {"positive": [], "negative": []}
-
-
-def save_feedback(fb: dict):
-    FEEDBACK_PATH.parent.mkdir(parents=True, exist_ok=True)
-    FEEDBACK_PATH.write_text(json.dumps(fb, indent=2))
-
-
-def build_preference_prompt(feedback: dict, max_examples: int = 15) -> str:
-    """Convierte el historial de feedback en una sección de sesgo del prompt."""
-    lines = []
-    if feedback.get("positive"):
-        lines.append("# Ítems que al usuario le GUSTARON (señal positiva):")
-        for e in feedback["positive"][-max_examples:]:
-            lines.append(f"- {e}")
-    if feedback.get("negative"):
-        lines.append("\n# Ítems que el usuario OMITIÓ/RECHAZÓ (señal negativa):")
-        for e in feedback["negative"][-max_examples:]:
-            lines.append(f"- {e}")
-    if lines:
-        lines.append("\nUsa estos patrones para sesgar la puntuación de ítems nuevos.")
-    return "\n".join(lines)
-```
-
-**Integración con tu capa de almacenamiento:** después de cada corrida, consulta tu BD por ítems con estado positivo/negativo y llama a `save_feedback()` con los patrones extraídos.
-
----
-
-### Paso 7: construye el almacenamiento (ejemplo con Notion)
-
-```python
-# storage/notion_sync.py
-import os
-from notion_client import Client
-from notion_client.errors import APIResponseError
-
-_client = None
-
-def get_client():
-    global _client
-    if _client is None:
-        _client = Client(auth=os.environ["NOTION_TOKEN"])
-    return _client
-
-def get_existing_urls(db_id: str) -> set[str]:
-    """Trae todas las URL ya guardadas — se usa para deduplicar."""
-    client, seen, cursor = get_client(), set(), None
-    while True:
-        resp = client.databases.query(database_id=db_id, page_size=100, **{"start_cursor": cursor} if cursor else {})
-        for page in resp["results"]:
-            url = page["properties"].get("URL", {}).get("url", "")
-            if url: seen.add(url)
-        if not resp["has_more"]: break
-        cursor = resp["next_cursor"]
-    return seen
-
-def push_item(db_id: str, item: dict) -> bool:
-    """Empuja un ítem a Notion. Devuelve True si tuvo éxito."""
-    props = {
-        "Name": {"title": [{"text": {"content": item.get("name", "")[:100]}}]},
-        "URL": {"url": item.get("url")},
-        "Source": {"select": {"name": item.get("source", "Unknown")}},
-        "Date Found": {"date": {"start": item.get("date_found")}},
-        "Status": {"select": {"name": "New"}},
-    }
-    # Campos de IA
-    if item.get("ai_score") is not None:
-        props["AI Score"] = {"number": item["ai_score"]}
-    if item.get("ai_summary"):
-        props["Summary"] = {"rich_text": [{"text": {"content": item["ai_summary"][:2000]}}]}
-    if item.get("ai_notes"):
-        props["Notes"] = {"rich_text": [{"text": {"content": item["ai_notes"][:2000]}}]}
-
-    try:
-        get_client().pages.create(parent={"database_id": db_id}, properties=props)
-        return True
-    except APIResponseError as e:
-        print(f"[notion] Falló el push: {e}")
-        return False
-
-def sync(db_id: str, items: list[dict]) -> tuple[int, int]:
-    existing = get_existing_urls(db_id)
-    added = skipped = 0
-    for item in items:
-        if item.get("url") in existing:
-            skipped += 1; continue
-        if push_item(db_id, item):
-            added += 1; existing.add(item["url"])
-        else:
-            skipped += 1
-    return added, skipped
-```
-
----
-
-### Paso 8: orquesta en main.py
-
-```python
-# scraper/main.py
-import os, sys, yaml
-from pathlib import Path
-from dotenv import load_dotenv
-
-load_dotenv()
-
-from scraper.sources import my_source          # agrega tus fuentes
-
-# NOTA: este ejemplo usa Notion. Si storage.provider es "sheets" o "supabase",
-# reemplaza este import por storage.sheets_sync o storage.supabase_sync y actualiza
-# la variable de entorno y la llamada a sync() en consecuencia.
-from storage.notion_sync import sync
-
-SOURCES = [
-    ("Mi fuente", my_source.fetch),
-]
-
-def ai_enabled():
-    return bool(os.environ.get("LLM_API_KEY"))
-
-def main():
-    config = yaml.safe_load((Path(__file__).parent.parent / "config.yaml").read_text())
-    provider = config.get("storage", {}).get("provider", "notion")
-
-    # Resuelve el identificador del destino de almacenamiento desde el entorno según el proveedor
-    if provider == "notion":
-        db_id = os.environ.get("NOTION_DATABASE_ID")
-        if not db_id:
-            print("ERROR: NOTION_DATABASE_ID no está definido"); sys.exit(1)
-    else:
-        # Extiende aquí para sheets (SHEET_ID) o supabase (SUPABASE_TABLE), etc.
-        print(f"ERROR: el proveedor '{provider}' aún no está cableado en main.py"); sys.exit(1)
-
-    all_items = []
-
-    for name, fetch_fn in SOURCES:
-        try:
-            items = fetch_fn()
-            print(f"[{name}] {len(items)} ítems")
-            all_items.extend(items)
-        except Exception as e:
-            print(f"[{name}] FALLÓ: {e}")
-
-    # Deduplicar por URL
-    seen, deduped = set(), []
-    for item in all_items:
-        if (url := item.get("url", "")) and url not in seen:
-            seen.add(url); deduped.append(item)
-
-    print(f"Ítems únicos: {len(deduped)}")
-
-    if ai_enabled() and deduped:
-        from ai.memory import load_feedback, build_preference_prompt
-        from ai.pipeline import analyse_batch
-
-        # load_feedback() lee data/feedback.json escrito por tu script de sync de feedback.
-        # Para mantenerlo al día, implementa un feedback_sync.py aparte que consulte tu
-        # proveedor de almacenamiento por ítems con estados positivos/negativos y llame a save_feedback().
-        feedback = load_feedback()
-        preference = build_preference_prompt(feedback)
-        context_path = Path(__file__).parent.parent / "profile" / "context.md"
-        context = context_path.read_text() if context_path.exists() else ""
-        deduped = analyse_batch(deduped, context=context, preference_prompt=preference)
-    else:
-        print("[IA] Omitida — LLM_API_KEY no está definida")
-
-    added, skipped = sync(db_id, deduped)
-    print(f"Listo — {added} nuevos, {skipped} existentes")
-
-if __name__ == "__main__":
-    main()
-```
-
----
-
-### Paso 9: workflow de GitHub Actions
-
-```yaml
-# .github/workflows/scraper.yml
-name: Agente scraper de datos
-
-on:
-  schedule:
-    - cron: "0 */3 * * *"  # cada 3 horas — ajústalo a tu necesidad
-  workflow_dispatch:        # permitir disparo manual
-
-permissions:
-  contents: write   # requerido para el paso de commit del historial de feedback
-
-jobs:
-  scrape:
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-          cache: "pip"
-
-      - run: pip install -r requirements.txt
-
-      # Descomenta si Playwright está habilitado en requirements.txt
-      # - name: Instalar navegadores de Playwright
-      #   run: python -m playwright install chromium --with-deps
-
-      - name: Ejecutar agente
-        env:
-          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
-          NOTION_DATABASE_ID: ${{ secrets.NOTION_DATABASE_ID }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-          LLM_API_URL: ${{ secrets.LLM_API_URL }}
-          LLM_MODELS: ${{ secrets.LLM_MODELS }}
-        run: python -m scraper.main
-
-      - name: Commit del historial de feedback
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add data/feedback.json || true
-          git diff --cached --quiet || git commit -m "chore: actualizar historial de feedback"
-          git push
-```
-
----
-
-### Paso 10: plantilla de config.yaml
-
-```yaml
-# Personaliza este archivo — sin cambios de código
-
-# Qué recolectar (pre-filtro antes de la IA)
-filters:
-  required_keywords: []      # el ítem debe contener al menos una
-  blocked_keywords: []       # el ítem no debe contener ninguna
-
-# Tus prioridades — la IA las usa para puntuar
-priorities:
-  - "ejemplo de prioridad 1"
-  - "ejemplo de prioridad 2"
-
-# Almacenamiento
-storage:
-  provider: "notion"         # notion | sheets | supabase | sqlite
-
-# Aprendizaje por feedback
-feedback:
-  positive_statuses: ["Saved", "Applied", "Interested"]
-  negative_statuses: ["Skip", "Rejected", "Not relevant"]
-
-# Configuración de IA
-ai:
-  enabled: true
-  model: ""                  # vacío = usar el primero de la cadena LLM_MODELS
-  min_score: 0               # descartar ítems por debajo de este puntaje
-  rate_limit_seconds: 7      # segundos entre llamadas a la API
-  batch_size: 5              # ítems por llamada a la API
-```
-
----
-
-## Patrones comunes de scraping
-
-### Patrón 1: API REST (el más fácil)
-```python
-resp = requests.get(url, params={"q": query}, headers=HEADERS, timeout=15)
-items = resp.json().get("results", [])
-```
-
-### Patrón 2: scraping de HTML
-```python
-soup = BeautifulSoup(resp.text, "lxml")
-for card in soup.select(".listing-card"):
-    title = card.select_one("h2").get_text(strip=True)
-    href = card.select_one("a")["href"]
-```
-
-### Patrón 3: feed RSS
-```python
-import xml.etree.ElementTree as ET
-root = ET.fromstring(resp.text)
-for item in root.findall(".//item"):
-    title = item.findtext("title", "")
-    link = item.findtext("link", "")
-    pub_date = item.findtext("pubDate", "")
-```
-
-### Patrón 4: API paginada
-```python
-page = 1
-while True:
-    resp = requests.get(url, params={"page": page, "limit": 50}, timeout=15)
-    data = resp.json()
-    items = data.get("results", [])
-    if not items:
-        break
-    for item in items:
-        results.append(_normalise(item))
-    if not data.get("has_more"):
-        break
-    page += 1
-```
-
-### Patrón 5: páginas renderizadas con JS (Playwright)
-```python
-from playwright.sync_api import sync_playwright
-
-with sync_playwright() as p:
-    browser = p.chromium.launch()
-    page = browser.new_page()
-    page.goto(url)
-    page.wait_for_selector(".listing")
-    html = page.content()
-    browser.close()
-
-soup = BeautifulSoup(html, "lxml")
-```
-
----
-
-## Antipatrones a evitar
-
-| Antipatrón | Problema | Corrección |
-|---|---|---|
-| Una llamada al LLM por ítem | Golpea los límites de tasa al instante | Lotes de 5 ítems por llamada |
-| Keywords hardcodeadas en el código | No reutilizable | Mover toda la config a `config.yaml` |
-| Scraping sin límite de tasa | Baneo de IP | Añadir `time.sleep(1)` entre peticiones |
-| Guardar secretos en el código | Riesgo de seguridad | Siempre `.env` + GitHub Secrets |
-| Sin deduplicación | Se acumulan filas duplicadas | Verificar siempre la URL antes de empujar |
-| Ignorar `robots.txt` | Riesgo legal/ético | Respetar las reglas de rastreo; usar APIs públicas cuando existan |
-| Sitios con JS usando `requests` | Respuesta vacía | Usar Playwright o buscar la API subyacente |
-| `max_tokens` demasiado bajo | JSON truncado, error de parseo | Usar 2048+ para respuestas en lote |
-
----
-
-## Referencia de límites de capas gratuitas
-
-| Servicio | Límite gratuito | Uso típico |
-|---|---|---|
-| API de LLM (capa gratuita) | Depende del proveedor — verifica RPM/RPD antes de fijar `rate_limit_seconds` | ~56 llamadas/día a intervalos de 3 h con lotes de 5 |
-| GitHub Actions | Ilimitado (repos públicos) | ~20 min/día |
-| API de Notion | Ilimitado | ~200 escrituras/día |
-| Supabase | 500 MB de BD, 2 GB de transferencia | Suficiente para la mayoría de agentes |
-| API de Google Sheets | 300 req/min | Funciona para agentes pequeños |
-
----
-
-## Plantilla de requirements
-
-```
-requests==2.31.0
-beautifulsoup4==4.12.3
-lxml==5.1.0
-python-dotenv==1.0.1
-pyyaml==6.0.2
-notion-client==2.2.1   # si usas Notion
-# playwright==1.40.0   # descomenta para sitios renderizados con JS
-```
-
----
-
-## Checklist de calidad
-
-Antes de dar el agente por terminado:
-
-- [ ] `config.yaml` controla toda la configuración del usuario — sin valores hardcodeados
-- [ ] `profile/context.md` guarda el contexto del usuario para el matching con IA
-- [ ] Deduplicación por URL antes de cada push al almacenamiento
-- [ ] El cliente del LLM tiene cadena de fallback de modelos configurable
-- [ ] Tamaño de lote ≤ 5 ítems por llamada a la API
-- [ ] `max_tokens` ≥ 2048
-- [ ] `.env` está en `.gitignore`
-- [ ] `.env.example` provisto para el onboarding
-- [ ] `setup.py` crea el esquema de la BD en la primera corrida
-- [ ] `enrich_existing.py` rellena puntajes de IA en filas antiguas
-- [ ] El workflow de GitHub Actions hace commit de `feedback.json` tras cada corrida
-- [ ] El README cubre: setup en < 5 minutos, secretos requeridos, personalización
-
----
-
-## Ejemplos del mundo real
-
-```
-"Constrúyeme un agente que monitoree Hacker News por noticias de financiamiento de startups de IA"
-"Scrapea precios de productos de 3 e-commerce y alerta cuando bajen"
-"Rastrea repos nuevos de GitHub con etiqueta 'llm' o 'agents' — resume cada uno"
-"Recolecta avisos de trabajo de Chief of Staff de LinkedIn y Cutshort hacia Notion"
-"Monitorea un subreddit por posts que mencionen mi empresa — clasifica el sentimiento"
-"Scrapea papers académicos nuevos de arXiv sobre un tema que me interesa, a diario"
-"Rastrea resultados de partidos y mantén una tabla al día en Google Sheets"
-"Construye un vigilante de avisos inmobiliarios — alerta sobre propiedades nuevas bajo cierto precio"
-```
-
----
-
-## Implementación de referencia
-
-Un agente completo construido con esta misma arquitectura recolectaría de 4+ fuentes,
-agruparía las llamadas al LLM en lotes, aprendería de las decisiones Applied/Rejected guardadas en Notion
-y correría gratis en GitHub Actions. Sigue los pasos 1–9 de arriba para construir el tuyo.