Initial upload for Build Small Hackathon

.chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6383dc1c0cefbd3b30e42ef6ac1c49139ba41868383b2f882ea9cdaae1980255
+size 188416

.env.example

@@ -0,0 +1,26 @@
+# LetXipu Gradio - Variables de Entorno (Ejemplo)
+# Copia este archivo como .env y rellena con tus propias llaves API
+
+# Backend URL (Opcional, si tienes un servicio externo conectado)
+NEXTJS_API_URL=http://localhost:3000
+API_V1_KEY=
+
+# AI Providers (Llena los que planees utilizar)
+GROQ_API_KEY=tu_api_key_aqui
+OPENROUTER_API_KEY=tu_api_key_aqui
+MISTRAL_API_KEY=tu_api_key_aqui
+GEMINI_API_KEY=tu_api_key_aqui
+DEEPSEEK_API_KEY=tu_api_key_aqui
+NEBIUS_API_KEY=tu_api_key_aqui
+HF_TOKEN=tu_token_huggingface_aqui
+
+# Academic Providers (Opcional, mejora los limites de busqueda)
+CORE_API_KEY=tu_api_key_aqui
+SCOPUS_API_KEY=tu_api_key_aqui
+SEMANTIC_SCHOLAR_API_KEY=tu_api_key_aqui
+SERP_API_KEY=tu_api_key_aqui
+
+# Azure (Solo si utilizas modelos hospedados en Azure)
+AZURE_API_KEY=tu_api_key_aqui
+AZURE_ENDPOINT=tu_endpoint_aqui
+AZURE_AI_ENDPOINT=tu_ai_endpoint_aqui

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+venv/
+__pycache__/
+*.pyc
+.env
+backend/letxipu.db
+data/
+.letxipu/
+.idea/
+.vscode/

ANALISIS_BUGS_REFACTORIZACION.md

@@ -0,0 +1,591 @@
+# Analisis de bugs y refactorizacion
+
+Fecha de revision: 2026-06-08
+
+## Resumen ejecutivo
+
+El proyecto compila y la app importa correctamente, pero hay fallos funcionales y de seguridad que pueden hacer que la interfaz prometa capacidades que el backend no ejecuta, que algunas busquedas fallen silenciosamente, y que datos externos se rendericen como HTML sin escape.
+
+Hallazgos mas importantes:
+
+- La configuracion de fuentes esta desalineada: la UI usa IDs en mayusculas y el motor usa IDs en minusculas.
+- Scopus, CORE y SerpAPI no reciben API keys aunque existan en `.env`.
+- La normalizacion de anos puede romper busquedas con `ValueError` o `TypeError`.
+- Hay varias rutas de XSS/HTML injection al insertar metadatos externos en `gr.HTML`.
+- Los controles de sistema pueden matar todos los procesos `python.exe`.
+- La app crea y muestra credenciales por defecto `admin/admin123`.
+- Las API keys se devuelven al frontend en la pestana de modelos.
+- El mecanismo de detener pipeline usa `StopAsyncIteration` de forma insegura para async generators.
+- La refactorizacion prioritaria debe centralizar fuentes/providers, sanitizar salidas HTML y separar configuracion sensible del cliente.
+
+## Verificaciones realizadas
+
+- `python -m compileall -q .`: OK.
+- `venv\Scripts\python.exe -c "import app; print('app import ok')"`: OK.
+- `python -m pytest -q`: falla porque `pytest` no esta instalado.
+- `venv\Scripts\python.exe -m pytest -q`: falla porque `pytest` no esta instalado en el `venv`.
+- Se reprodujeron fallos con providers simulados:
+  - filtro de fuentes con `OPENALEX` devuelve 0 resultados, con `openalex` devuelve 1.
+  - `year='s.f.'` rompe el filtro de anos.
+  - mezcla `year='2020'` y `year=2019` rompe el ordenamiento.
+
+## Severidad
+
+- P0: riesgo de seguridad o accion destructiva.
+- P1: rompe flujo principal o fuente importante.
+- P2: inconsistencia funcional, deuda tecnica con alto costo futuro.
+- P3: mejora de robustez, UX o mantenibilidad.
+
+## Hallazgos detallados
+
+### 1. Configuracion de fuentes inconsistente
+
+Severidad: P1
+
+Archivos:
+
+- `modules/config/sources_config_tab.py`
+- `backend/tools/search_engine.py`
+- `backend/providers/sources.py`
+- `config.py`
+- `modules/research_tab.py`
+
+Sintoma:
+
+La pestana de configuracion guarda fuentes como `OPENALEX`, `SCOPUS`, `LA_REFERENCIA`, pero el motor de busqueda filtra contra `openalex`, `scopus`, `lareferencia`.
+
+Causa raiz:
+
+Hay varias fuentes de verdad:
+
+- `modules/config/sources_config_tab.py` define IDs en mayusculas.
+- `backend/providers/sources.py` define grupos reales usados por `search_engine`.
+- `config.py` define otro mapa mas amplio con fuentes que no estan implementadas.
+- `modules/research_tab.py` define `ALL_SOURCES` manualmente.
+
+Ademas, en `sources_config_tab.py`, la linea que inicializa `_enabled_sources` dentro de `create_sources_config_tab()` no declara `global`, por lo que crea una variable local. Al arrancar, la configuracion queda ignorada. Cuando el usuario cambia un checkbox, `_update_enabled()` si usa `global`, pero guarda IDs en mayusculas y puede filtrar todo.
+
+Impacto:
+
+- La UI puede decir que una fuente esta activa, pero el backend no la usa.
+- El usuario puede desactivar/activar fuentes y dejar la busqueda sin providers efectivos.
+- Dificulta diagnosticar por que "no hay resultados".
+
+Correccion recomendada:
+
+- Crear un registro unico de fuentes, por ejemplo `backend/providers/registry.py`.
+- Usar siempre IDs canonicos en minusculas.
+- Hacer que la UI derive sus opciones desde ese registro.
+- Normalizar aliases antes de guardar configuracion.
+- Eliminar o consolidar `config.py` si no es la fuente real.
+
+Criterio de aceptacion:
+
+- Activar `OpenAlex` en UI guarda `openalex`.
+- Desactivar `openalex` realmente evita llamadas a OpenAlex.
+- Seleccionar `all` expande solo providers implementados o marca claramente los no implementados.
+
+Pruebas minimas:
+
+- `expand_sources(["all"])` solo devuelve IDs canonicos.
+- `enabled_sources=["OPENALEX"]` se normaliza a `["openalex"]`.
+- `enabled_sources=["openalex"]` permite resultados de OpenAlex.
+
+### 2. Scopus, CORE y SerpAPI no reciben API keys
+
+Severidad: P1
+
+Archivos:
+
+- `backend/tools/search_engine.py`
+- `backend/providers/scopus.py`
+- `backend/providers/core_.py`
+- `backend/providers/serpapi.py`
+
+Sintoma:
+
+Los providers premium o con clave devuelven lista vacia si `api_key` no se pasa como argumento. El motor los llama asi:
+
+```python
+PROVIDERS[src](query, limit=min(max_results, 50))
+```
+
+Causa raiz:
+
+Las claves estan en `.env`, pero no existe una capa que lea `SCOPUS_API_KEY`, `CORE_API_KEY` o `SERPAPI_API_KEY` y las inyecte al provider correspondiente.
+
+Impacto:
+
+- Scopus, CORE y SerpAPI aparecen configurables pero no funcionan.
+- El sistema no distingue "sin resultados" de "no habia credencial".
+
+Correccion recomendada:
+
+- En el registro unico, cada provider debe declarar `env_key`, `requires_key` y `callable`.
+- `search_engine.search()` debe resolver la clave por provider y pasarla como `api_key`.
+- Si falta una clave requerida, devolver metadata tipo `sourceStatus` en lugar de silencio.
+
+Criterio de aceptacion:
+
+- Con `SCOPUS_API_KEY` en `.env`, `search(..., sources=["scopus"])` llama a Scopus con la clave.
+- Sin clave, el resultado indica `scopus: missing_api_key`.
+
+### 3. Filtro y ordenamiento por ano rompen con datos heterogeneos
+
+Severidad: P1
+
+Archivo:
+
+- `backend/tools/search_engine.py`
+
+Sintoma:
+
+El filtro usa `int(r.get("year", 0))` sin validar. Si un provider devuelve `s.f.`, `N/A`, una fecha completa o un string no numerico, la busqueda completa falla.
+
+Reproduccion:
+
+- `year='s.f.'` + `year_start='2020'` lanza `ValueError`.
+- `year='2020'` y `year=2019` sin filtro lanza `TypeError` al ordenar.
+
+Causa raiz:
+
+No hay normalizacion de metadatos a la entrada del motor.
+
+Correccion recomendada:
+
+- Crear `parse_year(value) -> Optional[int]`.
+- Normalizar todos los resultados inmediatamente despues de recibirlos.
+- Ordenar con una key que siempre devuelva int: `parse_year(x.get("year")) or 0`.
+- Los filtros deben ignorar o conservar documentos sin ano segun politica explicita.
+
+Criterio de aceptacion:
+
+- `year="2020"`, `year=2020`, `year="2020-05-01"` se tratan como 2020.
+- `year="s.f."`, `None`, `"N/A"` no rompen.
+
+### 4. HTML injection / XSS en resultados, referencias y grafo
+
+Severidad: P0
+
+Archivos:
+
+- `modules/search_tab.py`
+- `modules/research_tab.py`
+- `modules/graph_module.py`
+- `assets/custom.js`
+
+Sintoma:
+
+Campos de proveedores externos se insertan directo en HTML:
+
+- titulo
+- autores
+- abstract
+- DOI
+- PDF URL
+- fuente
+- contenido generado por IA
+
+Tambien se usan `onclick` inline y `innerHTML`.
+
+Impacto:
+
+Un resultado academico malicioso o un dato corrupto puede inyectar HTML/JS en la app. Aunque sea local, el riesgo aumenta si se comparte con usuarios, se usa `share=True`, o se abre en red.
+
+Correccion recomendada:
+
+- Escapar texto con `html.escape`.
+- Validar URLs con `urllib.parse`; permitir solo `http` y `https`.
+- Construir atributos JS con `json.dumps`, no con reemplazos manuales.
+- Evitar `onclick` inline; delegar eventos desde JS con `data-*`.
+- En grafo, usar `textContent` para texto y crear nodos DOM en vez de concatenar strings con `innerHTML`.
+- Revisar salida Markdown a HTML; si se usa `markdown`, sanitizar o restringir tags.
+
+Criterio de aceptacion:
+
+- Un titulo como `<img src=x onerror=alert(1)>` se muestra como texto, no ejecuta codigo.
+- Una URL `javascript:alert(1)` no se renderiza como link.
+
+### 5. Controles destructivos: reiniciar y matar procesos
+
+Severidad: P0
+
+Archivo:
+
+- `app.py`
+
+Sintoma:
+
+Los botones de control ejecutan:
+
+- `taskkill /F /IM python.exe /T`
+- `taskkill` con `shell=True`
+
+Impacto:
+
+- Puede matar la app actual.
+- Puede matar otros procesos Python del usuario.
+- Puede interrumpir trabajos no relacionados.
+
+Correccion recomendada:
+
+- Eliminar el boton "Matar Procesos" de la UI normal.
+- Si se requiere restart, reiniciar solo el proceso actual con un supervisor controlado.
+- Evitar `shell=True`.
+- No matar por nombre de proceso global.
+
+Criterio de aceptacion:
+
+- Ningun boton de UI mata todos los `python.exe`.
+- Reinicio, si existe, afecta solo a la instancia actual.
+
+### 6. Credenciales por defecto y hash debil
+
+Severidad: P0/P1 segun despliegue
+
+Archivo:
+
+- `app.py`
+
+Sintoma:
+
+La app crea `admin/admin123` y lo muestra en el mensaje de login. La contrasena se almacena con SHA-256 simple, sin sal ni factor de coste.
+
+Impacto:
+
+- Cualquier usuario que vea el login sabe la credencial.
+- Si se filtra la base, el hash es barato de romper.
+
+Correccion recomendada:
+
+- Exigir `LETXIPU_ADMIN_PASSWORD` o crear usuario en un comando setup.
+- No mostrar credenciales en UI.
+- Usar `passlib` con bcrypt/argon2 o `werkzeug.security`.
+- Forzar cambio de password inicial.
+
+Criterio de aceptacion:
+
+- Sin password configurado, la app no crea admin debil.
+- El mensaje de login no contiene credenciales.
+
+### 7. API keys expuestas al frontend
+
+Severidad: P0/P1
+
+Archivo:
+
+- `modules/config/ai_tab.py`
+
+Sintoma:
+
+La pestana de modelos precarga `MISTRAL_API_KEY` en un textbox y al cambiar provider devuelve la clave al cliente.
+
+Impacto:
+
+- Cualquier persona autenticada puede inspeccionar el HTML/estado y extraer secretos.
+- Aumenta el riesgo si la app se comparte.
+
+Correccion recomendada:
+
+- Mostrar solo estado: configurada/no configurada.
+- Si se permite actualizar claves, hacerlo con un flujo de escritura al `.env` cuidadosamente autorizado.
+- Nunca devolver claves existentes al navegador.
+
+Criterio de aceptacion:
+
+- El frontend no recibe valores completos de API keys.
+- El endpoint/evento solo devuelve mascara, por ejemplo `sk-...abcd`.
+
+### 8. Detener pipeline puede terminar como error generico
+
+Severidad: P1/P2
+
+Archivos:
+
+- `backend/pipeline.py`
+- `modules/research_tab.py`
+
+Sintoma:
+
+`_checkpoint()` levanta `StopAsyncIteration`. En async generators, Python convierte esto en `RuntimeError: async generator raised StopAsyncIteration`.
+
+Impacto:
+
+- El boton detener puede mostrar error generico en vez de estado "detenido".
+- La limpieza final puede no ejecutarse como se esperaba.
+
+Correccion recomendada:
+
+- Crear excepcion propia:
+
+```python
+class PipelineStopped(Exception):
+    pass
+```
+
+- Levantar `PipelineStopped`.
+- Capturar `PipelineStopped` en handlers.
+
+Criterio de aceptacion:
+
+- Pulsar detener muestra estado detenido y no un traceback/error generico.
+
+### 9. Cambio de proveedor IA en Research devuelve forma incorrecta
+
+Severidad: P2
+
+Archivo:
+
+- `modules/research_tab.py`
+
+Sintoma:
+
+`update_models()` devuelve un solo `gr.update`, pero esta conectado a tres outputs: busqueda, sintesis y traduccion.
+
+Impacto:
+
+- Al cambiar proveedor, Gradio puede fallar o actualizar solo un componente.
+
+Correccion recomendada:
+
+- Devolver tres updates:
+
+```python
+update = gr.update(choices=models, value=models[0])
+return update, update, update
+```
+
+o una lista de tres updates.
+
+Criterio de aceptacion:
+
+- Cambiar de `mistral` a `groq` actualiza los tres dropdowns.
+
+### 10. Descarga de PDFs: SSRF, TLS deshabilitado y sin limite de tamano
+
+Severidad: P0/P1
+
+Archivos:
+
+- `backend/tools/pdf_tools.py`
+- `backend/tools/pdf_processor.py`
+- `modules/pdf_tab.py`
+- `modules/chat_tab.py`
+
+Sintoma:
+
+Se descargan URLs ingresadas por el usuario desde el servidor. Algunas descargas usan `verify=False`. No hay limite de tamano ni allowlist/bloqueo de IPs internas.
+
+Impacto:
+
+- SSRF contra servicios internos si la app se expone.
+- Descarga de archivos enormes que agotan memoria o disco.
+- TLS sin verificar permite MITM.
+
+Correccion recomendada:
+
+- Activar verificacion TLS.
+- Bloquear IPs privadas/locales: `127.0.0.0/8`, `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, link-local, metadata cloud.
+- Limitar tamano por `Content-Length` y streaming con max bytes.
+- Permitir solo `http`/`https`.
+- Reusar un downloader comun.
+
+Criterio de aceptacion:
+
+- URL `http://127.0.0.1/...` se rechaza.
+- PDF mayor al limite se corta con error claro.
+
+### 11. Catalogo de fuentes promete providers no implementados
+
+Severidad: P2
+
+Archivos:
+
+- `README.md`
+- `config.py`
+- `modules/config/sources_config_tab.py`
+- `backend/providers/sources.py`
+- `backend/tools/search_engine.py`
+
+Sintoma:
+
+Se mencionan fuentes como SciELO, CONAHCyT, UNAM, ANID, OasisBR, SNRD, MinCiencias, OpenReview, PapersWithCode o HuggingFace, pero el mapa real `PROVIDERS` no contiene implementaciones para muchas de ellas.
+
+Impacto:
+
+- La UI genera expectativas falsas.
+- Los grupos `all`, `latam`, `ai_ml` pueden incluir fuentes que no hacen nada.
+
+Correccion recomendada:
+
+- El registro unico debe marcar `implemented=True/False`.
+- La UI debe ocultar fuentes no implementadas o mostrarlas como "proximamente".
+- Los grupos operativos deben incluir solo implementadas.
+
+Criterio de aceptacion:
+
+- No se puede seleccionar una fuente no implementada como si estuviera activa.
+
+### 12. Manejo de errores silencioso en providers
+
+Severidad: P2
+
+Archivos:
+
+- `backend/providers/*.py`
+- `backend/providers/base.py`
+- `backend/tools/search_engine.py`
+
+Sintoma:
+
+Muchos providers hacen `except Exception: return []`. `fetch_json()` tambien convierte cualquier error en `{"error": str(e)}`.
+
+Impacto:
+
+- Timeouts, credenciales faltantes, 403/429 y errores de parseo se ven igual que "0 resultados".
+- Dificulta depurar fuentes rotas.
+
+Correccion recomendada:
+
+- Devolver estructura por fuente:
+
+```python
+{
+  "source": "openalex",
+  "ok": true,
+  "results": [],
+  "error": None,
+  "status": "ok"
+}
+```
+
+- `search()` debe conservar `sourceErrors` y mostrarlos en UI.
+
+Criterio de aceptacion:
+
+- Si PubMed falla por timeout, la UI muestra "PubMed timeout" y no solo "sin resultados".
+
+## Plan de refactorizacion recomendado
+
+### Fase 1: estabilizacion funcional
+
+Objetivo: que las busquedas basicas sean confiables.
+
+Tareas:
+
+- Crear `backend/providers/registry.py`.
+- Consolidar grupos y aliases en un solo lugar.
+- Normalizar IDs de fuentes a minusculas.
+- Pasar API keys por provider desde `.env`.
+- Agregar `parse_year()` y normalizacion de resultados.
+- Corregir `update_models()` para multiples outputs.
+- Reemplazar `StopAsyncIteration` por `PipelineStopped`.
+
+Resultado esperado:
+
+- `search()` no se cae por anos raros.
+- Fuentes activadas en UI coinciden con providers usados.
+- Scopus/CORE/SerpAPI usan claves si existen.
+- Detener pipeline funciona sin error generico.
+
+### Fase 2: seguridad de interfaz y secretos
+
+Objetivo: eliminar riesgos P0.
+
+Tareas:
+
+- Escapar HTML en `search_tab`, `research_tab` y `graph_module`.
+- Validar links antes de renderizar.
+- Quitar `onclick` inline donde sea posible.
+- No devolver API keys al frontend.
+- Remover credenciales por defecto o exigir password por env.
+- Eliminar controles `taskkill` globales.
+
+Resultado esperado:
+
+- Datos externos no ejecutan HTML/JS.
+- Las claves no viajan al navegador.
+- La app no mata procesos ajenos.
+
+### Fase 3: downloader PDF seguro
+
+Objetivo: robustecer lectura/vectorizacion/chat con PDFs.
+
+Tareas:
+
+- Crear `backend/tools/downloader.py`.
+- Bloquear IPs internas y esquemas no permitidos.
+- Descargar en streaming con limite de tamano.
+- Activar TLS verification.
+- Unificar `pdf_tools.py`, `pdf_processor.py` y `chat_tab.py`.
+
+Resultado esperado:
+
+- El PDF local funciona sin abrir SSRF ni OOM.
+
+### Fase 4: arquitectura de resultados y errores
+
+Objetivo: dejar de mezclar "sin resultados" con "fuente rota".
+
+Tareas:
+
+- Definir `SearchResult` y `SourceSearchOutcome`.
+- Hacer que providers devuelvan resultados normalizados.
+- Agregar `sourcesUsed`, `sourcesSkipped`, `sourceErrors`.
+- Mostrar estado por fuente en UI.
+
+Resultado esperado:
+
+- La UI puede decir: "OpenAlex OK, PubMed timeout, Scopus falta API key".
+
+### Fase 5: pruebas y CI local
+
+Objetivo: evitar regresiones.
+
+Tareas:
+
+- Agregar `pytest` a `requirements-dev.txt` o `requirements.txt`.
+- Tests unitarios para:
+  - expansion de fuentes
+  - normalizacion de aliases
+  - parseo de anos
+  - providers con/sin API key
+  - escape HTML
+  - detener pipeline
+- Tests de integracion con providers simulados.
+
+Resultado esperado:
+
+- `pytest -q` corre sin depender de red.
+- Los bugs reproducidos quedan cubiertos.
+
+## Orden de implementacion sugerido
+
+1. `registry.py` de fuentes/providers.
+2. Normalizacion de resultados y anos.
+3. API keys por provider.
+4. Correccion de `update_models()` y `PipelineStopped`.
+5. Escape HTML y validacion de URLs.
+6. Retiro de `taskkill`, credenciales por defecto y exposicion de secrets.
+7. Downloader PDF seguro.
+8. Tests.
+
+## Archivos mas importantes para tocar
+
+- `backend/tools/search_engine.py`
+- `backend/providers/sources.py`
+- `backend/providers/registry.py` nuevo
+- `modules/config/sources_config_tab.py`
+- `modules/research_tab.py`
+- `modules/search_tab.py`
+- `modules/graph_module.py`
+- `modules/config/ai_tab.py`
+- `backend/tools/pdf_tools.py`
+- `backend/tools/pdf_processor.py`
+- `modules/chat_tab.py`
+- `app.py`
+- `requirements.txt` o `requirements-dev.txt`
+
+## Nota sobre el estado del repo
+
+El arbol de trabajo ya tenia cambios modificados y archivos sin seguimiento antes de este informe. No se debe hacer `reset` ni revertir esos cambios sin revisar su origen.

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

Letxinet_Explicacion.html

@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <title>Letxinet Gradio - Explicación</title>
+    <style>
+        body { font-family: Arial, sans-serif; line-height: 1.6; margin: 40px; color: #333; }
+        h1 { color: #4338ca; border-bottom: 2px solid #e0e7ff; padding-bottom: 10px; }
+        h2 { color: #3730a3; margin-top: 30px; }
+        p { text-align: justify; }
+        ul { margin-bottom: 20px; }
+        li { margin-bottom: 10px; }
+    </style>
+</head>
+<body>
+
+    <h1>LETXINET GRADIO - Asistente de Investigación Académica</h1>
+
+    <p><strong>Letxinet Gradio</strong> es una avanzada plataforma de investigación científica impulsada por Inteligencia Artificial y agentes autónomos. Desarrollada y diseñada íntegramente de forma independiente por el equipo <strong>c2mv</strong>, esta aplicación está especialmente ajustada para entornos de investigación universitaria y para el <em>Build Small Hackathon de HuggingFace</em>.</p>
+
+    <h2>CARACTERÍSTICAS PRINCIPALES</h2>
+
+    <ul>
+        <li><strong>1. Motor de Búsqueda Multi-Repositorio y Bypass "Anubis":</strong><br>
+        El núcleo del programa permite realizar búsquedas simultáneas en docenas de bases de datos. A diferencia de un buscador tradicional, Letxinet Gradio implementa un "DME" (Deep Metadata Enhancement) y mecanismos de bypass heurísticos que permiten burlar escudos anti-bot como Cloudflare o DSpace v7. Esto le permite extraer PDFs ocultos de repositorios latinoamericanos como ALICIA o RENATI, lo cual es vital para investigaciones en Perú. Además incluye un "Fallback Manager" que lanza búsquedas de rescate en OpenAlex y Semantic Scholar si los repositorios locales fallan o bloquean el acceso.</li>
+
+        <li><strong>2. Ecosistema de Agentes y Arquitectura ARA+</strong><br>
+        El sistema emplea un pipeline jerárquico. No le hace una sola pregunta a la IA, sino que lanza un enjambre de agentes:
+        <ul>
+            <li><em>El Metodólogo:</em> Revisa que el diseño científico sea sólido (usa protocolo GRADE).</li>
+            <li><em>El Teórico:</em> Elabora el marco conceptual.</li>
+            <li><em>El Arquitecto:</em> Orquesta el plan maestro de investigación.</li>
+            <li><em>El ARA+ (Agente de Refinamiento Académico):</em> La última fase, se encarga de corregir anglicismos, asegurar la cohesión geográfica (ej. priorizar datos de la "Universidad Nacional del Santa", Perú) y garantizar la escritura en formato científico impecable.</li>
+        </ul>
+        </li>
+
+        <li><strong>3. Análisis de PDFs con PyMuPDF</strong><br>
+        Se incluye un potente procesador de PDFs locales. En lugar de procesar ciegamente el texto, utiliza expresiones regulares complejas para separar el documento en "Metodología", "Resultados", "Conclusiones" y extraer estadísticas críticas (p-values, intervalos de confianza). El sistema soporta la inclusión de datos directamente a un ChromaDB (base de datos vectorial local) para el sistema de RAG (Retrieval-Augmented Generation).</li>
+
+        <li><strong>4. Clasificación GRADE Exhaustiva</strong><br>
+        Se integraron 4 modos de evaluación de evidencia médica y científica: Keywords, Oxford, LLM e Híbrido. El algoritmo evalúa cada fuente y determina si es una evidencia de nivel ALTO (ej. Metaanálisis) o MUY BAJO (ej. Opinión experta), ponderando los resultados finales para evitar sesgos en el informe redactado por la IA.</li>
+
+        <li><strong>5. Visualización Avanzada y Exportaciones Universales</strong><br>
+        La herramienta incluye:
+        <ul>
+            <li>Interfaz gráfica basada en Gradio (Glassmorphism, Dark Mode).</li>
+            <li>Generación de grafos interactivos (Pyvis y NetworkX) que mapean co-citaciones.</li>
+            <li>Sistema unificado de exportación de resultados a: Markdown, BibTeX (para gestores como Zotero o Mendeley), Word (.docx) y empaquetamiento del workspace en ZIP (informe, CSV de metadatos, configuraciones).</li>
+        </ul>
+        </li>
+    </ul>
+
+    <h2>CÓMO EJECUTAR ESTA APLICACIÓN</h2>
+
+    <ol>
+        <li>El sistema opera completamente en local con un entorno virtual Python (venv).</li>
+        <li>Todo el código fuente está alojado en GitHub y usa HuggingFace Spaces/Modelos a través de las APIs correspondientes.</li>
+        <li>El frontend de Gradio se lanza usando <code>python app.py</code>. Se ha eliminado cualquier capa de autenticación restrictiva; ahora es <strong>libre y de código abierto (Open Source)</strong>, listo para demostraciones y despliegues sin contraseña.</li>
+    </ol>
+
+</body>
+</html>

Letxinet_Explicacion.pdf

@@ -0,0 +1,99 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R /F3 5 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/Contents 10 0 R /MediaBox [ 0 0 612 792 ] /Parent 9 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+5 0 obj
+<<
+/BaseFont /Helvetica-Oblique /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font
+>>
+endobj
+6 0 obj
+<<
+/Contents 11 0 R /MediaBox [ 0 0 612 792 ] /Parent 9 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+7 0 obj
+<<
+/PageMode /UseNone /Pages 9 0 R /Type /Catalog
+>>
+endobj
+8 0 obj
+<<
+/Author (\(anonymous\)) /CreationDate (D:20260615184121-05'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260615184121-05'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (\(anonymous\)) /Trapped /False
+>>
+endobj
+9 0 obj
+<<
+/Count 2 /Kids [ 4 0 R 6 0 R ] /Type /Pages
+>>
+endobj
+10 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2261
+>>
+stream
+Gat=+?$G&5&Ui!/Qo?IrXGW2=OhB)IP%a0b9%om1*5+T_7)K0/"X(3RIXU[8,%Wi>DR[Y6Yt5"a4#;*K$mHVJ-OTl$3RRM_rq7Y4BLp;U7H=B7QFA\VIe`mc3ip!,U5Mf7/B5:fGiu@CfG6=l@8Dn^L(mq`.Dm=$dCl)'s#%E\0'V[a^6q-3UuaBas2&FK"$^_M^\Ans*s\$3iV_=Y?V"*d8gVa+:AR:g,#PDg`Q1lGLibL8O)gMA<n$(`Rst,*r6q;?oENA"MLe13]b%OO_l5B.@p-Gm,7FA57&he0:SeXKG/F.gWM$@/L"KLo$\kb>6V\?.!Trt_0U'YgV=n>eFmuSr>%Q,-Wc=pU]0]r.&t8M>16.&9;&8+MRp4dJ)sN&t<bjm4:T<mt?R(#/9A#@eOk3I3YUPdYXYd!aYM$M:ND95^<*N#S3M[q=TUQA]h;MW[QYm<7.,b)*_k5XS]NU<7&UnXE,HkpAk7UG@=5a;@Q$(+CP>Nfhg.CI-+l'+pljl2N:WT\3V,LRY6>QEEP5g?tadVs#g![>bbEU,_Ld^sk(it^e-Q"YRqXYDm`:J5ZSBb32k^9Y*:#Z=>c=cm8fjfCk?*o2#%8MJ1>3fkSJ-]I_7.*Nm]!DZ%a5D8$\fCS8V*lg$8mSC%\_L?kgH+hL:Y5KGn=D\G.G)^d5.<ft%pQkT*^ULQ75NJ)(dt*p"X6ZFB:5KeL30s-=.Bt.r=G"?8$JStb(5nYAL&=nU!tF;Ld7]Bn1sp(MLqlQDKqAFNHCkopiC._?$[n(U/>k=-d!@$Hh>%X;4LfFFTq6ugtYUc[-HL=\YVC06nXMLS=1g6P-B9*&M_L@,)l)<`U@pad3i'X/kAf%_$;r"qob(kL:bk]AVtEC+>%A5:kB<uXA#uQdgal"Z?3G*K#P+/m*jH#Q?70daVQo`*Bi8,nRN<OXMWqVH1hB3;T;$>*%I9_nVsOCFuGc-0Jf?Xa3.VH[&'RO#U.2Le>9<_nQ"[S,=>'EV;n'h!NF:'=!"CT?1()D4'tgZCQp7'#m32/S]2qq6aMZa9mXU7I'I%5*["XkQ7n'a6KT8bKGM[njktCfPl@5?2A$kC2D?Wi*?AC#$NkVWqM?J[hR3d.3'(&tU\::)\eYmH.ItfEX_JL=6.P]D4","jPG1H]Tc8JuK/>^D^TK3Cq\O"N2D(?TJ_XJ;7HZCgSiM)VLg_R;:\TE@:WtV4EZSXYXida+U(GB]c/Kei1R='S/'Y>]QtMPb?0FA*hGqZhpj2XtNWU7nbGO%u[*@t#T/:pJGKPhO%>h,iSUJsg/U=kf_]^M;.,***D?sWZ_.0':VQ5dV5<uO8UIV8C'/6:eXDQLGEoCC\YpfWhJI;4JA"+I13;*C169f$UAA71-O3X>3P".THK74N*?ZOcomIuQk98GsS1d5b/2p-rHULmlZ;0MX&B3;W*86cYP._qJ^F;?n"C.s<(!eV0P^^B1r>8[Wr+FLkk"bQd_]/$VE0kh9t,lOFeB+iY=S-oGHW[j_=8<lO7ZMXqZB+*ABq=QEVU`uX^;9<up*t.:_kk&WS@0LNsQpIUB&jIkh&/(m-F[8[;,ZMG>%V-[@^"2QQ_XQW:0YA8#Gs*!1.Lem5.o[iW)g!$XU<!4<M2*u3dALuRan*?j%_Rn,7<r[L)&jk'+UjpH7WHdN8<tE)Ag2U_XE,AllnDQd%0cTgm87"7mbLAFG_'E#W^!_2E;p:$#3tdgJIdaY9E+$>;57X_JX=GT-g1T22WFp[OumaLdF!KmG8cKa3tog:<+\1Qd^f[(3MglMKs`25i9Kc2GC-b3)C=!&3""p>:sf`gh^DM]a992>9Q)X8(T`"DAQ@EcfNaIZ:aUr15K"m^m,Z:A>hiT%.ZZ("V*!60`rgbr2V;5p\]5c==I[?<EPPfp:._*AMp![(8Em03d\3RC;bPm61$34qK"B>u/!!G(GMK*Q(7m0-c0QM$Q)631!oq#K[9h(OW3os3]@^igL.dLnNJo<qBpCQ98D*tL02u*aIQ?^uaqD%1HO'FAJ!^&iX@pB\LDNKJMFm=2NfG:_`_4nnSKq#tkR?,oEZ<6-hE]H_>-fYFZ>fo/"V5(t0NENc4<aeWehLk/mIHq`]Z(Z3Q/\_GTRs#P?iNjPnLoZo(k@jMY?<Lqp^0j)LC2%L%RPqg=,fIfM%Iim%mUl-G]^ir,^j;'X"MY-;hjt,LTON$]JnUQ6]5lZe#-,2GkHRMi-CsoWI,Qfs5o&C?`Wp/<%,GtTR#`)m+OO?o\mR9l2`L~>endstream
+endobj
+11 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 874
+>>
+stream
+Gas2H;/b/B&BE]*.IJoa'F4_?F\e5fb60C9fiD*u3>*^L:$gAQB^)GP?(e9t<FlICgNWDds*bb+3jeh]2_G(_6>0/Bn@K7/i:gD<#\Ph$:EE=0rQVNY0^*ZD1@<J+s,^VR0h!*CgZ@X<N_[8]#2Tbs/W@M4$KVhpMXtR5c5R>O",($s4,'YS_PHr.R>HNeT?8!ZKbb=)U#=@,+uMdFAWG=Wg6?AeM^EgAo)Nj&LoA^IS*a*%@5+!E0F/@<K!Jjc/QHu,n)T6&7,DCbOVYBE/_lOJ&%>C<*\.6pQ3%f>qD=LuZ=kQN;>R,r:)!u!Ot8H;>XCQ>g:4U\NNcFNkh#s._jn(\qFNR'6EWXp9D(q7#aqnldoEDLBXlNe:kPpoEOE>RM9*XoC,FnQ2@5)F&fj3#eh)]P6rNApcE`BKpa*Ae=KldhdffnGQ"j6R-B+7?=BIj$#s)pmLGH,8WQZiuJ*sA0F@6E4UihV^^s'IGm<!Mj]QX:AOrd!=Sob:A)R2*<`>_632jiL<pr@XO3un6OnM2*$E&!iBL8-1>?@SiJJ(FQ`8`(V;J8)di3Mq65`];\"F*1'QE)XoL%46R?7ro\\:>:Z;%rAgS)E-$RMRF=*\#,A1gBb2I@^=a?:_P8,TU5aOA>UNPG$1qWjoKOOcS.*CdToj'l>U;HY,X%:.[tBQQeY`uB'+0s$Cnq,'_HgsNMYl!FEG$[1/iqS.^_kcO<]^:qR*<M['(+&hG9R$4R**\[N[_S8:)!9rUS+e,I&e(j`Z.KC8TU7V1:E4D(Z3qpbacDo2nRm+N>%nc9WUS<8#Y!^!7$XF[kqHi]"Z\-N@d4Ek*rWX<<5sXhtlbFSn_?.ESciY"UD';[XuQ!3^`k3r~>endstream
+endobj
+xref
+0 12
+0000000000 65535 f 
+0000000061 00000 n 
+0000000112 00000 n 
+0000000219 00000 n 
+0000000331 00000 n 
+0000000525 00000 n 
+0000000640 00000 n 
+0000000834 00000 n 
+0000000902 00000 n 
+0000001182 00000 n 
+0000001247 00000 n 
+0000003600 00000 n 
+trailer
+<<
+/ID 
+[<6395a77bd2f5083957b1812ea19c317b><6395a77bd2f5083957b1812ea19c317b>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 8 0 R
+/Root 7 0 R
+/Size 12
+>>
+startxref
+4565
+%%EOF

README.md

@@ -1,13 +1,108 @@
 ---
-title: Letxinet
-emoji: 💻
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
-app_file: app.py
+title: "Letxinet Gradio"
+emoji: "🔬"
+colorFrom: "purple"
+colorTo: "indigo"
+sdk: "gradio"
+sdk_version: "4.0.0"
+app_file: "app.py"
 pinned: false
+tags:
+  - build-small-hackathon
+  - agents
+  - research
+  - smolagents
+  - langchain
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Letxinet Gradio: Asistente de Investigación Académica 🔬🤖
+
+**Hackathon Submission: Build Small Hackathon**
+
+* 🎥 **Demo Video:** [Ver Demo en YouTube](https://youtube.com/) *(Inserta el enlace final de tu demo aquí)*
+* 🌐 **Social Link:** [Publicación en X / LinkedIn](https://twitter.com/) *(Inserta el enlace final de tu publicación aquí)*
+* 👥 **Team Usernames:** [@c2mv](https://huggingface.co/c2mv)
+
+Letxinet Gradio es una avanzada plataforma de investigación científica impulsada por Inteligencia Artificial y agentes autónomos. Permite realizar búsquedas profundas en docenas de repositorios académicos globales y regionales, sintetizar miles de documentos, construir mapas de conocimiento y renderizar informes matemáticos y científicos con alta fidelidad (LaTeX y Markdown).
+
+## 🌟 Características Principales
+
+* **Búsqueda Multi-Repositorio:** Conexión nativa con OpenAlex, PubMed, arXiv, Scopus, Crossref, DOAJ, Zenodo, repositorios de LATAM (ALICIA, RENATI, SciELO, Redalyc) y más.
+* **Agentes de Síntesis IA:** Un ecosistema de agentes (Arquitecto, Redactor, Validador, ARA+) que leen, analizan y redactan informes científicos complejos sin alucinaciones.
+* **Formatos Científicos Precisos:** Soporte nativo para matemáticas, símbolos químicos, notación científica y estructuración estricta en LaTeX adaptada al navegador.
+* **Mapeo de Conocimiento:** Generación de grafos interactivos de redes de citas, coautoría e instituciones utilizando análisis relacional profundo.
+* **Vectores y Memoria Local:** Procesamiento avanzado de PDFs y embeddings para chatear con tus propios documentos y recuperar datos clave instantáneamente.
+
+---
+
+## ⚙️ Requisitos y Dependencias
+
+Asegúrate de tener instalado **Python 3.10 o superior**. 
+
+Las dependencias clave que hacen posible este proyecto son:
+* **Gradio 4+:** Interfaz web interactiva e intuitiva.
+* **LangChain & ChromaDB:** Cerebro vectorial y RAG (Retrieval-Augmented Generation) para leer PDFs.
+* **PyMuPDF:** Extracción ultrarrápida de texto de documentos científicos.
+* **NetworkX & Pyvis:** Renderizado de grafos relacionales y redes.
+* **SQLAlchemy:** Almacenamiento local de historial de investigaciones.
+* **Modelos IA:** Soporte múltiple para Mistral, Llama, OpenAI, Anthropic a través de Groq, OpenRouter y APIs nativas.
+
+Puedes ver la lista técnica completa en el archivo `requirements.txt`.
+
+---
+
+## 🚀 Instalación y Despliegue Local
+
+Sigue estos pasos para levantar la plataforma en tu máquina:
+
+### 1. Clonar el Repositorio
+```bash
+git clone https://github.com/C2MV96/letxinet-gradio.git
+cd letxinet-gradio
+```
+
+### 2. Crear un Entorno Virtual
+Se recomienda aislar las dependencias en un entorno virtual (`venv`):
+```bash
+# En Windows:
+python -m venv venv
+venv\Scripts\activate
+
+# En Linux/Mac:
+python3 -m venv venv
+source venv/bin/activate
+```
+
+### 3. Instalar Dependencias
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Configurar Variables de Entorno
+El sistema necesita credenciales para acceder a los LLMs (Inteligencias Artificiales) y a las bases de datos académicas de pago/privadas.
+1. Copia el archivo `.env.example` y renómbralo a `.env`:
+   ```bash
+   cp .env.example .env
+   ```
+2. Abre el archivo `.env` y pega tus llaves API (ej. `MISTRAL_API_KEY`, `GROQ_API_KEY`). *No necesitas llenar todas, solo las que planees usar.*
+
+### 5. Iniciar la Aplicación
+Ejecuta el archivo principal para iniciar el servidor local:
+```bash
+python app.py
+```
+O si estás en Windows, simplemente dale doble clic al archivo `start.bat`.
+
+La aplicación se abrirá en tu navegador (por defecto en `http://127.0.0.1:7860`).
+
+---
+
+## 📖 Estructura del Proyecto
+
+* `/backend`: Contiene el núcleo lógico, los agentes IA, parsers de repositorios (`/providers`), y prompts científicos (`/prompts`).
+* `/modules`: Componentes de interfaz (UI) escritos en Gradio (pestañas, configuraciones, reportes).
+* `/assets`: Archivos estáticos como estilos CSS personalizados, librerías de interfaz de cristal (Glassmorphism) y scripts.
+* `/lib`: Librerías frontend pesadas de terceros empaquetadas localmente (vis.js, tom-select).
+
+## 🛡️ Seguridad
+* Las carpetas `venv`, bases de datos SQLite y el archivo `.env` están debidamente ignoradas (`.gitignore`) para que tu información y llaves API permanezcan completamente seguras y locales.

app.py

@@ -0,0 +1,224 @@
+"""
+LetXipu Beta SX - Gradio Interface v9.0
+Dark/Light Theme · Glassmorphism · Chatbot-like Interface
+"""
+
+import gradio as gr
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from dotenv import load_dotenv
+load_dotenv(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env"))
+
+from modules.search_tab import create_search_tab
+from modules.metadata_tab import create_metadata_tab
+from modules.pdf_tab import create_pdf_tab
+from modules.research_tab import create_research_tab
+from modules.sources_tab import create_sources_tab
+from modules.prompts_config_tab import create_prompts_config_tab
+from modules.config.agents_tab import create_agents_tab
+from modules.config.sources_config_tab import create_sources_config_tab
+from modules.config.ai_tab import create_ai_tab
+from modules.config.mining_tab import create_mining_tab
+from modules.history_tab import create_history_tab
+
+from backend.database.models import init_db
+init_db()
+
+VERSION = "9.0.0"
+
+# Note: Gradio loads external CSS and JS
+assets_dir = os.path.join(os.path.dirname(__file__), "assets")
+
+def create_app():
+    with gr.Blocks(title="LetXipu Beta SX") as app:
+        
+        # ─── Theme Toggle Button ───
+        gr.HTML("""
+        <button class="theme-toggle" id="theme-toggle" onclick="toggleTheme()" title="Cambiar a modo claro">
+            ☀️
+        </button>
+        """)
+
+        # ─── Header ───
+        gr.HTML(f"""
+        <div class="header-banner">
+            <div style="display: flex; justify-content: space-between; align-items: center; position: relative; z-index: 2;">
+                <div>
+                    <h1>🔬 LetXipu Beta SX</h1>
+                    <p>Motor de Búsqueda Académica Independiente · Python Backend</p>
+                </div>
+                <div style="display: flex; gap: 8px; align-items: center;">
+                    <div class="header-badge">v{VERSION}</div>
+                    <div class="header-badge" style="background: rgba(16, 185, 129, 0.2); border-color: rgba(16, 185, 129, 0.3); color: #10b981;">17 fuentes</div>
+                    <div class="header-badge" style="background: rgba(59, 130, 246, 0.2); border-color: rgba(59, 130, 246, 0.3); color: #3b82f6;">87 modelos</div>
+                </div>
+            </div>
+        </div>
+        """)
+
+        # ─── Status ───
+        gr.HTML("""
+        <div class="status-banner status-connected">
+            <span class="status-dot connected"></span>
+            <span>✅ Backend Python independiente activo — Pipeline completo con 12 fases</span>
+        </div>
+        """)
+
+        # ─── Tabs ───
+        with gr.Tabs(elem_id="main-tabs") as tabs:
+            with gr.TabItem("🔍 Búsqueda y Extracción", id="search"):
+                create_search_tab()
+            with gr.TabItem("🔬 Agente de Research", id="research"):
+                create_research_tab()
+            with gr.TabItem("📄 Análisis PDF Local", id="pdf"):
+                create_pdf_tab()
+            with gr.TabItem("⚙️ Configuración (Core)", id="config_core"):
+                create_sources_tab()
+                create_prompts_config_tab()
+            with gr.TabItem("🛠️ Ajustes Avanzados", id="config_adv"):
+                create_agents_tab()
+                create_sources_config_tab()
+                create_ai_tab()
+                create_mining_tab()
+            with gr.TabItem("🕰️ Historial", id="history"):
+                create_history_tab()
+
+        # ─── Control Buttons ───
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 🛠️ Controles del Sistema")
+            with gr.Column(scale=2):
+                with gr.Row():
+                    restart_btn = gr.Button("🔄 Reiniciar App", variant="secondary", size="sm")
+                    clear_cache_btn = gr.Button("🗑️ Limpiar Cache", variant="secondary", size="sm")
+                    clear_processes_btn = gr.Button("🧹 Matar Procesos", variant="secondary", size="sm")
+                control_output = gr.Markdown("")
+
+                def do_restart():
+                    import subprocess
+                    import sys
+                    try:
+                        # Kill all python processes except current
+                        os.system("taskkill /F /IM python.exe /T 2>nul")
+                        # Restart the app
+                        subprocess.Popen([sys.executable, "app.py"], cwd=os.path.dirname(os.path.abspath(__file__)))
+                        return "🔄 Reiniciando app... La página se recargará en unos segundos."
+                    except Exception as e:
+                        return f"❌ Error al reiniciar: {str(e)}"
+
+                def do_clear_cache():
+                    import shutil
+                    cleared = []
+                    # Clear Gradio cache
+                    gradio_cache = os.path.join(os.path.expanduser("~"), ".cache", "gradio")
+                    if os.path.exists(gradio_cache):
+                        shutil.rmtree(gradio_cache, ignore_errors=True)
+                        cleared.append("Gradio cache")
+                    # Clear Python __pycache__
+                    for root, dirs, files in os.walk(os.path.dirname(os.path.abspath(__file__))):
+                        for d in dirs:
+                            if d == "__pycache__":
+                                shutil.rmtree(os.path.join(root, d), ignore_errors=True)
+                                cleared.append(root)
+                    # Clear prompts config cache
+                    prompts_cache = os.path.join(os.path.dirname(os.path.abspath(__file__)), "prompts_config.json")
+                    if os.path.exists(prompts_cache):
+                        os.remove(prompts_cache)
+                        cleared.append("prompts_config.json")
+                    return f"🗑️ Cache limpiado: {', '.join(cleared) if cleared else 'nada que limpiar'}"
+
+                def do_clear_processes():
+                    import subprocess
+                    try:
+                        # Kill orphaned python processes
+                        result = subprocess.run(["taskkill", "/F", "/IM", "python.exe", "/T"], 
+                                              capture_output=True, text=True, shell=True)
+                        return f"🧹 Procesos limpiados: {result.stdout.strip() if result.stdout else 'completado'}"
+                    except Exception as e:
+                        return f"❌ Error: {str(e)}"
+
+                restart_btn.click(fn=do_restart, outputs=[control_output])
+                clear_cache_btn.click(fn=do_clear_cache, outputs=[control_output])
+                clear_processes_btn.click(fn=do_clear_processes, outputs=[control_output])
+
+        # ─── Footer ───
+        gr.HTML(f"""
+        <div class="app-footer">
+            <span>LetXipu Beta SX v{VERSION} · Independiente · 2026</span>
+            <span>Backend: Python + httpx · Frontend: Gradio · 17 fuentes · 87 modelos · Pipeline de 12 fases</span>
+        </div>
+        """)
+
+    return app
+
+
+if __name__ == "__main__":
+    from backend.database.models import SessionLocal, User
+    import hashlib
+    
+    # Asegurar que existe al menos un usuario administrador
+    def init_admin():
+        db = SessionLocal()
+        admin = db.query(User).filter(User.username == "admin").first()
+        if not admin:
+            hashed = hashlib.sha256("admin123".encode()).hexdigest()
+            db.add(User(username="admin", hashed_password=hashed, role="admin"))
+            db.commit()
+        db.close()
+        
+    def check_auth(username, password):
+        db = SessionLocal()
+        user = db.query(User).filter(User.username == username).first()
+        db.close()
+        if user and user.hashed_password == hashlib.sha256(password.encode()).hexdigest():
+            return True
+        return False
+
+    init_admin()
+    app = create_app()
+    with open("assets/styles.css", "r", encoding="utf-8") as f:
+        custom_css = f.read()
+        
+    with open("assets/custom.js", "r", encoding="utf-8") as f:
+        custom_js = f.read()
+
+    app.launch(
+        server_name="127.0.0.1",
+        share=False,
+        show_error=True,
+        allowed_paths=[assets_dir],
+        theme=gr.themes.Base(
+            primary_hue="purple",
+            secondary_hue="indigo",
+        ).set(
+            body_background_fill="#0a0a0c",
+            body_background_fill_dark="#0a0a0c",
+            block_background_fill="#111827",
+            block_background_fill_dark="#111827",
+            block_border_color="#374151",
+            block_border_color_dark="#374151",
+            block_label_text_color="#9ca3af",
+            block_label_text_color_dark="#9ca3af",
+            block_title_text_color="#ffffff",
+            block_title_text_color_dark="#ffffff",
+            input_background_fill="#1f2937",
+            input_background_fill_dark="#1f2937",
+            input_border_color="#374151",
+            input_border_color_dark="#374151",
+            button_primary_background_fill="#8b5cf6",
+            button_primary_background_fill_dark="#8b5cf6",
+            button_primary_text_color="#ffffff",
+            button_secondary_background_fill="#1f2937",
+            button_secondary_background_fill_dark="#1f2937",
+            button_secondary_text_color="#9ca3af",
+            checkbox_background_color="#1f2937",
+            checkbox_background_color_dark="#1f2937",
+            slider_color="#8b5cf6",
+            slider_color_dark="#8b5cf6",
+        ),
+        css=custom_css,
+        js=custom_js
+    )

assets/custom.js

@@ -0,0 +1,460 @@
+// ─── Theme Management ───
+let currentTheme = 'dark';
+
+function toggleTheme() {
+    currentTheme = currentTheme === 'dark' ? 'light' : 'dark';
+    const html = document.documentElement;
+    
+    // Set theme attribute — CSS variables handle the rest
+    html.setAttribute('data-theme', currentTheme);
+    
+    if (currentTheme === 'light') {
+        document.body.classList.remove('dark');
+    } else {
+        document.body.classList.add('dark');
+    }
+
+    // Override Gradio internal CSS variables
+    const root = document.documentElement;
+    const isLight = currentTheme === 'light';
+    
+    const vars = isLight ? {
+        '--body-background-fill': '#f8fafc',
+        '--block-background-fill': '#ffffff',
+        '--block-border-color': '#e2e8f0',
+        '--block-label-text-color': '#475569',
+        '--block-title-text-color': '#0f172a',
+        '--input-background-fill': '#f1f5f9',
+        '--input-border-color': '#cbd5e1',
+        '--body-text-color': '#0f172a',
+        '--neutral-100': '#f1f5f9',
+        '--neutral-200': '#e2e8f0',
+        '--neutral-300': '#cbd5e1',
+        '--neutral-400': '#94a3b8',
+        '--neutral-500': '#64748b',
+        '--neutral-600': '#475569',
+        '--neutral-700': '#334155',
+        '--neutral-800': '#1e293b',
+        '--neutral-900': '#0f172a',
+    } : {
+        '--body-background-fill': '#0a0a0c',
+        '--block-background-fill': '#111827',
+        '--block-border-color': '#374151',
+        '--block-label-text-color': '#9ca3af',
+        '--block-title-text-color': '#ffffff',
+        '--input-background-fill': '#1f2937',
+        '--input-border-color': '#374151',
+        '--body-text-color': '#ffffff',
+        '--neutral-100': '#1f2937',
+        '--neutral-200': '#374151',
+        '--neutral-300': '#4b5563',
+        '--neutral-400': '#6b7280',
+        '--neutral-500': '#9ca3af',
+        '--neutral-600': '#d1d5db',
+        '--neutral-700': '#e5e7eb',
+        '--neutral-800': '#f3f4f6',
+        '--neutral-900': '#ffffff',
+    };
+
+    // Apply Gradio vars to all containers
+    document.querySelectorAll('.gradio-container').forEach(el => {
+        Object.entries(vars).forEach(([k, v]) => el.style.setProperty(k, v));
+        el.style.background = isLight ? '#f8fafc' : '#0a0a0c';
+        el.style.color = isLight ? '#0f172a' : '#ffffff';
+    });
+
+    // Force Gradio block/form/panel backgrounds
+    const bgColor = isLight ? '#ffffff' : '#111827';
+    const borderColor = isLight ? '#e2e8f0' : '#374151';
+    const textColor = isLight ? '#0f172a' : '#ffffff';
+    const subTextColor = isLight ? '#475569' : '#9ca3af';
+    const inputBg = isLight ? '#f1f5f9' : '#1f2937';
+
+    document.querySelectorAll('.block, .form, .panel').forEach(el => {
+        el.style.backgroundColor = bgColor;
+        el.style.borderColor = borderColor;
+    });
+    document.querySelectorAll('input, textarea, select').forEach(el => {
+        if (!el.closest('.glass-input-wrapper')) {
+            el.style.backgroundColor = inputBg;
+            el.style.borderColor = borderColor;
+        }
+        el.style.color = textColor;
+    });
+    document.querySelectorAll('label, .label-wrap, .block-label').forEach(el => {
+        if (!el.closest('.header-banner') && !el.closest('.glass-input-wrapper')) {
+            el.style.color = subTextColor;
+        }
+    });
+
+    // Update toggle button icon
+    const btn = document.getElementById('theme-toggle');
+    if (btn) {
+        btn.innerHTML = currentTheme === 'dark' ? '☀️' : '🌙';
+        btn.title = currentTheme === 'dark' ? 'Cambiar a modo claro' : 'Cambiar a modo oscuro';
+    }
+    
+    // Save preference
+    try { localStorage.setItem('letxipu-theme', currentTheme); } catch(e) {}
+}
+
+// Initialize theme on load (respect saved preference)
+document.addEventListener('DOMContentLoaded', function() {
+    try {
+        var saved = localStorage.getItem('letxipu-theme');
+        if (saved === 'light') {
+            currentTheme = 'dark'; // will be toggled to light
+            toggleTheme();
+            return;
+        }
+    } catch(e) {}
+    document.body.classList.add('dark');
+    document.documentElement.setAttribute('data-theme', 'dark');
+});
+
+window._copyCitation = function(btn, citeText) {
+    navigator.clipboard.writeText(citeText).then(function() {
+        var originalHtml = btn.innerHTML;
+        btn.innerHTML = '✅ Copiado';
+        btn.style.color = '#10b981';
+        btn.style.borderColor = 'rgba(16,185,129,0.3)';
+        setTimeout(function() {
+            btn.innerHTML = originalHtml;
+            btn.style.color = 'var(--foreground, #fff)';
+            btn.style.borderColor = 'var(--border, rgba(255,255,255,0.1))';
+        }, 2000);
+    });
+};
+
+// ─── Citation Floating Card (Global) ───
+window.showCiteCard = function(el) {
+    var b64 = el.getAttribute('data-cite-b64');
+    var raw = el.getAttribute('data-cite');
+    if (!b64 && !raw) return;
+    var data;
+    try {
+        if (b64) {
+            var decoded = decodeURIComponent(escape(atob(b64)));
+            data = JSON.parse(decoded);
+        } else {
+            data = JSON.parse(raw.replace(/"/g,'"').replace(/'/g,"'"));
+        }
+    } catch(e) { console.error('CiteCard parse error', e); return; }
+
+    var card = document.getElementById('cite-card-global');
+    var overlay = document.getElementById('cite-card-overlay-global');
+
+    if (!card) {
+        overlay = document.createElement('div');
+        overlay.id = 'cite-card-overlay-global';
+        overlay.style.cssText = 'display:none;position:fixed;top:0;left:0;width:100%;height:100%;z-index:999998;background:transparent;';
+        overlay.addEventListener('click', function(){ window.closeCiteCard(); });
+        document.body.appendChild(overlay);
+
+        card = document.createElement('div');
+        card.id = 'cite-card-global';
+        card.style.cssText = 'display:none;position:fixed;z-index:999999;width:340px;max-width:90vw;background:var(--popup-bg, rgba(17,24,39,0.95));backdrop-filter:blur(10px);border:1px solid var(--popup-border, rgba(139,92,246,0.3));border-radius:12px;box-shadow:0 20px 60px rgba(0,0,0,0.5),0 0 30px rgba(139,92,246,0.1);font-family:Inter,sans-serif;transition:opacity 0.2s ease,transform 0.2s ease;opacity:0;transform:translateY(8px);color:var(--foreground, #fff);display:flex;flex-direction:column;';
+        card.innerHTML = '<div id="cite-card-content-global" style="display:flex;flex-direction:column;height:100%;"></div>';
+        document.body.appendChild(card);
+        
+        // Setup dragging
+        var isDragging = false;
+        var dragOffset = {x: 0, y: 0};
+        
+        document.addEventListener('mousemove', function(e) {
+            if (isDragging && card) {
+                card.style.left = (e.clientX - dragOffset.x) + 'px';
+                card.style.top = (e.clientY - dragOffset.y) + 'px';
+                card.style.transform = 'none'; // Clear animation transform
+            }
+        });
+        document.addEventListener('mouseup', function(e) {
+            isDragging = false;
+        });
+        
+        window._startCardDrag = function(e) {
+            isDragging = true;
+            var rect = card.getBoundingClientRect();
+            dragOffset.x = e.clientX - rect.left;
+            dragOffset.y = e.clientY - rect.top;
+            e.preventDefault();
+        };
+    }
+
+    overlay = document.getElementById('cite-card-overlay-global');
+    var content = document.getElementById('cite-card-content-global');
+
+    var doi = data.DOI || data.doi || '';
+    var pdfUrl = data.pdf_url || data.PDF || '';
+    var title = data['Título'] || data.title || 'Sin título';
+    var authors = data['Autores'] || data.authors || 'Autor desconocido';
+    var year = data['Año'] || data.year || '?';
+    var source = data['Fuente'] || data.source || 'Desconocido';
+    var abstract = data['Abstract'] || data.abstract || '';
+    
+    // Icon SVGs
+    var iconMove = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="5 9 2 12 5 15"></polyline><polyline points="9 5 12 2 15 5"></polyline><polyline points="19 9 22 12 19 15"></polyline><polyline points="9 19 12 22 15 19"></polyline><line x1="2" y1="12" x2="22" y2="12"></line><line x1="12" y1="2" x2="12" y2="22"></line></svg>';
+    var iconX = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>';
+    var iconMsg = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path></svg>';
+    var iconDl = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></svg>';
+    var iconQuote = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 21c3 0 7-1 7-8V5c0-1.25-.756-2.017-2-2H4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2 1 0 1 0 1 1v1c0 1-1 2-2 2s-1 .008-1 1.031V20c0 1 0 1 1 1z"></path><path d="M15 21c3 0 7-1 7-8V5c0-1.25-.757-2.017-2-2h-4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2h.75c0 2.25.25 4-2.75 4v3c0 1 0 1 1 1z"></path></svg>';
+    var iconLang = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 8l6 6"></path><path d="M4 14l6-6 2-3"></path><path d="M2 5h12"></path><path d="M7 2h1"></path><path d="M22 22l-5-10-5 10"></path><path d="M14 18h6"></path></svg>';
+    var iconBranch = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="transform: rotate(90deg);"><line x1="6" y1="3" x2="6" y2="15"></line><circle cx="18" cy="6" r="3"></circle><circle cx="6" cy="18" r="3"></circle><path d="M18 9a9 9 0 0 1-9 9"></path></svg>';
+    var iconExt = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>';
+    var iconSearch = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>';
+
+    // Header
+    var headerHtml = 
+        '<div onmousedown="window._startCardDrag(event)" style="padding:12px;border-bottom:1px solid rgba(255,255,255,0.1);display:flex;justify-content:space-between;align-items:center;cursor:grab;user-select:none;background:rgba(255,255,255,0.02);border-top-left-radius:12px;border-top-right-radius:12px;">' +
+            '<div style="display:flex;align-items:center;gap:6px;color:var(--accent, #8b5cf6);">' +
+                iconMove +
+                '<span style="font-size:11px;font-weight:700;letter-spacing:0.5px;">CITAR</span>' +
+            '</div>' +
+            '<button class="close-cite-btn" style="background:transparent;border:none;color:#9ca3af;cursor:pointer;display:flex;">' +
+                iconX +
+            '</button>' +
+        '</div>';
+
+    var authorStr = Array.isArray(authors) ? authors.join(', ') : authors;
+    var firstAuthor = Array.isArray(authors) ? authors[0] : authors.split(",")[0];
+
+    // Compute source URL and button styling
+    var sourceUrl = data.url || data.URL || '';
+    if (!sourceUrl && doi) sourceUrl = 'https://doi.org/' + doi;
+    if (!sourceUrl) sourceUrl = '#';
+
+    var sourceBtnText = 'Ver fuente';
+    var sourceBtnColor = '#a78bfa';
+    var sourceBtnBg = 'rgba(139,92,246,0.1)';
+    var sourceBtnBorder = 'rgba(139,92,246,0.3)';
+    var sourceBtnIcon = iconExt;
+
+    if (source.toLowerCase().includes('pubmed')) {
+        sourceBtnText = 'PubMed'; sourceBtnColor = '#22c55e'; sourceBtnBg = 'rgba(34,197,94,0.1)'; sourceBtnBorder = 'rgba(34,197,94,0.3)'; sourceBtnIcon = iconSearch;
+    } else if (source.toLowerCase().includes('semantic')) {
+        sourceBtnText = 'Semantic Scholar'; sourceBtnColor = '#3b82f6'; sourceBtnBg = 'rgba(59,130,246,0.1)'; sourceBtnBorder = 'rgba(59,130,246,0.3)'; sourceBtnIcon = iconSearch;
+    } else if (source.toLowerCase().includes('crossref')) {
+        sourceBtnText = 'Crossref'; sourceBtnColor = '#f59e0b'; sourceBtnBg = 'rgba(245,158,11,0.1)'; sourceBtnBorder = 'rgba(245,158,11,0.3)'; sourceBtnIcon = iconSearch;
+    } else if (source.toLowerCase().includes('openalex')) {
+        sourceBtnText = 'OpenAlex'; sourceBtnColor = '#ec4899'; sourceBtnBg = 'rgba(236,72,153,0.1)'; sourceBtnBorder = 'rgba(236,72,153,0.3)'; sourceBtnIcon = iconSearch;
+    } else if (doi) {
+        sourceBtnText = 'DOI'; sourceBtnColor = '#06b6d4'; sourceBtnBg = 'rgba(6,182,212,0.1)'; sourceBtnBorder = 'rgba(6,182,212,0.3)'; sourceBtnIcon = iconExt;
+    }
+
+    var citeString = firstAuthor + " et al. (" + year + "). " + title + ". " + sourceUrl;
+    var escapedCiteString = citeString.replace(/'/g, "\\'").replace(/"/g, "&quot;").replace(/\n/g, " ").replace(/\r/g, "");
+
+    // Buttons
+    var actionBtnsHtml = 
+        '<div style="display:flex;gap:8px;margin-bottom:12px;flex-wrap:wrap;">' +
+            '<button onclick="alert(\'Función Chat IA se implementará nativamente pronto.\')" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;border-radius:6px;padding:6px;cursor:pointer;font-size:11px;font-weight:600;background:var(--popup-god-bg, rgba(139,92,246,0.15));border:1px solid var(--popup-god-border, rgba(139,92,246,0.3));color:var(--popup-god-color, #c084fc);">' +
+                iconMsg + ' Chat IA' +
+            '</button>' +
+            (pdfUrl ? 
+            '<a href="'+pdfUrl+'" target="_blank" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;border-radius:6px;padding:6px;cursor:pointer;font-size:11px;font-weight:600;background:var(--input-bg, rgba(255,255,255,0.05));border:1px solid var(--border, rgba(255,255,255,0.1));color:var(--foreground, #fff);text-decoration:none;">' +
+                iconDl + ' Descargar' +
+            '</a>' : '') +
+            '<button onclick="window._copyCitation(this, \'' + escapedCiteString + '\')" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;border-radius:6px;padding:6px;cursor:pointer;font-size:11px;font-weight:600;background:var(--input-bg, rgba(255,255,255,0.05));border:1px solid var(--border, rgba(255,255,255,0.1));color:var(--foreground, #fff);">' +
+                iconQuote + ' Citar' +
+            '</button>' +
+            '<button onclick="alert(\'Traducción en la vista web disponible próximamente.\')" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;border-radius:6px;padding:6px;cursor:pointer;font-size:11px;font-weight:600;background:var(--input-bg, rgba(255,255,255,0.05));border:1px solid var(--border, rgba(255,255,255,0.1));color:var(--foreground, #fff);">' +
+                iconLang + ' Traducir' +
+            '</button>' +
+            '<button onclick="alert(\'Añadido al flujo (simulación).\')" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;border-radius:6px;padding:6px;cursor:pointer;font-size:11px;font-weight:600;background:rgba(249,115,22,0.15);border:1px solid rgba(249,115,22,0.3);color:var(--warning, #f59e0b);">' +
+                iconBranch + ' Flujo' +
+            '</button>' +
+        '</div>';
+
+    // Abstract box
+    var abstractHtml = '';
+    if (abstract) {
+        abstractHtml = 
+            '<div class="custom-scrollbar" style="max-height:120px;overflow-y:auto;font-size:11px;line-height:1.5;color:var(--foreground, #fff);margin-bottom:16px;padding:8px;background:var(--input-bg, rgba(0,0,0,0.2));border-radius:6px;text-align:justify;">' +
+                abstract +
+            '</div>';
+    }
+
+    var bodyHtml = 
+        '<div style="padding:16px;">' +
+            '<div style="font-size:14px;font-weight:700;margin-bottom:8px;line-height:1.4;color:white;word-break:break-word;white-space:normal;">' + title + '</div>' +
+            actionBtnsHtml +
+            '<div style="font-size:12px;color:#9ca3af;margin-bottom:12px;padding-bottom:12px;border-bottom:1px solid rgba(255,255,255,0.08);word-break:break-word;white-space:normal;">' +
+                authorStr + ' <span style="margin:0 6px;color:rgba(255,255,255,0.2);">|</span> ' + year +
+            '</div>' +
+            abstractHtml +
+            '<div style="display:flex;gap:8px;">' +
+                '<a href="'+sourceUrl+'" target="_blank" class="paper-action-btn" style="flex:1;display:flex;align-items:center;justify-content:center;gap:6px;font-size:11px;font-weight:600;color:'+sourceBtnColor+';background:'+sourceBtnBg+';text-decoration:none;padding:8px;border-radius:6px;border:1px solid '+sourceBtnBorder+';">' +
+                    sourceBtnIcon + sourceBtnText +
+                '</a>' +
+            '</div>' +
+        '</div>';
+
+    content.innerHTML = headerHtml + bodyHtml;
+
+    // Centering Logic
+    var rect = el.getBoundingClientRect();
+    var cardW = 340;
+    var left = rect.left + rect.width/2 - cardW/2;
+    if (left < 10) left = 10;
+    if (left + cardW > window.innerWidth - 10) left = window.innerWidth - cardW - 10;
+    
+    // Position slightly offset from cursor or element
+    var top = rect.bottom + 10;
+    if (top + 400 > window.innerHeight) {
+        top = window.innerHeight - 410; 
+        if (top < 10) top = 10;
+    }
+
+    card.style.left = left + 'px';
+    card.style.top = top + 'px';
+    overlay.style.display = 'block';
+    card.style.display = 'flex';
+    setTimeout(function(){ card.style.opacity='1'; card.style.transform='translateY(0)'; }, 10);
+};
+
+window.closeCiteCard = function() {
+    var card = document.getElementById('cite-card-global');
+    var overlay = document.getElementById('cite-card-overlay-global');
+    if (card) {
+        card.style.opacity = '0';
+        card.style.transform = 'translateY(8px)';
+        setTimeout(function(){ card.style.display='none'; if(overlay) overlay.style.display='none'; }, 200);
+    }
+};
+
+// Event Delegation for Cite Links (Fix for Gradio 6 removing inline onclick handlers)
+document.addEventListener('click', function(e) {
+    const citeLink = e.target.closest('.cite-link');
+    if (citeLink) {
+        e.preventDefault();
+        window.showCiteCard(citeLink);
+        return;
+    }
+    
+    // Check for close button
+    if (e.target.closest('.close-cite-btn')) {
+        e.preventDefault();
+        window.closeCiteCard();
+    }
+});
+
+// References Pagination Logic
+window.initRefsPagination = function() {
+    var container = document.getElementById('refs-container');
+    if (!container) return;
+    var items = Array.from(container.querySelectorAll('.ref-item'));
+    var filterCb = document.getElementById('refs-filter-cited');
+    var citedFilter = filterCb ? filterCb.checked : false;
+    
+    var visibleItems = items.filter(function(item) {
+        if (citedFilter && item.getAttribute('data-cited') !== 'true') return false;
+        return true;
+    });
+    
+    var perPage = 10;
+    var totalPages = Math.ceil(visibleItems.length / perPage);
+    var currentPage = parseInt(container.getAttribute('data-page')) || 1;
+    if (currentPage > totalPages && totalPages > 0) currentPage = totalPages;
+    if (currentPage < 1) currentPage = 1;
+    
+    items.forEach(function(item) { item.style.display = 'none'; });
+    
+    var start = (currentPage - 1) * perPage;
+    var end = start + perPage;
+    for (var i = start; i < end && i < visibleItems.length; i++) {
+        visibleItems[i].style.display = 'flex';
+    }
+    
+    var pagContainer = document.getElementById('refs-pagination');
+    if (pagContainer) {
+        pagContainer.innerHTML = '';
+        if (totalPages > 1) {
+            var createBtn = function(text, page, disabled, active) {
+                var b = document.createElement('button');
+                b.innerHTML = text;
+                b.style.cssText = 'padding: 6px 14px; margin: 0 2px; border: 1px solid var(--border, #374151); background: ' + (active ? 'var(--accent, #8b5cf6)' : 'transparent') + '; color: ' + (active ? '#fff' : 'var(--foreground, #d1d5db)') + '; border-radius: 6px; cursor: ' + (disabled ? 'default' : 'pointer') + '; opacity: ' + (disabled ? '0.5' : '1') + '; font-size: 13px; font-weight: 600; transition: all 0.2s;';
+                if (!disabled && !active) {
+                    b.onmouseover = function() { b.style.background = 'rgba(139,92,246,0.15)'; };
+                    b.onmouseout = function() { b.style.background = 'transparent'; };
+                    b.onclick = function() {
+                        container.setAttribute('data-page', page);
+                        window.initRefsPagination();
+                        // Scroll to top of container smoothly
+                        var y = container.getBoundingClientRect().top + window.scrollY - 100;
+                        window.scrollTo({top: y, behavior: 'smooth'});
+                    };
+                }
+                return b;
+            };
+            
+            pagContainer.appendChild(createBtn('Anterior', currentPage - 1, currentPage === 1, false));
+            
+            var startP = Math.max(1, currentPage - 2);
+            var endP = Math.min(totalPages, startP + 4);
+            if (endP - startP < 4) startP = Math.max(1, endP - 4);
+            
+            for (var p = startP; p <= endP; p++) {
+                pagContainer.appendChild(createBtn(p, p, false, p === currentPage));
+            }
+            
+            pagContainer.appendChild(createBtn('Siguiente', currentPage + 1, currentPage === totalPages, false));
+        }
+    }
+    
+    var stats = document.getElementById('refs-stats');
+    if (stats) stats.innerHTML = 'Mostrando ' + (visibleItems.length > 0 ? start + 1 : 0) + ' - ' + Math.min(end, visibleItems.length) + ' de <b>' + visibleItems.length + '</b> referencias';
+};
+
+// Make Headers Collapsible
+window.makeHeadersCollapsible = function() {
+    var container = document.getElementById('report-content');
+    if (!container) return;
+    
+    // Prevent double processing
+    if (container.getAttribute('data-collapsible-processed') === 'true') return;
+    container.setAttribute('data-collapsible-processed', 'true');
+    
+    var headers = Array.from(container.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+    if (headers.length === 0) return;
+    
+    headers.forEach(function(h) {
+        if (h.parentElement && h.parentElement.tagName.toLowerCase() === 'summary') return;
+        
+        var details = document.createElement('details');
+        details.open = true; // Open by default as requested
+        
+        var summary = document.createElement('summary');
+        summary.innerHTML = h.innerHTML;
+        summary.className = h.className;
+        
+        h.parentNode.insertBefore(details, h);
+        details.appendChild(summary);
+        
+        var headerLevel = parseInt(h.tagName[1]);
+        var next = h.nextSibling;
+        
+        while (next) {
+            var current = next;
+            next = next.nextSibling;
+            
+            if (current.nodeType === 1 && current.tagName.match(/^H[1-6]$/i)) {
+                var currentLevel = parseInt(current.tagName[1]);
+                if (currentLevel <= headerLevel) {
+                    break;
+                }
+            }
+            details.appendChild(current);
+        }
+        h.remove();
+    });
+};
+
+// MathJax Loading
+window.MathJax = {
+  tex: { inlineMath: [['$','$'], ['\\\\(','\\\\)']], displayMath: [['$$','$$'], ['\\\\[','\\\\]']] },
+  options: { skipHtmlTags: ['script','noscript','style','textarea','pre','code'] }
+};
+const script = document.createElement('script');
+script.src = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js";
+script.async = true;
+document.head.appendChild(script);

assets/graphs/graph_01ea5af0.html

@@ -0,0 +1,201 @@
+<html>
+    <head>
+        <meta charset="utf-8">
+        
+            <script src="lib/bindings/utils.js"></script>
+            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css" integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js" integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+            
+                <link href="lib/tom-select/tom-select.css" rel="stylesheet">
+                <script src="lib/tom-select/tom-select.complete.min.js"></script>
+            
+        
+<center>
+<h1></h1>
+</center>
+
+<!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
+<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <link
+          href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
+          crossorigin="anonymous"
+        />
+        <script
+          src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
+          integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
+          crossorigin="anonymous"
+        ></script>
+
+
+        <center>
+          <h1></h1>
+        </center>
+        <style type="text/css">
+
+             #mynetwork {
+                 width: 100%;
+                 height: 600px;
+                 background-color: #0f172a;
+                 border: 1px solid lightgray;
+                 position: relative;
+                 float: left;
+             }
+
+             
+
+             
+
+             
+        </style>
+    </head>
+
+
+    <body>
+        <div class="card" style="width: 100%">
+            
+                <div id="select-menu" class="card-header">
+                    <div class="row no-gutters">
+                        <div class="col-10 pb-2">
+                            <select
+                            class="form-select"
+                            aria-label="Default select example"
+                            onchange="selectNode([value]);"
+                            id="select-node"
+                            placeholder="Select node..."
+                            >
+                                <option selected>Select a Node by ID</option>
+                                
+                                    <option value="Desconocido...">Desconocido...</option>
+                                
+                                    <option value="Fuente Desconocida">Fuente Desconocida</option>
+                                
+                            </select>
+                        </div>
+                        <div class="col-2 pb-2">
+                            <button type="button" class="btn btn-primary btn-block" onclick="neighbourhoodHighlight({nodes: []});">Reset Selection</button>
+                        </div>
+                    </div>
+                </div>
+            
+            
+            <div id="mynetwork" class="card-body"></div>
+        </div>
+
+        
+        
+
+        <script type="text/javascript">
+
+              // initialize global variables.
+              var edges;
+              var nodes;
+              var allNodes;
+              var allEdges;
+              var nodeColors;
+              var originalNodes;
+              var network;
+              var container;
+              var options, data;
+              var filter = {
+                  item : '',
+                  property : '',
+                  value : []
+              };
+
+              
+                  new TomSelect("#select-node",{
+                      create: false,
+                      sortField: {
+                          field: "text",
+                          direction: "asc"
+                      }
+                  });
+              
+
+              
+
+              // This method is responsible for drawing the graph, returns the drawn network
+              function drawGraph() {
+                  var container = document.getElementById('mynetwork');
+
+                  
+
+                  // parsing and collecting nodes and edges from the python
+                  nodes = new vis.DataSet([{"color": "#8b5cf6", "font": {"color": "white"}, "id": "Desconocido...", "label": "Desconocido...", "shape": "dot", "size": 20, "title": ""}, {"color": "#10b981", "font": {"color": "white"}, "id": "Fuente Desconocida", "label": "Fuente Desconocida", "shape": "square", "size": 25}]);
+                  edges = new vis.DataSet([{"from": "Desconocido...", "to": "Fuente Desconocida", "width": 1}]);
+
+                  nodeColors = {};
+                  allNodes = nodes.get({ returnType: "Object" });
+                  for (nodeId in allNodes) {
+                    nodeColors[nodeId] = allNodes[nodeId].color;
+                  }
+                  allEdges = edges.get({ returnType: "Object" });
+                  // adding nodes and edges to the graph
+                  data = {nodes: nodes, edges: edges};
+
+                  var options = {
+    "configure": {
+        "enabled": false
+    },
+    "edges": {
+        "color": {
+            "inherit": true
+        },
+        "smooth": {
+            "enabled": true,
+            "type": "dynamic"
+        }
+    },
+    "interaction": {
+        "dragNodes": true,
+        "hideEdgesOnDrag": false,
+        "hideNodesOnDrag": false
+    },
+    "physics": {
+        "enabled": true,
+        "forceAtlas2Based": {
+            "avoidOverlap": 0,
+            "centralGravity": 0.01,
+            "damping": 0.4,
+            "gravitationalConstant": -50,
+            "springConstant": 0.08,
+            "springLength": 100
+        },
+        "solver": "forceAtlas2Based",
+        "stabilization": {
+            "enabled": true,
+            "fit": true,
+            "iterations": 1000,
+            "onlyDynamicEdges": false,
+            "updateInterval": 50
+        }
+    }
+};
+
+                  
+
+
+                  
+
+                  network = new vis.Network(container, data, options);
+
+                  
+
+                  
+                    network.on("selectNode", neighbourhoodHighlight);
+                  
+
+                  
+
+
+                  
+
+                  return network;
+
+              }
+              drawGraph();
+        </script>
+    </body>
+</html>

assets/graphs/graph_5a169899.html

@@ -0,0 +1,201 @@
+<html>
+    <head>
+        <meta charset="utf-8">
+        
+            <script src="lib/bindings/utils.js"></script>
+            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css" integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js" integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+            
+                <link href="lib/tom-select/tom-select.css" rel="stylesheet">
+                <script src="lib/tom-select/tom-select.complete.min.js"></script>
+            
+        
+<center>
+<h1></h1>
+</center>
+
+<!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
+<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <link
+          href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
+          crossorigin="anonymous"
+        />
+        <script
+          src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
+          integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
+          crossorigin="anonymous"
+        ></script>
+
+
+        <center>
+          <h1></h1>
+        </center>
+        <style type="text/css">
+
+             #mynetwork {
+                 width: 100%;
+                 height: 600px;
+                 background-color: #0f172a;
+                 border: 1px solid lightgray;
+                 position: relative;
+                 float: left;
+             }
+
+             
+
+             
+
+             
+        </style>
+    </head>
+
+
+    <body>
+        <div class="card" style="width: 100%">
+            
+                <div id="select-menu" class="card-header">
+                    <div class="row no-gutters">
+                        <div class="col-10 pb-2">
+                            <select
+                            class="form-select"
+                            aria-label="Default select example"
+                            onchange="selectNode([value]);"
+                            id="select-node"
+                            placeholder="Select node..."
+                            >
+                                <option selected>Select a Node by ID</option>
+                                
+                                    <option value="Desconocido...">Desconocido...</option>
+                                
+                                    <option value="Fuente Desconocida">Fuente Desconocida</option>
+                                
+                            </select>
+                        </div>
+                        <div class="col-2 pb-2">
+                            <button type="button" class="btn btn-primary btn-block" onclick="neighbourhoodHighlight({nodes: []});">Reset Selection</button>
+                        </div>
+                    </div>
+                </div>
+            
+            
+            <div id="mynetwork" class="card-body"></div>
+        </div>
+
+        
+        
+
+        <script type="text/javascript">
+
+              // initialize global variables.
+              var edges;
+              var nodes;
+              var allNodes;
+              var allEdges;
+              var nodeColors;
+              var originalNodes;
+              var network;
+              var container;
+              var options, data;
+              var filter = {
+                  item : '',
+                  property : '',
+                  value : []
+              };
+
+              
+                  new TomSelect("#select-node",{
+                      create: false,
+                      sortField: {
+                          field: "text",
+                          direction: "asc"
+                      }
+                  });
+              
+
+              
+
+              // This method is responsible for drawing the graph, returns the drawn network
+              function drawGraph() {
+                  var container = document.getElementById('mynetwork');
+
+                  
+
+                  // parsing and collecting nodes and edges from the python
+                  nodes = new vis.DataSet([{"color": "#8b5cf6", "font": {"color": "white"}, "id": "Desconocido...", "label": "Desconocido...", "shape": "dot", "size": 20, "title": ""}, {"color": "#10b981", "font": {"color": "white"}, "id": "Fuente Desconocida", "label": "Fuente Desconocida", "shape": "square", "size": 25}]);
+                  edges = new vis.DataSet([{"from": "Desconocido...", "to": "Fuente Desconocida", "width": 1}]);
+
+                  nodeColors = {};
+                  allNodes = nodes.get({ returnType: "Object" });
+                  for (nodeId in allNodes) {
+                    nodeColors[nodeId] = allNodes[nodeId].color;
+                  }
+                  allEdges = edges.get({ returnType: "Object" });
+                  // adding nodes and edges to the graph
+                  data = {nodes: nodes, edges: edges};
+
+                  var options = {
+    "configure": {
+        "enabled": false
+    },
+    "edges": {
+        "color": {
+            "inherit": true
+        },
+        "smooth": {
+            "enabled": true,
+            "type": "dynamic"
+        }
+    },
+    "interaction": {
+        "dragNodes": true,
+        "hideEdgesOnDrag": false,
+        "hideNodesOnDrag": false
+    },
+    "physics": {
+        "enabled": true,
+        "forceAtlas2Based": {
+            "avoidOverlap": 0,
+            "centralGravity": 0.01,
+            "damping": 0.4,
+            "gravitationalConstant": -50,
+            "springConstant": 0.08,
+            "springLength": 100
+        },
+        "solver": "forceAtlas2Based",
+        "stabilization": {
+            "enabled": true,
+            "fit": true,
+            "iterations": 1000,
+            "onlyDynamicEdges": false,
+            "updateInterval": 50
+        }
+    }
+};
+
+                  
+
+
+                  
+
+                  network = new vis.Network(container, data, options);
+
+                  
+
+                  
+                    network.on("selectNode", neighbourhoodHighlight);
+                  
+
+                  
+
+
+                  
+
+                  return network;
+
+              }
+              drawGraph();
+        </script>
+    </body>
+</html>

assets/graphs/graph_77739dd7.html

@@ -0,0 +1,201 @@
+<html>
+    <head>
+        <meta charset="utf-8">
+        
+            <script src="lib/bindings/utils.js"></script>
+            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css" integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js" integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+            
+                <link href="lib/tom-select/tom-select.css" rel="stylesheet">
+                <script src="lib/tom-select/tom-select.complete.min.js"></script>
+            
+        
+<center>
+<h1></h1>
+</center>
+
+<!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
+<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <link
+          href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
+          crossorigin="anonymous"
+        />
+        <script
+          src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
+          integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
+          crossorigin="anonymous"
+        ></script>
+
+
+        <center>
+          <h1></h1>
+        </center>
+        <style type="text/css">
+
+             #mynetwork {
+                 width: 100%;
+                 height: 600px;
+                 background-color: #0f172a;
+                 border: 1px solid lightgray;
+                 position: relative;
+                 float: left;
+             }
+
+             
+
+             
+
+             
+        </style>
+    </head>
+
+
+    <body>
+        <div class="card" style="width: 100%">
+            
+                <div id="select-menu" class="card-header">
+                    <div class="row no-gutters">
+                        <div class="col-10 pb-2">
+                            <select
+                            class="form-select"
+                            aria-label="Default select example"
+                            onchange="selectNode([value]);"
+                            id="select-node"
+                            placeholder="Select node..."
+                            >
+                                <option selected>Select a Node by ID</option>
+                                
+                                    <option value="Desconocido...">Desconocido...</option>
+                                
+                                    <option value="Fuente Desconocida">Fuente Desconocida</option>
+                                
+                            </select>
+                        </div>
+                        <div class="col-2 pb-2">
+                            <button type="button" class="btn btn-primary btn-block" onclick="neighbourhoodHighlight({nodes: []});">Reset Selection</button>
+                        </div>
+                    </div>
+                </div>
+            
+            
+            <div id="mynetwork" class="card-body"></div>
+        </div>
+
+        
+        
+
+        <script type="text/javascript">
+
+              // initialize global variables.
+              var edges;
+              var nodes;
+              var allNodes;
+              var allEdges;
+              var nodeColors;
+              var originalNodes;
+              var network;
+              var container;
+              var options, data;
+              var filter = {
+                  item : '',
+                  property : '',
+                  value : []
+              };
+
+              
+                  new TomSelect("#select-node",{
+                      create: false,
+                      sortField: {
+                          field: "text",
+                          direction: "asc"
+                      }
+                  });
+              
+
+              
+
+              // This method is responsible for drawing the graph, returns the drawn network
+              function drawGraph() {
+                  var container = document.getElementById('mynetwork');
+
+                  
+
+                  // parsing and collecting nodes and edges from the python
+                  nodes = new vis.DataSet([{"color": "#8b5cf6", "font": {"color": "white"}, "id": "Desconocido...", "label": "Desconocido...", "shape": "dot", "size": 20, "title": ""}, {"color": "#10b981", "font": {"color": "white"}, "id": "Fuente Desconocida", "label": "Fuente Desconocida", "shape": "square", "size": 25}]);
+                  edges = new vis.DataSet([{"from": "Desconocido...", "to": "Fuente Desconocida", "width": 1}]);
+
+                  nodeColors = {};
+                  allNodes = nodes.get({ returnType: "Object" });
+                  for (nodeId in allNodes) {
+                    nodeColors[nodeId] = allNodes[nodeId].color;
+                  }
+                  allEdges = edges.get({ returnType: "Object" });
+                  // adding nodes and edges to the graph
+                  data = {nodes: nodes, edges: edges};
+
+                  var options = {
+    "configure": {
+        "enabled": false
+    },
+    "edges": {
+        "color": {
+            "inherit": true
+        },
+        "smooth": {
+            "enabled": true,
+            "type": "dynamic"
+        }
+    },
+    "interaction": {
+        "dragNodes": true,
+        "hideEdgesOnDrag": false,
+        "hideNodesOnDrag": false
+    },
+    "physics": {
+        "enabled": true,
+        "forceAtlas2Based": {
+            "avoidOverlap": 0,
+            "centralGravity": 0.01,
+            "damping": 0.4,
+            "gravitationalConstant": -50,
+            "springConstant": 0.08,
+            "springLength": 100
+        },
+        "solver": "forceAtlas2Based",
+        "stabilization": {
+            "enabled": true,
+            "fit": true,
+            "iterations": 1000,
+            "onlyDynamicEdges": false,
+            "updateInterval": 50
+        }
+    }
+};
+
+                  
+
+
+                  
+
+                  network = new vis.Network(container, data, options);
+
+                  
+
+                  
+                    network.on("selectNode", neighbourhoodHighlight);
+                  
+
+                  
+
+
+                  
+
+                  return network;
+
+              }
+              drawGraph();
+        </script>
+    </body>
+</html>

assets/styles.css

@@ -0,0 +1,899 @@
+/* LetXipu Beta SX - Custom Gradio Theme */
+/* Dark/Light mode support, Glassmorphism, Animations */
+
+/* ─── Google Fonts ─── */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500;600&display=swap');
+
+/* ─── Dark Theme (Default) ─── */
+:root, [data-theme="dark"] {
+    --bg: #0a0a0c;
+    --surface: #111827;
+    --surface-2: #1a1a2e;
+    --border: #374151;
+    --text: #ffffff;
+    --text-muted: #9ca3af;
+    --accent: #8b5cf6;
+    --accent-hover: #a78bfa;
+    --primary: #3b82f6;
+    --primary-hover: #60a5fa;
+    --success: #10b981;
+    --danger: #ef4444;
+    --warning: #f59e0b;
+    --input-bg: #1f2937;
+    --glass: rgba(10, 10, 12, 0.7);
+    --glass-border: rgba(255, 255, 255, 0.1);
+    --glass-results: rgba(17, 24, 39, 0.6);
+    --glass-results-border: rgba(255, 255, 255, 0.08);
+    --shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+    --shadow-lg: 0 12px 64px rgba(0, 0, 0, 0.7);
+    --section-header-bg: linear-gradient(135deg, rgba(139, 92, 246, 0.1), rgba(99, 102, 241, 0.05));
+    --section-header-border: rgba(139, 92, 246, 0.2);
+    --section-header-color: #a78bfa;
+    --banner-bg: linear-gradient(135deg, #0f0c29 0%, #302b63 50%, #24243e 100%);
+    --banner-text: white;
+    --tab-bg: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+    --tab-text: #b0b8c8;
+    --tab-hover-bg: rgba(255, 255, 255, 0.08);
+    --accordion-bg: rgba(17, 24, 39, 0.5);
+    --accordion-border: rgba(255, 255, 255, 0.08);
+    --prose-text: rgba(255, 255, 255, 0.85);
+    --prose-h2: #d1d5db;
+    --prose-h3: #e5e7eb;
+    --prose-em: #a78bfa;
+    --prose-details-bg: rgba(17, 24, 39, 0.3);
+    --prose-details-border: rgba(255, 255, 255, 0.05);
+    --radius: 12px;
+    --radius-lg: 20px;
+    --transition: 0.3s cubic-bezier(0.23, 1, 0.32, 1);
+}
+
+/* ─── Light Theme ─── */
+[data-theme="light"] {
+    --bg: #f8fafc;
+    --surface: #ffffff;
+    --surface-2: #f1f5f9;
+    --border: #e2e8f0;
+    --text: #0f172a;
+    --text-muted: #64748b;
+    --accent: #7c3aed;
+    --accent-hover: #6d28d9;
+    --primary: #2563eb;
+    --primary-hover: #1d4ed8;
+    --success: #059669;
+    --danger: #dc2626;
+    --warning: #d97706;
+    --input-bg: #f1f5f9;
+    --glass: rgba(255, 255, 255, 0.85);
+    --glass-border: rgba(0, 0, 0, 0.1);
+    --glass-results: rgba(255, 255, 255, 0.75);
+    --glass-results-border: rgba(0, 0, 0, 0.08);
+    --shadow: 0 4px 20px rgba(0, 0, 0, 0.08);
+    --shadow-lg: 0 8px 40px rgba(0, 0, 0, 0.12);
+    --section-header-bg: linear-gradient(135deg, rgba(124, 58, 237, 0.06), rgba(99, 102, 241, 0.03));
+    --section-header-border: rgba(124, 58, 237, 0.15);
+    --section-header-color: #7c3aed;
+    --banner-bg: linear-gradient(135deg, #e0e7ff 0%, #c7d2fe 50%, #ddd6fe 100%);
+    --banner-text: #1e1b4b;
+    --tab-bg: linear-gradient(135deg, #e0e7ff 0%, #c7d2fe 50%, #ddd6fe 100%);
+    --tab-text: #475569;
+    --tab-hover-bg: rgba(0, 0, 0, 0.05);
+    --accordion-bg: rgba(241, 245, 249, 0.8);
+    --accordion-border: rgba(0, 0, 0, 0.08);
+    --prose-text: #1e293b;
+    --prose-h2: #334155;
+    --prose-h3: #1e293b;
+    --prose-em: #7c3aed;
+    --prose-details-bg: rgba(241, 245, 249, 0.6);
+    --prose-details-border: rgba(0, 0, 0, 0.06);
+}
+
+/* ─── Global ─── */
+.gradio-container {
+    max-width: 1400px !important;
+    margin: auto !important;
+    background: var(--bg) !important;
+    color: var(--text) !important;
+    font-family: 'Inter', 'Segoe UI', system-ui, -apple-system, sans-serif !important;
+}
+
+/* ─── Header Banner ─── */
+.header-banner {
+    background: var(--banner-bg);
+    color: var(--banner-text);
+    padding: 1.5rem 2rem;
+    border-radius: 16px;
+    margin-bottom: 1rem;
+    position: relative;
+    overflow: hidden;
+    box-shadow: 0 8px 32px rgba(48, 43, 99, 0.3);
+}
+.header-banner::before {
+    content: '';
+    position: absolute;
+    top: -50%;
+    right: -20%;
+    width: 400px;
+    height: 400px;
+    background: radial-gradient(circle, rgba(139, 92, 246, 0.25) 0%, transparent 70%);
+    border-radius: 50%;
+    animation: float 6s ease-in-out infinite;
+}
+.header-banner h1 {
+    margin: 0 0 0.3rem 0 !important;
+    font-size: 1.8rem !important;
+    font-weight: 700 !important;
+    position: relative;
+    z-index: 1;
+    color: var(--banner-text) !important;
+}
+.header-banner p {
+    margin: 0 !important;
+    font-size: 0.9rem !important;
+    opacity: 0.85;
+    position: relative;
+    z-index: 1;
+    color: var(--banner-text) !important;
+}
+.header-badge {
+    display: inline-block;
+    background: rgba(255, 255, 255, 0.15);
+    backdrop-filter: blur(4px);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 20px;
+    padding: 0.2rem 0.7rem;
+    font-size: 0.75rem !important;
+    margin-top: 0.6rem;
+    position: relative;
+    z-index: 1;
+}
+
+/* ─── Status Banner ─── */
+.status-banner {
+    display: flex;
+    align-items: center;
+    gap: 0.6rem;
+    padding: 0.7rem 1.2rem;
+    border-radius: 10px;
+    margin-bottom: 1rem;
+    font-size: 0.85rem;
+    font-weight: 500;
+    backdrop-filter: blur(10px);
+}
+.status-connected {
+    background: linear-gradient(135deg, rgba(16, 185, 129, 0.1), rgba(16, 185, 129, 0.05));
+    border: 1px solid rgba(16, 185, 129, 0.3);
+    color: #10b981;
+}
+.status-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+.status-dot.connected {
+    background: #10b981;
+    box-shadow: 0 0 8px rgba(16, 185, 129, 0.4);
+    animation: pulse 2s infinite;
+}
+
+/* ─── Tabs ─── */
+.tab-nav {
+    background: var(--tab-bg) !important;
+    border-radius: 12px 12px 0 0 !important;
+    padding: 6px !important;
+    gap: 4px !important;
+}
+.tab-nav button {
+    color: var(--tab-text) !important;
+    font-weight: 500 !important;
+    font-size: 0.85rem !important;
+    border: none !important;
+    border-radius: 8px !important;
+    padding: 0.5rem 1rem !important;
+    transition: all 0.2s ease !important;
+    background: transparent !important;
+}
+.tab-nav button:hover {
+    color: var(--text) !important;
+    background: var(--tab-hover-bg) !important;
+}
+.tab-nav button.selected {
+    color: white !important;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    box-shadow: 0 2px 12px rgba(102, 126, 234, 0.4) !important;
+}
+
+/* ─── Progress Bar ─── */
+.progress-container {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 1rem 1.5rem;
+    margin-bottom: 1rem;
+}
+.progress-bar {
+    height: 8px;
+    background: var(--border);
+    border-radius: 4px;
+    overflow: hidden;
+    margin: 0.5rem 0;
+}
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, #667eea, #764ba2);
+    border-radius: 4px;
+    transition: width 0.5s ease;
+    box-shadow: 0 0 10px rgba(102, 126, 234, 0.3);
+}
+.progress-text {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+/* ─── Glassmorphic Cards ─── */
+.glass-card {
+    background: var(--glass);
+    backdrop-filter: blur(24px);
+    border: 1px solid var(--glass-border);
+    border-radius: var(--radius-lg);
+    padding: 1.25rem;
+    box-shadow: var(--shadow);
+    transition: all var(--transition);
+}
+.glass-card:hover {
+    border-color: var(--accent);
+    box-shadow: var(--shadow-lg), 0 0 20px rgba(139, 92, 246, 0.15);
+}
+.glass-card-focused {
+    border-color: var(--accent) !important;
+    box-shadow: var(--shadow-lg), 0 0 25px rgba(139, 92, 246, 0.25) !important;
+}
+
+/* ─── Section Header ─── */
+.section-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.6rem 1rem;
+    background: var(--section-header-bg);
+    border: 1px solid var(--section-header-border);
+    border-radius: 10px;
+    margin-bottom: 0.6rem;
+    font-weight: 600;
+    font-size: 0.85rem;
+    color: var(--section-header-color);
+}
+
+/* ─── Source Status Dots ─── */
+.source-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    margin-right: 4px;
+}
+.source-dot.online { background: #10b981; box-shadow: 0 0 6px rgba(16, 185, 129, 0.4); }
+.source-dot.offline { background: #ef4444; box-shadow: 0 0 6px rgba(239, 68, 68, 0.4); }
+.source-dot.checking { background: #f59e0b; animation: pulse 1s infinite; }
+
+.source-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 10px;
+    border-radius: 20px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+.source-online {
+    background: rgba(16, 185, 129, 0.1);
+    border: 1px solid rgba(16, 185, 129, 0.3);
+    color: #10b981;
+}
+.source-offline {
+    background: rgba(239, 68, 68, 0.1);
+    border: 1px solid rgba(239, 68, 68, 0.3);
+    color: #ef4444;
+}
+
+/* ─── Toggle Switch ─── */
+.toggle-switch {
+    position: relative;
+    width: 44px;
+    height: 24px;
+    background: var(--border);
+    border-radius: 12px;
+    cursor: pointer;
+    transition: background 0.3s ease;
+}
+.toggle-switch.active {
+    background: var(--accent);
+}
+.toggle-switch::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 20px;
+    height: 20px;
+    background: white;
+    border-radius: 50%;
+    transition: transform 0.3s ease;
+}
+.toggle-switch.active::after {
+    transform: translateX(20px);
+}
+
+/* ─── Result Tabs ─── */
+.result-tabs {
+    display: flex;
+    gap: 6px;
+    padding: 6px;
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 14px;
+    margin-bottom: 1rem;
+}
+.result-tab {
+    padding: 10px 16px;
+    border-radius: 10px;
+    border: none;
+    background: transparent;
+    color: var(--text-muted);
+    font-weight: 600;
+    font-size: 0.85rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+.result-tab:hover {
+    color: var(--text);
+    background: var(--tab-hover-bg);
+}
+.result-tab.active {
+    color: white;
+    background: var(--accent);
+    box-shadow: 0 4px 15px rgba(139, 92, 246, 0.35);
+}
+
+/* ─── Prompt Editor ─── */
+.prompt-editor,
+.prompt-editor textarea {
+    background: var(--input-bg) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: 10px !important;
+    padding: 1rem;
+    font-family: 'JetBrains Mono', 'Fira Code', monospace !important;
+    font-size: 0.8rem !important;
+    line-height: 1.5 !important;
+    resize: vertical;
+    min-height: 120px;
+    color: var(--text) !important;
+    transition: border-color 0.2s ease;
+}
+.prompt-editor:focus,
+.prompt-editor textarea:focus {
+    border-color: var(--accent) !important;
+    outline: none;
+}
+
+/* ─── Glass Input Wrapper ─── */
+.glass-input-wrapper {
+    background: var(--glass);
+    backdrop-filter: blur(24px);
+    border: 2px solid var(--glass-border);
+    border-radius: 20px;
+    padding: 14px 18px;
+    box-shadow: var(--shadow);
+    transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1);
+    margin-bottom: 1rem;
+}
+.glass-input-wrapper:focus-within {
+    border-color: rgba(139, 92, 246, 0.6);
+    box-shadow: var(--shadow-lg), 0 0 25px rgba(139, 92, 246, 0.15);
+}
+.glass-input-wrapper textarea,
+.glass-input-wrapper input[type="text"] {
+    background: transparent !important;
+    border: none !important;
+    padding: 8px 4px !important;
+    font-size: 14px !important;
+    font-family: 'Inter', system-ui, sans-serif !important;
+    color: var(--text) !important;
+}
+.glass-input-wrapper textarea:focus,
+.glass-input-wrapper input[type="text"]:focus {
+    box-shadow: none !important;
+    outline: none !important;
+}
+.glass-input-wrapper label {
+    color: var(--accent) !important;
+    font-weight: 600 !important;
+    font-size: 13px !important;
+}
+
+/* ─── Glassmorphic Results Wrapper ─── */
+.glass-results-wrapper {
+    background: var(--glass-results);
+    backdrop-filter: blur(16px);
+    border: 1px solid var(--glass-results-border);
+    border-radius: 16px;
+    padding: 1.25rem;
+    box-shadow: var(--shadow);
+}
+
+/* ─── Premium Execute Button ─── */
+.ejecutar-btn {
+    background: linear-gradient(135deg, #6366f1, #8b5cf6) !important;
+    color: white !important;
+    font-weight: 700 !important;
+    font-size: 15px !important;
+    border-radius: 14px !important;
+    padding: 14px 28px !important;
+    border: none !important;
+    box-shadow: 0 4px 20px rgba(99, 102, 241, 0.4), inset 0 1px 0 rgba(255,255,255,0.15) !important;
+    transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1) !important;
+    position: relative !important;
+    overflow: hidden !important;
+}
+.ejecutar-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 30px rgba(99, 102, 241, 0.5), inset 0 1px 0 rgba(255,255,255,0.2) !important;
+}
+.ejecutar-btn:active {
+    transform: translateY(0) !important;
+}
+.ejecutar-btn:disabled {
+    opacity: 0.5 !important;
+    transform: none !important;
+    box-shadow: none !important;
+}
+
+/* ─── Gradio Accordion Glass ─── */
+.gradio-accordion {
+    border: 1px solid var(--glass-border) !important;
+    border-radius: 12px !important;
+    overflow: hidden !important;
+    background: var(--glass) !important;
+    backdrop-filter: blur(12px) !important;
+}
+.gradio-accordion .label-wrap {
+    padding: 10px 16px !important;
+    font-weight: 600 !important;
+    color: var(--text) !important;
+}
+
+/* ─── Config Accordion ─── */
+.config-accordion {
+    background: var(--accordion-bg) !important;
+    border: 1px solid var(--accordion-border) !important;
+    border-radius: 12px !important;
+}
+
+/* ─── Gradio Blocks Glass Panels ─── */
+.gradio-group {
+    border: 1px solid var(--glass-border) !important;
+    border-radius: 14px !important;
+    background: var(--glass) !important;
+}
+
+/* ─── Scrollbar ─── */
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb {
+    background: var(--accent);
+    opacity: 0.3;
+    border-radius: 10px;
+}
+::-webkit-scrollbar-thumb:hover { opacity: 0.5; }
+
+/* ─── Pipeline Control Buttons ─── */
+.control-btn-pause button {
+    background: rgba(245, 158, 11, 0.1) !important;
+    border: 1px solid rgba(245, 158, 11, 0.4) !important;
+    color: #f59e0b !important;
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    transition: all 0.2s ease !important;
+}
+.control-btn-pause button:hover {
+    background: rgba(245, 158, 11, 0.2) !important;
+    box-shadow: 0 4px 12px rgba(245, 158, 11, 0.2) !important;
+}
+.control-btn-resume button {
+    background: rgba(16, 185, 129, 0.1) !important;
+    border: 1px solid rgba(16, 185, 129, 0.4) !important;
+    color: #10b981 !important;
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    transition: all 0.2s ease !important;
+}
+.control-btn-resume button:hover {
+    background: rgba(16, 185, 129, 0.2) !important;
+    box-shadow: 0 4px 12px rgba(16, 185, 129, 0.2) !important;
+}
+.control-btn-stop button {
+    background: rgba(239, 68, 68, 0.1) !important;
+    border: 1px solid rgba(239, 68, 68, 0.4) !important;
+    color: #ef4444 !important;
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    transition: all 0.2s ease !important;
+}
+.control-btn-stop button:hover {
+    background: rgba(239, 68, 68, 0.2) !important;
+    box-shadow: 0 4px 12px rgba(239, 68, 68, 0.2) !important;
+}
+
+/* ─── Paper Card ─── */
+.paper-card {
+    position: relative;
+    background: var(--glass);
+    backdrop-filter: blur(14px);
+    border: 1px solid var(--glass-border);
+    border-radius: 14px;
+    padding: 16px 20px 16px 24px;
+    margin-bottom: 10px;
+    transition: all 0.25s cubic-bezier(0.23, 1, 0.32, 1);
+    overflow: hidden;
+}
+.paper-card:hover {
+    border-color: rgba(139, 92, 246, 0.35);
+    box-shadow: 0 8px 32px rgba(139, 92, 246, 0.12), 0 2px 8px rgba(0,0,0,0.2);
+    transform: translateY(-2px);
+}
+
+/* Paper action buttons */
+.paper-actions {
+    display: flex;
+    gap: 6px;
+    flex-wrap: wrap;
+    align-items: center;
+    opacity: 0;
+    max-height: 0;
+    overflow: hidden;
+    transition: all 0.25s ease;
+}
+.paper-card:hover .paper-actions {
+    opacity: 1;
+    max-height: 50px;
+    margin-top: 6px;
+}
+.paper-action-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    padding: 4px 10px;
+    border-radius: 8px;
+    font-size: 11px;
+    font-weight: 600;
+    text-decoration: none;
+    border: 1px solid;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    white-space: nowrap;
+}
+.paper-action-btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 3px 10px rgba(0,0,0,0.15);
+    filter: brightness(1.15);
+}
+
+/* ─── Section Card ─── */
+.section-card {
+    background: var(--glass);
+    backdrop-filter: blur(14px);
+    border: 1px solid var(--glass-border);
+    border-radius: 14px;
+    margin-bottom: 10px;
+    overflow: hidden;
+    transition: all 0.25s cubic-bezier(0.23, 1, 0.32, 1);
+}
+.section-card:hover {
+    border-color: rgba(139, 92, 246, 0.3);
+    box-shadow: 0 4px 20px rgba(139, 92, 246, 0.08);
+}
+.section-card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 12px 16px;
+    cursor: pointer;
+    transition: background 0.2s ease;
+}
+.section-card-header:hover {
+    background: rgba(139, 92, 246, 0.04);
+}
+.section-card-body {
+    padding: 0 16px 16px;
+    border-top: 1px solid var(--glass-border);
+}
+
+/* ─── Stat Card Hover ─── */
+.stat-card {
+    background: var(--glass);
+    border: 1px solid var(--glass-border);
+    border-radius: 12px;
+    padding: 16px;
+    text-align: center;
+    min-width: 100px;
+    transition: all 0.25s cubic-bezier(0.23, 1, 0.32, 1);
+}
+.stat-card:hover {
+    transform: translateY(-3px);
+    border-color: rgba(139, 92, 246, 0.3);
+    box-shadow: 0 8px 24px rgba(139, 92, 246, 0.1);
+}
+
+/* ─── Theme Toggle Button ─── */
+.theme-toggle {
+    position: fixed;
+    top: 12px;
+    right: 12px;
+    z-index: 9999;
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #8b5cf6, #6366f1);
+    border: 2px solid rgba(255,255,255,0.2);
+    color: white;
+    font-size: 18px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 4px 15px rgba(139, 92, 246, 0.4);
+    transition: all 0.3s ease;
+}
+.theme-toggle:hover {
+    transform: scale(1.1);
+    box-shadow: 0 6px 20px rgba(139, 92, 246, 0.6);
+}
+
+/* ─── Animations ─── */
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+@keyframes float {
+    0%, 100% { transform: translateY(0); }
+    50% { transform: translateY(-12px); }
+}
+@keyframes glowPulse {
+    0%, 100% { box-shadow: 0 0 15px rgba(139, 92, 246, 0.15); }
+    50% { box-shadow: 0 0 30px rgba(139, 92, 246, 0.35); }
+}
+@keyframes slideIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+@keyframes shimmer {
+    0% { background-position: -200% center; }
+    100% { background-position: 200% center; }
+}
+@keyframes toastSlideIn {
+    from { transform: translateY(-10px); opacity: 0; }
+    to { transform: translateY(0); opacity: 1; }
+}
+
+/* ─── Footer ─── */
+.app-footer {
+    background: var(--banner-bg);
+    color: var(--text-muted);
+    padding: 1rem 2rem;
+    border-radius: 12px;
+    margin-top: 1.5rem;
+    font-size: 0.8rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+/* ─── Hide default Gradio footer ─── */
+footer { display: none !important; }
+
+/* ─── Report Typography (.prose) ─── */
+.prose {
+    font-family: 'Inter', system-ui, sans-serif !important;
+    font-size: 15px !important;
+    line-height: 1.65 !important;
+    color: var(--prose-text) !important;
+    max-width: 850px !important;
+    margin: 0 auto !important;
+    padding-bottom: 40px !important;
+}
+.prose h1 {
+    font-size: 1.4rem !important;
+    font-weight: 700 !important;
+    margin-top: 1.8rem !important;
+    margin-bottom: 0.8rem !important;
+    color: var(--accent) !important;
+}
+.prose h2 {
+    font-size: 1.25rem !important;
+    font-weight: 600 !important;
+    margin-top: 1.5rem !important;
+    margin-bottom: 0.6rem !important;
+    color: var(--prose-h2) !important;
+}
+.prose h3 {
+    font-size: 1.1rem !important;
+    font-weight: 600 !important;
+    margin-top: 1.2rem !important;
+    margin-bottom: 0.5rem !important;
+    color: var(--prose-h3) !important;
+}
+.prose p {
+    margin-bottom: 1rem !important;
+}
+.prose li {
+    margin-bottom: 0.4rem !important;
+}
+.prose em {
+    color: var(--prose-em) !important;
+    font-style: italic !important;
+}
+
+/* Style for details/summary collapsible headers */
+.prose details > summary {
+    list-style: none;
+    position: relative;
+    padding-left: 20px;
+    cursor: pointer;
+    transition: color 0.2s;
+}
+.prose details > summary::-webkit-details-marker {
+    display: none;
+}
+.prose details > summary::before {
+    content: "▶";
+    position: absolute;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    font-size: 0.7em;
+    color: var(--accent);
+    transition: transform 0.2s;
+}
+.prose details[open] > summary::before {
+    transform: translateY(-50%) rotate(90deg);
+}
+.prose details[open] > summary {
+    margin-bottom: 0.5rem;
+}
+.prose details {
+    margin-bottom: 0.5rem;
+    background: var(--prose-details-bg);
+    border: 1px solid var(--prose-details-border);
+    border-radius: 12px;
+    padding: 8px 16px;
+}
+
+/* ─── Responsive: Tablet ─── */
+@media (max-width: 1024px) {
+    .gradio-container {
+        max-width: 100% !important;
+        padding: 0 8px !important;
+    }
+    .gradio-row {
+        flex-direction: column !important;
+    }
+    .gradio-column {
+        max-width: 100% !important;
+        flex: 1 1 100% !important;
+    }
+    .header-banner {
+        padding: 1.2rem 1.5rem;
+    }
+}
+
+/* ─── Responsive: Mobile ─── */
+@media (max-width: 768px) {
+    .gradio-container {
+        padding: 0 4px !important;
+    }
+    .header-banner {
+        padding: 1rem;
+        border-radius: 12px;
+    }
+    .header-banner h1 {
+        font-size: 1.3rem !important;
+    }
+    .header-banner::before {
+        width: 200px;
+        height: 200px;
+    }
+    .app-footer {
+        flex-direction: column;
+        text-align: center;
+        gap: 0.5rem;
+        padding: 1rem;
+    }
+    .status-banner {
+        flex-wrap: wrap;
+    }
+
+    .paper-card {
+        padding: 12px 14px 12px 18px;
+        border-radius: 12px;
+    }
+    .paper-card:hover {
+        transform: none;
+    }
+    .paper-actions {
+        opacity: 1;
+        max-height: 50px;
+        margin-top: 6px;
+    }
+
+    .ejecutar-btn {
+        padding: 12px 20px !important;
+        font-size: 14px !important;
+        width: 100% !important;
+    }
+
+    .control-btn-pause button,
+    .control-btn-resume button,
+    .control-btn-stop button {
+        padding: 8px 12px !important;
+        font-size: 12px !important;
+    }
+
+    /* Stack tabs horizontally scrollable */
+    .gradio-tabs > .tab-nav {
+        overflow-x: auto;
+        flex-wrap: nowrap;
+    }
+    .gradio-tabs > .tab-nav button {
+        white-space: nowrap;
+        flex-shrink: 0;
+        font-size: 0.78rem !important;
+        padding: 0.4rem 0.75rem !important;
+    }
+
+    .glass-input-wrapper {
+        padding: 10px 14px;
+        border-radius: 14px;
+    }
+    .glass-results-wrapper {
+        padding: 0.75rem;
+        border-radius: 12px;
+    }
+    .section-header {
+        font-size: 0.8rem;
+        padding: 0.5rem 0.75rem;
+    }
+    .prose {
+        font-size: 14px !important;
+        padding-bottom: 20px !important;
+    }
+}
+
+/* ─── Responsive: Small Mobile ─── */
+@media (max-width: 480px) {
+    .header-banner h1 {
+        font-size: 1.1rem !important;
+    }
+    .paper-card {
+        padding: 10px 12px 10px 16px;
+        margin-bottom: 8px;
+    }
+    .ejecutar-btn {
+        padding: 10px 16px !important;
+        font-size: 13px !important;
+    }
+    .control-btn-pause, .control-btn-resume, .control-btn-stop {
+        flex: 1 !important;
+    }
+    .theme-toggle {
+        width: 36px;
+        height: 36px;
+        font-size: 16px;
+        top: 8px;
+        right: 8px;
+    }
+}

backend/__init__.py

@@ -0,0 +1 @@
+"""LetXipu Backend - AI-powered research synthesis pipeline."""

backend/database/models.py

@@ -0,0 +1,58 @@
+import os
+from datetime import datetime
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, Text, Boolean, ForeignKey
+from sqlalchemy.orm import declarative_base, sessionmaker, relationship
+
+# Configuración de SQLite
+DB_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "letxipu.db")
+engine = create_engine(f"sqlite:///{DB_PATH}", echo=False)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    role = Column(String, default="user")
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    projects = relationship("Project", back_populates="owner", cascade="all, delete-orphan")
+
+
+class Project(Base):
+    __tablename__ = "projects"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, nullable=False)
+    description = Column(Text, nullable=True)
+    owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    owner = relationship("User", back_populates="projects")
+    jobs = relationship("ResearchJob", back_populates="project", cascade="all, delete-orphan")
+
+
+class ResearchJob(Base):
+    __tablename__ = "research_jobs"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id"), nullable=False)
+    query = Column(Text, nullable=False)
+    status = Column(String, default="pending")  # pending, running, completed, error
+    progress_pct = Column(Integer, default=0)
+    report_md = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    completed_at = Column(DateTime, nullable=True)
+    
+    project = relationship("Project", back_populates="jobs")
+
+# Crear las tablas en la base de datos si no existen
+def init_db():
+    Base.metadata.create_all(bind=engine)
+
+if __name__ == "__main__":
+    init_db()
+    print(f"Base de datos inicializada en: {DB_PATH}")

backend/guardrails.py

@@ -0,0 +1,33 @@
+import re
+
+
+XSS_PATTERNS = [r"<script", r"javascript:", r"on\w+\s*=", r"<iframe", r"<object", r"<embed"]
+
+PROFANITY_WORDS = [
+    "fuck", "shit", "damn", "hell", "ass", "bitch", "crap", "piss",
+    "puta", "mierda", "pendejo", "cabrón", "estúpido", "idiota",
+    "marica", "gonorrea", "hijueputa", "malparido", "chucha",
+]
+
+
+class Guardrails:
+    def __init__(self, max_length: int = 500):
+        self.max_length = max_length
+
+    def validate(self, query: str) -> tuple[bool, str]:
+        if not query or not query.strip():
+            return False, "La consulta está vacía"
+
+        if len(query) > self.max_length:
+            return False, f"La consulta excede {self.max_length} caracteres (tiene {len(query)})"
+
+        query_lower = query.lower()
+        for pattern in XSS_PATTERNS:
+            if re.search(pattern, query_lower):
+                return False, "Se detectó contenido potencialmente inseguro (XSS)"
+
+        for word in PROFANITY_WORDS:
+            if word in query_lower:
+                return False, "Se detectó lenguaje inapropiado"
+
+        return True, ""

backend/metadata_recovery.py

@@ -0,0 +1,211 @@
+"""
+Metadata Recovery Engine - Fiel al app original Next.js
+Implementa la cascada de 7 pasos de recuperación de metadatos
+"""
+
+import re
+import httpx
+import asyncio
+from typing import List, Dict, Any, Optional
+
+RESCUE_SEARCH_RESULT_LIMIT = 10
+
+
+def compute_completeness_score(paper: dict) -> int:
+    """Score paper completeness from 0-100."""
+    score = 0
+    abstract = paper.get("abstract", "") or ""
+    if len(abstract) > 50 and "..." not in abstract[-10:]:
+        score += 30
+    elif len(abstract) > 20:
+        score += 10
+    if paper.get("doi"):
+        score += 15
+    university = paper.get("university", "") or ""
+    generic_unis = ["Universidad Peruana", "Universidad", "Universidad Nacional"]
+    if university and not any(g in university for g in generic_unis):
+        score += 15
+    if paper.get("year") and paper["year"] != 0:
+        score += 10
+    authors = paper.get("authors", [])
+    if authors and "Autor Desconocido" not in str(authors):
+        score += 15
+    pdf_url = paper.get("pdfUrl", "") or ""
+    if pdf_url and not pdf_url.startswith("http://hdl.handle.net"):
+        score += 15
+    return min(score, 100)
+
+
+def is_abstract_truncated(text: str) -> bool:
+    """Detect truncated abstracts."""
+    if not text:
+        return True
+    return bool(re.search(r'\.{3}\s*(Descripci[oó]n\s+completa\s*)?$', text)) or text.endswith('\u2026')
+
+
+def is_generic_university(name: str) -> bool:
+    """Detect generic university names."""
+    if not name:
+        return True
+    generics = ["Universidad Peruana", "Universidad", "Universidad Nacional", "Instituto"]
+    return any(g in name for g in generics)
+
+
+class MetadataRecoveryEngine:
+    """7-step metadata recovery cascade."""
+    
+    def __init__(self, api_key: str = ""):
+        self.api_key = api_key
+        self.stats = {
+            "totalAttempted": 0, "recoveredAbstract": 0, "recoveredYear": 0,
+            "recoveredDoi": 0, "recoveredPdf": 0, "recoveredUniversity": 0,
+            "recoveredAuthors": 0, "fullyFailed": 0, "skipped": 0,
+        }
+    
+    async def recover_batch(self, papers: List[dict], min_score: int = 60, batch_size: int = 10) -> dict:
+        """Recover metadata for a batch of papers."""
+        candidates = []
+        for p in papers:
+            score = compute_completeness_score(p)
+            if score < min_score:
+                p["completenessScore"] = score
+                candidates.append(p)
+            else:
+                self.stats["skipped"] += 1
+        
+        for i in range(0, len(candidates), batch_size):
+            batch = candidates[i:i+batch_size]
+            await asyncio.gather(*[self._recover_one(p) for p in batch])
+        
+        return {"papers": papers, "stats": self.stats}
+    
+    async def _recover_one(self, paper: dict):
+        """7-step recovery cascade for a single paper."""
+        self.stats["totalAttempted"] += 1
+        
+        try:
+            if not paper.get("abstract") or len(paper.get("abstract", "")) < 50:
+                await self._step_openalex(paper)
+            
+            if not paper.get("abstract") or len(paper.get("abstract", "")) < 50:
+                await self._step_pubmed(paper)
+            
+            if paper.get("doi") and (not paper.get("abstract") or len(paper.get("abstract", "")) < 50):
+                await self._step_crossref(paper)
+            
+            if paper.get("doi") and (not paper.get("abstract") or len(paper.get("abstract", "")) < 50):
+                await self._step_semantic_scholar(paper)
+            
+            paper["completenessScore"] = compute_completeness_score(paper)
+            
+            if paper.get("abstract") and len(paper.get("abstract", "")) > 50:
+                self.stats["recoveredAbstract"] += 1
+            if paper.get("year"):
+                self.stats["recoveredYear"] += 1
+            if paper.get("doi"):
+                self.stats["recoveredDoi"] += 1
+            if paper.get("pdfUrl"):
+                self.stats["recoveredPdf"] += 1
+            if paper.get("university") and not is_generic_university(paper.get("university", "")):
+                self.stats["recoveredUniversity"] += 1
+            if paper.get("authors") and "Autor Desconocido" not in str(paper.get("authors", [])):
+                self.stats["recoveredAuthors"] += 1
+        except Exception:
+            self.stats["fullyFailed"] += 1
+    
+    async def _step_openalex(self, paper: dict):
+        """Step 4: Search OpenAlex by title or DOI."""
+        try:
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                if paper.get("doi"):
+                    url = f"https://api.openalex.org/works/https://doi.org/{paper['doi']}"
+                    r = await client.get(url)
+                elif paper.get("title"):
+                    url = f"https://api.openalex.org/works?filter=title.search:{paper['title'][:100]}&per-page=1"
+                    r = await client.get(url)
+                else:
+                    return
+                
+                if r.status_code == 200:
+                    data = r.json()
+                    work = data if "title" in data else (data.get("results", [{}])[0] if data.get("results") else {})
+                    
+                    if work:
+                        if not paper.get("abstract") and work.get("abstract_inverted_index"):
+                            paper["abstract"] = self._decode_inverted_index(work["abstract_inverted_index"])
+                        if not paper.get("year") and work.get("publication_year"):
+                            paper["year"] = work["publication_year"]
+                        if not paper.get("doi") and work.get("ids", {}).get("doi"):
+                            paper["doi"] = work["ids"]["doi"].replace("https://doi.org/", "")
+                        if not paper.get("pdfUrl") and work.get("open_access", {}).get("oa_url"):
+                            paper["pdfUrl"] = work["open_access"]["oa_url"]
+                        if not paper.get("university") and work.get("authorships"):
+                            for a in work["authorships"]:
+                                for inst in a.get("institutions", []):
+                                    if inst.get("display_name"):
+                                        paper["university"] = inst["display_name"]
+                                        break
+                        if not paper.get("authors") and work.get("authorships"):
+                            paper["authors"] = [a.get("author", {}).get("display_name", "") for a in work["authorships"] if a.get("author", {}).get("display_name")]
+        except:
+            pass
+    
+    async def _step_pubmed(self, paper: dict):
+        """Step 5: Search PubMed by PMID."""
+        try:
+            pmid = self._extract_pmid(paper)
+            if not pmid:
+                return
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                url = f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id={pmid}&rettype=abstract&retmode=text"
+                r = await client.get(url)
+                if r.status_code == 200 and len(r.text) > 50:
+                    paper["abstract"] = r.text[:50000]
+        except:
+            pass
+    
+    async def _step_crossref(self, paper: dict):
+        """Step 6: Search Crossref by DOI for abstract."""
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                url = f"https://api.crossref.org/works/{paper['doi']}"
+                r = await client.get(url, headers={"User-Agent": "LetXipuResearch/1.0"})
+                if r.status_code == 200:
+                    item = r.json().get("message", {})
+                    if item.get("abstract") and len(item["abstract"]) > len(paper.get("abstract", "")):
+                        paper["abstract"] = re.sub(r'<[^>]+>', '', item["abstract"])[:50000]
+        except:
+            pass
+    
+    async def _step_semantic_scholar(self, paper: dict):
+        """Step 7a: Search Semantic Scholar by DOI."""
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{paper['doi']}?fields=title,abstract,year,authors,openAccessPdf"
+                headers = {}
+                if self.api_key:
+                    headers["x-api-key"] = self.api_key
+                r = await client.get(url, headers=headers)
+                if r.status_code == 200:
+                    ss = r.json()
+                    if ss.get("abstract") and len(ss["abstract"]) > len(paper.get("abstract", "")):
+                        paper["abstract"] = ss["abstract"][:50000]
+                    if ss.get("openAccessPdf", {}).get("url") and not paper.get("pdfUrl"):
+                        paper["pdfUrl"] = ss["openAccessPdf"]["url"]
+        except:
+            pass
+    
+    def _extract_pmid(self, paper: dict) -> Optional[str]:
+        """Extract PubMed ID from paper."""
+        url = paper.get("url", "") or paper.get("handleUrl", "") or ""
+        match = re.search(r'(\d{6,})', url)
+        return match.group(1) if match else None
+    
+    def _decode_inverted_index(self, inverted_index: dict) -> str:
+        """Decode OpenAlex inverted index to text."""
+        word_positions = []
+        for word, positions in inverted_index.items():
+            for pos in positions:
+                word_positions.append((pos, word))
+        word_positions.sort()
+        return " ".join([w for _, w in word_positions])

backend/persistence.py

@@ -0,0 +1,56 @@
+import json
+import os
+from typing import Dict, Any, Optional
+import datetime
+
+
+CONFIG_DIR = ".letxipu"
+CONFIG_FILE = "search-config.json"
+PRESETS_FILE = "presets.json"
+
+
+class PersistenceManager:
+    def __init__(self, project_path: str = "."):
+        self.config_dir = os.path.join(project_path, CONFIG_DIR)
+        self.config_file = os.path.join(self.config_dir, CONFIG_FILE)
+        self.presets_file = os.path.join(self.config_dir, PRESETS_FILE)
+        os.makedirs(self.config_dir, exist_ok=True)
+
+    def save_config(self, config: Dict[str, Any]):
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+
+    def load_config(self) -> Dict[str, Any]:
+        if os.path.exists(self.config_file):
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return {}
+
+    def save_preset(self, name: str, config: Dict[str, Any]):
+        presets = self.load_presets()
+        presets[name] = {
+            "config": config,
+            "timestamp": datetime.datetime.now().isoformat(),
+        }
+        with open(self.presets_file, "w", encoding="utf-8") as f:
+            json.dump(presets, f, indent=2, ensure_ascii=False)
+
+    def load_presets(self) -> Dict[str, Any]:
+        if os.path.exists(self.presets_file):
+            with open(self.presets_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return {}
+
+    def load_preset(self, name: str) -> Optional[Dict[str, Any]]:
+        presets = self.load_presets()
+        return presets.get(name, {}).get("config")
+
+    def delete_preset(self, name: str):
+        presets = self.load_presets()
+        if name in presets:
+            del presets[name]
+            with open(self.presets_file, "w", encoding="utf-8") as f:
+                json.dump(presets, f, indent=2, ensure_ascii=False)
+
+    def list_presets(self) -> list:
+        return list(self.load_presets().keys())

backend/pipeline.py

@@ -0,0 +1,1050 @@
+"""
+Complete Research Pipeline - Fiel al app original Next.js
+Implementa: Query Optimizer, Iterations, Planning Context,
+Adaptive Tier 2, Gap Detection, Rescue Search, Deduplicación persistente,
+Infinite Output, Hierarchical Synthesis, GRADE Classification,
+Year/University Filtering, Source Health Check, Retry on LLM calls
+Como async generator para streaming en tiempo real con Gradio
+"""
+
+import json
+import logging
+import time
+import asyncio
+import re
+from typing import List, Dict, Any, Optional, Set, AsyncGenerator
+from backend.synthesis import SynthesisEngine, PROVIDERS, classify_grade, grade_label
+from backend.tools.search_engine import search
+from backend.prompts.profiles import AGENT_PROFILES
+from backend.utils import (
+    robust_json_parse,
+    with_retry,
+    clean_agent_content,
+    strip_latex,
+    is_plan_weak,
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(name)s] %(message)s')
+logger = logging.getLogger("pipeline")
+
+MIN_SEARCH_DOCS_FOR_TIER2 = 5
+RESCUE_SEARCH_RESULT_LIMIT = 10
+PLANNING_CONTEXT_DOCS_LIMIT = 5
+INTER_ITERATION_DELAY = 1.5
+MAX_SYNTHESIS_DOCS = 150
+CONTINUATION_MAX_TOKENS = 4000
+
+
+async def optimize_query(engine: SynthesisEngine, query: str, profile: str = "general") -> dict:
+    """Phase 0: AI generates optimized queries in 3 languages (EN, ES, PT)."""
+    prompt = f"""You are an Academic Search Query Optimizer. Generate TWO versions of this query.
+
+ORIGINAL QUERY: "{query}"
+
+RULES:
+1. "local" (Spanish): Keep in Spanish, use natural keywords, max 15 words
+2. "international" (English): MUST be in ENGLISH with Boolean operators. Max 10 scientific keywords.
+
+CRITICAL: The "international" field MUST be in ENGLISH. Use scientific terminology.
+Example: "optimización de producción de ácido indolacético" → "indoleacetic acid production optimization bacteria"
+
+RESPOND ONLY IN JSON:
+{{"local": "...", "international": "..."}}"""
+
+    system = "You are an academic search query optimizer. Generate queries in Spanish and English."
+
+    response = await with_retry(
+        lambda: engine._call_llm(system, prompt, role="search"),
+        retries=1,
+        delay=1.0,
+    )
+
+    result = robust_json_parse(response)
+    local_query = result.get("local", query) if result else query
+    international_query = result.get("international", query) if result else query
+
+    spanish_indicators = [
+        " de ", " del ", " la ", " el ", " los ", " las ", " en ", " con ",
+        " para ", " por ", " una ", " un ", " que ", " como ",
+    ]
+    es_count = sum(1 for ind in spanish_indicators if ind in international_query.lower())
+
+    if es_count >= 2:
+        translate_prompt = f"""Translate this Spanish academic query to English. Return ONLY the English translation, nothing else.
+Spanish: "{international_query}"
+English:"""
+        try:
+            translated = await with_retry(
+                lambda: engine._call_llm(
+                    "You are a strict academic translator. Return ONLY the translation.",
+                    translate_prompt,
+                    temperature=0.0,
+                    role="translation",
+                ),
+                retries=1,
+                delay=1.0,
+            )
+            translated = translated.strip().strip('"').strip("'").strip(".")
+            if translated and len(translated) > 3:
+                international_query = translated
+        except Exception:
+            pass
+
+    return {"local": local_query, "international": international_query}
+
+
+def build_planning_context(all_docs: list, query: str, iteration: int) -> str:
+    if iteration == 0:
+        return ""
+    prev_titles = [d.get("title", "") for d in all_docs[-PLANNING_CONTEXT_DOCS_LIMIT:]]
+    return (
+        f"PREVIOUS FINDINGS: We have already found {len(all_docs)} documents.\n"
+        f'Some recent titles: "{", ".join(prev_titles)}".\n'
+        "Your task is finding MISSING or COMPLEMENTARY information.\n"
+        "DO NOT repeat the same queries."
+    )
+
+
+def clean_query(q: str) -> str:
+    q = re.sub(r'\b(AND|OR|NOT)\b', ' ', q, flags=re.IGNORECASE)
+    accents = {
+        'á': 'a', 'é': 'e', 'í': 'i', 'ó': 'o', 'ú': 'u', 'ñ': 'n',
+        'Á': 'A', 'É': 'E', 'Í': 'I', 'Ó': 'O', 'Ú': 'U', 'Ñ': 'N',
+    }
+    q = re.sub(
+        r'[áéíóúñÁÉÍÓÚÑ]',
+        lambda m: accents.get(m.group(), m.group()),
+        q,
+    )
+    return q.strip()
+
+
+def filter_by_year(docs: list, year_start: Optional[int], year_end: Optional[int]) -> list:
+    """Filter documents by year range. Keeps docs without a year."""
+    if not year_start and not year_end:
+        return docs
+    filtered = []
+    for doc in docs:
+        year = doc.get("year")
+        if year is None:
+            filtered.append(doc)
+            continue
+        try:
+            year_int = int(year)
+        except (ValueError, TypeError):
+            filtered.append(doc)
+            continue
+        if year_start and year_int < year_start:
+            continue
+        if year_end and year_int > year_end:
+            continue
+        filtered.append(doc)
+    return filtered
+
+
+def filter_by_university(docs: list, university: str) -> list:
+    """Filter documents that match a university/institution keyword."""
+    if not university:
+        return docs
+    kw = university.lower()
+    return [
+        doc
+        for doc in docs
+        if kw in (doc.get("affiliation") or "").lower()
+        or kw in (doc.get("institution") or "").lower()
+        or kw in ", ".join(doc.get("authors", [])).lower()
+    ]
+
+
+async def check_source_health(sources: list) -> dict:
+    """Quick health check on search sources before running full search."""
+    status = {}
+    for source in sources:
+        if source == "all":
+            status["all"] = True
+            continue
+        try:
+            result = await search("test", sources=[source], max_results=1)
+            status[source] = bool(result.get("results"))
+        except Exception:
+            status[source] = False
+    return status
+
+
+class ResearchPipeline:
+    def __init__(
+        self,
+        provider: str = "mistral",
+        search_model: str = None,
+        synthesis_model: str = None,
+        translation_model: str = None,
+        api_key: str = None,
+    ):
+        self.engine = SynthesisEngine(
+            provider=provider,
+            model=synthesis_model,
+            api_key=api_key,
+            search_model=search_model,
+            translation_model=translation_model,
+        )
+        self.seen_titles: Set[str] = set()
+        self.seen_dois: Set[str] = set()
+        self.all_docs: List[dict] = []
+        # ─── Pipeline Control Flags ───
+        self._stopped = False
+        self._paused = False
+
+    def stop(self):
+        """Signal the pipeline to stop after the current phase."""
+        self._stopped = True
+        self._paused = False
+        logger.info("Pipeline STOP requested")
+
+    def pause(self):
+        """Signal the pipeline to pause after the current phase."""
+        self._paused = True
+        logger.info("Pipeline PAUSE requested")
+
+    def resume(self):
+        """Resume a paused pipeline."""
+        self._paused = False
+        logger.info("Pipeline RESUME requested")
+
+    @property
+    def is_stopped(self):
+        return self._stopped
+
+    @property
+    def is_paused(self):
+        return self._paused
+
+    async def _checkpoint(self):
+        """Check control flags between phases. Raises StopAsyncIteration if stopped."""
+        if self._stopped:
+            raise StopAsyncIteration("Pipeline detenido por el usuario")
+        while self._paused:
+            await asyncio.sleep(0.5)
+            if self._stopped:
+                raise StopAsyncIteration("Pipeline detenido por el usuario")
+
+    def _track_doc(self, doc: dict) -> bool:
+        title = (doc.get("title") or "").lower().replace(" ", "")
+        title_norm = re.sub(r'[^a-z0-9]', '', title)
+        doi = (doc.get("doi") or "").lower().strip()
+        if doi.startswith("https://doi.org/"):
+            doi = doi[16:]
+        if title_norm not in self.seen_titles and (not doi or doi not in self.seen_dois):
+            self.seen_titles.add(title_norm)
+            if doi:
+                self.seen_dois.add(doi)
+            self.all_docs.append(doc)
+            return True
+        return False
+
+    async def run_tier(
+        self, eng_query: str, sources: list, max_docs: int = 50,
+        year_start: Optional[int] = None, year_end: Optional[int] = None,
+        university: str = None,
+    ) -> List[dict]:
+        result = await search(eng_query, sources=sources, max_results=max_docs)
+        new_docs = []
+        for doc in result.get("results", []):
+            if self._track_doc(doc):
+                new_docs.append(doc)
+        if year_start or year_end:
+            new_docs = filter_by_year(new_docs, year_start, year_end)
+        if university:
+            new_docs = filter_by_university(new_docs, university)
+        return new_docs
+
+    async def run_rescue_search(self, missing_aspects: list, sources: list) -> List[dict]:
+        rescue_docs = []
+        for aspect in missing_aspects[:3]:
+            for q in [f"{aspect} research study", f"{aspect} investigación estudio"]:
+                try:
+                    result = await with_retry(
+                        lambda q=q: search(q, sources=sources, max_results=RESCUE_SEARCH_RESULT_LIMIT),
+                        retries=1,
+                        delay=1.0,
+                    )
+                    for doc in result.get("results", []):
+                        if self._track_doc(doc):
+                            rescue_docs.append(doc)
+                except Exception:
+                    pass
+        return rescue_docs
+
+    def _build_docs_df(self):
+        import pandas as pd
+
+        rows = []
+        for d in self.all_docs:
+            autores = d.get("authors", [])
+            if isinstance(autores, list):
+                autores = ", ".join(autores)
+            grade_level = d.get("grade_level", "")
+            grade_lbl = d.get("evidenceLevel") or d.get("grade_label", "")
+            rows.append({
+                "Título": d.get("title") or "N/A",
+                "Autores": autores or "N/A",
+                "Año": d.get("year", "N/A"),
+                "DOI": d.get("doi", ""),
+                "Fuente": d.get("source", "N/A"),
+                "GRADE": grade_lbl or grade_level or "N/A",
+                "PDF URL": d.get("pdfUrl", ""),
+            })
+        cols = ["Título", "Autores", "Año", "DOI", "Fuente", "GRADE", "PDF URL"]
+        return pd.DataFrame(rows) if rows else pd.DataFrame(columns=cols)
+
+    def _append_section_with_continuation(
+        self,
+        section_content: str,
+        section_name: str,
+        full_report_parts: list,
+    ) -> str:
+        """Strip and clean section content before appending."""
+        cleaned = clean_agent_content(section_content)
+        cleaned = strip_latex(cleaned)
+        full_report_parts.append(f"### {section_name}\n\n{cleaned}\n\n")
+        return cleaned
+
+    async def _write_section_with_continuation(
+        self,
+        section_name: str,
+        section_prompt: str,
+        section_context: str,
+        geo_context: str = "Automático",
+        infinite_output: bool = False,
+        max_continuation_passes: int = 2,
+    ) -> str:
+        """Write a section, optionally continuing for long content."""
+        content = await with_retry(
+            lambda: self.engine.write_section(section_name, section_prompt, section_context, geo_context),
+            retries=1,
+            delay=1.0,
+        )
+        content = clean_agent_content(content)
+
+        if not infinite_output or max_continuation_passes <= 0:
+            return content
+
+        for _ in range(max_continuation_passes):
+            if len(content) < 2000:
+                break
+            continue_prompt = (
+                f"Continue writing the section '{section_name}'. "
+                "Add more depth, examples, and citations. "
+                "Do NOT repeat what is already written."
+            )
+            try:
+                continuation = await with_retry(
+                    lambda: self.engine.write_section(
+                        section_name, continue_prompt, content + "\n\n" + section_context[:2000], geo_context
+                    ),
+                    retries=1,
+                    delay=1.0,
+                )
+                continuation = clean_agent_content(continuation)
+                if continuation and len(continuation) > 100:
+                    content += "\n\n" + continuation
+                else:
+                    break
+            except Exception:
+                break
+
+        return content
+
+    async def _execute_grade_classification(self, mode: str = "keywords") -> None:
+        """Enrich all docs with GRADE evidence levels using the selected algorithm."""
+        self.all_docs = await self.engine.classify_documents(self.all_docs, mode=mode)
+        self.all_docs = self.engine.sort_by_evidence(self.all_docs)
+
+    async def _retrieve_full_text(self) -> None:
+        """Download PDFs for top N docs to get real text for synthesis using native PyMuPDF."""
+        from backend.tools.pdf_tools import resolve_pdf, download_pdf, read_pdf
+
+        docs_with_pdf = [d for d in self.all_docs if d.get("pdfUrl") or d.get("doi")][:10]
+
+        for doc in docs_with_pdf:
+            try:
+                identifier = doc.get("doi") or doc.get("pdfUrl") or ""
+                if not identifier:
+                    continue
+
+                result = await resolve_pdf(identifier)
+                pdf_url = result.get("pdfUrl", "")
+
+                if pdf_url:
+                    dl_res = await download_pdf(pdf_url)
+                    if dl_res.get("success"):
+                        read_res = await read_pdf(dl_res["path"])
+                        if read_res.get("success"):
+                            doc["fullText"] = read_res["text"][:50000]
+            except Exception as e:
+                logger.warning(f"Failed to retrieve full text: {e}")
+
+    async def run(
+        self,
+        query: str,
+        sources: list = None,
+        profile: str = "general",
+        iterations: int = 1,
+        depth: int = 3,
+        include_validation: bool = True,
+        docs_text: str = None,
+        enable_dme: bool = True,
+        synthesis_strategy: str = "auto",
+        infinite_output: bool = False,
+        max_continuation_passes: int = 2,
+        year_start: Optional[int] = None,
+        year_end: Optional[int] = None,
+        university: str = None,
+        skip_gap_detection: bool = False,
+        grade_mode: str = "original",
+        geo_context: str = "Automático",
+    ) -> AsyncGenerator[tuple[str, Any], None]:
+        """Async generator that yields (report_text, docs_df) pairs for real-time Gradio streaming."""
+        import pandas as pd
+
+        if not sources:
+            sources = ["all"]
+
+        report = []
+        report.append(f"<div style='font-family: monospace; background: rgba(0,0,0,0.3); padding: 10px; border-radius: 8px; border: 1px solid #374151; font-size: 13px; color: #a78bfa;'>\n")
+        report.append(f"▶ <b>Research Pipeline</b><br>")
+        report.append(f"▶ <b>Consulta:</b> {query.strip()}<br><br>")
+
+        def get_report_md():
+            return "\n".join(report)
+
+        # ─── PHASE -1: Source Health Check ───
+        report.append("▶ <b>Verificación de Fuentes</b><br>")
+        yield get_report_md(), pd.DataFrame()
+
+        health = await check_source_health(sources)
+        for src, ok in health.items():
+            status_icon = "✅" if ok else "❌"
+            report.append(f"  {status_icon} {src}")
+        report.append("<br>")
+        yield get_report_md(), pd.DataFrame()
+
+        # ─── PHASE 0: Query Optimizer ───
+        await self._checkpoint()
+        report.append("▶ <b>Fase 0: Optimización de Queries</b><br>")
+        yield get_report_md(), pd.DataFrame()
+
+        optimized = await optimize_query(self.engine, query, profile)
+        eng_query = optimized.get("international", query)
+        esp_query = optimized.get("local", query)
+
+        report.append(f"  └ Query EN: <code>{eng_query[:80]}</code><br>")
+        report.append(f"  └ Query ES: <code>{esp_query[:80]}</code><br><br>")
+        yield get_report_md(), pd.DataFrame()
+
+        # ─── SYNTHESIS ONLY MODE ───
+        if iterations == 0 and docs_text:
+            report.append("▶ <b>Modo Síntesis (sin búsqueda)</b><br>")
+            yield get_report_md(), pd.DataFrame()
+
+            docs_lines = [l.strip() for l in docs_text.strip().split("\n") if l.strip()]
+            docs_context = "\n".join([f"[{i+1}] {l}" for i, l in enumerate(docs_lines[:50])])
+
+            master_plan = await with_retry(
+                lambda: self.engine.generate_master_plan(
+                    query=query, docs_context=docs_context, profile=profile, geo_context=geo_context
+                ),
+                retries=1,
+                delay=1.0,
+            )
+            plan_items = master_plan.get("plan", [])
+
+            if is_plan_weak(master_plan):
+                report.append("  ⚠ Plan débil detectado, reintentando...<br>")
+                master_plan = await with_retry(
+                    lambda: self.engine.generate_master_plan(
+                        query=query, docs_context=docs_context, profile=profile,
+                    ),
+                    retries=1,
+                    delay=2.0,
+                )
+                plan_items = master_plan.get("plan", [])
+
+            report.append(f"  └ Plan: {len(plan_items)} secciones<br><br>")
+            yield get_report_md(), pd.DataFrame()
+
+            full_report_parts = [f"## Resumen Ejecutivo\n\n{master_plan.get('summary', 'N/A')}\n\n"]
+
+            for i, item in enumerate(plan_items):
+                section_name = item.get("section", f"Sección {i+1}")
+                section_prompt = item.get("prompt", "Genera contenido detallado.")
+                relevant_indices = item.get("relevant_indices", [])
+                section_docs = [docs_lines[idx - 1] for idx in relevant_indices if 1 <= idx <= len(docs_lines)]
+                section_context = "\n".join(section_docs) if section_docs else docs_context[:3000]
+
+                report.append(f"▶ <b>Redactando:</b> {section_name}<br>")
+                yield get_report_md(), pd.DataFrame()
+
+                section_content = await self._write_section_with_continuation(
+                    section_name,
+                    section_prompt,
+                    section_context,
+                    geo_context=geo_context,
+                    infinite_output=infinite_output,
+                    max_continuation_passes=max_continuation_passes,
+                )
+
+                if include_validation:
+                    try:
+                        validation = await with_retry(
+                            lambda: self.engine.validate_citations(
+                                docs_context[:3000], section_content[:3000],
+                            ),
+                            retries=1,
+                            delay=1.0,
+                        )
+                        if not validation.get("is_valid", True):
+                            corrections = validation.get("corrections", [])
+                            if corrections:
+                                findings = "\n".join(
+                                    [f"- {c.get('explanation', '')}" for c in corrections]
+                                )
+                                section_content = await with_retry(
+                                    lambda: self.engine.refine_section(
+                                        section_content[:3000], findings,
+                                    ),
+                                    retries=1,
+                                    delay=1.0,
+                                )
+                    except Exception:
+                        pass
+
+                self._append_section_with_continuation(
+                    section_content, section_name, full_report_parts,
+                )
+                report.append(f"  ✔ {section_name}<br>")
+                yield get_report_md(), pd.DataFrame()
+
+            full_report = "".join(full_report_parts)
+            yield full_report, pd.DataFrame()
+            return
+
+        # ─── PHASE 1: Iterative Search Loop ───
+        await self._checkpoint()
+        for i in range(iterations):
+            report.append(f"<br>▶ <b>Ronda {i+1}/{iterations} ↻</b><br>")
+            yield get_report_md(), pd.DataFrame()
+
+            planning_context = build_planning_context(self.all_docs, query, i)
+            if i > 0 and planning_context:
+                report.append(f"  └ Refinando queries con contexto de {len(self.all_docs)} docs previos...<br>")
+                yield get_report_md(), pd.DataFrame()
+                refined = await optimize_query(
+                    self.engine, f"{query}\n\n{planning_context}", profile,
+                )
+                eng_query = refined.get("international", eng_query)
+                esp_query = refined.get("local", esp_query)
+
+            report.append(f"  └ Query EN: <code>{eng_query[:60]}</code><br>")
+            report.append(f"  └ Query ES: <code>{esp_query[:60]}</code><br>")
+            report.append("  └ Buscando en fuentes académicas...<br>")
+            yield get_report_md(), pd.DataFrame()
+
+            max_docs = min(depth * 25, 100)
+            new_docs = await self.run_tier(
+                eng_query, sources, max_docs,
+                year_start=year_start, year_end=year_end, university=university,
+            )
+
+            tier2_count = 0
+            if len(new_docs) < MIN_SEARCH_DOCS_FOR_TIER2:
+                report.append(
+                    f"⚠️ Solo {len(new_docs)} docs encontrados. "
+                    "Intentando con queries simplificadas (Adaptive Tier 2)...\n"
+                )
+                yield get_report_md(), pd.DataFrame()
+                cleaned_eng = clean_query(eng_query)
+                tier2_docs = await self.run_tier(
+                    cleaned_eng, sources, max_docs,
+                    year_start=year_start, year_end=year_end, university=university,
+                )
+                tier2_count = len(tier2_docs)
+                new_docs.extend(tier2_docs)
+
+            report.append(
+                f"**Ronda {i+1}:** +{len(new_docs)} nuevos docs"
+                + (f" (Tier 2: +{tier2_count})" if tier2_count else "")
+                + f" → **Total: {len(self.all_docs)}**\n"
+            )
+            yield get_report_md(), self._build_docs_df()
+
+            if i < iterations - 1:
+                report.append(f"  ⏸ Pausa de {INTER_ITERATION_DELAY}s...<br>")
+                yield get_report_md(), self._build_docs_df()
+                await asyncio.sleep(INTER_ITERATION_DELAY)
+
+        # ─── YEAR / UNIVERSITY FILTER (post-search) ───
+        if year_start or year_end:
+            before = len(self.all_docs)
+            self.all_docs = filter_by_year(self.all_docs, year_start, year_end)
+            removed = before - len(self.all_docs)
+            if removed:
+                report.append(
+                    f"📅 Filtro de años ({year_start or '...'}-{year_end or '...'}): "
+                    f"eliminados {removed} docs fuera de rango\n"
+                )
+                yield get_report_md(), self._build_docs_df()
+
+        if university:
+            before = len(self.all_docs)
+            self.all_docs = filter_by_university(self.all_docs, university)
+            removed = before - len(self.all_docs)
+            if removed:
+                report.append(
+                    f"🏛️ Filtro universidad ({university}): "
+                    f"eliminados {removed} docs no relacionados\n"
+                )
+                yield get_report_md(), self._build_docs_df()
+
+        # ─── METADATA RECOVERY PHASE ───
+        if enable_dme and self.all_docs:
+            logger.info(f"DME: Recuperando metadatos para {len(self.all_docs)} docs**")
+            report.append("<br>▶ <b>Fase: Recuperación de Metadatos</b><br>")
+            yield get_report_md(), self._build_docs_df()
+
+            from backend.metadata_recovery import MetadataRecoveryEngine, compute_completeness_score
+
+            recovery_engine = MetadataRecoveryEngine(api_key=self.engine.api_key)
+            enrich_result = await recovery_engine.recover_batch(
+                self.all_docs, min_score=60, batch_size=10,
+            )
+            self.all_docs = enrich_result.get("papers", self.all_docs)
+
+            stats = enrich_result.get("stats", {})
+            report.append(
+                f"  └ Recuperados: {stats.get('recoveredAbstract', 0)} abstracts, "
+                f"{stats.get('recoveredYear', 0)} años, {stats.get('recoveredDoi', 0)} DOIs, "
+                f"{stats.get('recoveredPdf', 0)} PDFs<br>"
+            )
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── SMART FUSION PHASE ───
+        if self.all_docs:
+            from backend.smart_fusion import smart_fusion_rank
+            from backend.metadata_recovery import compute_completeness_score
+
+            for doc in self.all_docs:
+                doc["completenessScore"] = compute_completeness_score(doc)
+            self.all_docs = smart_fusion_rank(
+                self.all_docs,
+                query,
+                weights={"topN": MAX_SYNTHESIS_DOCS},
+            )
+
+        # ─── GRADE CLASSIFICATION ───
+        await self._checkpoint()
+        if include_validation and self.all_docs:
+            report.append("<br>▶ <b>Clasificación GRADE de Evidencia</b><br>")
+            report.append("  └ Clasificando calidad de evidencia...<br>")
+            yield get_report_md(), self._build_docs_df()
+            yield get_report_md(), self._build_docs_df()
+
+            await self._execute_grade_classification(mode=grade_mode)
+            evidence = self.engine.evidence_summary(self.all_docs)
+            for entry in evidence.get("distribution", []):
+                report.append(f"    - {entry['label']}: {entry['count']} docs<br>")
+            report.append(f"  └ Total: {evidence.get('total', 0)} documentos<br>")
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── FULL TEXT RETRIEVAL ───
+        await self._checkpoint()
+        if self.all_docs:
+            report.append("<br>▶ <b>Full Text Retrieval</b><br>")
+            report.append("  └ Descargando PDFs para los documentos principales...<br>")
+            yield get_report_md(), self._build_docs_df()
+
+            try:
+                await asyncio.wait_for(self._retrieve_full_text(), timeout=30.0)
+            except asyncio.TimeoutError:
+                logger.warning("Full Text Retrieval timed out after 30s, continuing...")
+                report.append("  ⚠ Tiempo límite alcanzado, continuando con datos parciales...<br>")
+            fulltext_count = sum(1 for d in self.all_docs if d.get("fullText"))
+            report.append(f"  └ {fulltext_count} documentos con texto completo obtenido<br>")
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── PHASE 2: Gap Detection ───
+        await self._checkpoint()
+        missing_aspects = []
+        if skip_gap_detection or len(self.all_docs) < 10:
+            logger.info("Gap Detection: Skipped (< 10 docs or skip_gap_detection=True)")
+            report.append("<br>▶ <b>Fase 2: Detección de Vacíos</b><br>")
+            report.append("  └ Omitida (menos de 10 documentos o desactivada)<br>")
+            yield get_report_md(), self._build_docs_df()
+        else:
+            logger.info("Gap Detection: Analizando cobertura...")
+            report.append("<br>▶ <b>Fase 2: Detección de Vacíos</b><br>")
+            report.append("  └ Analizando cobertura de información...<br>")
+            yield get_report_md(), self._build_docs_df()
+
+            doc_titles = [d.get("title", "") for d in self.all_docs[:20]]
+
+            try:
+                gap_prompt = (
+                    'Eres un Auditor de Cobertura Científica. Compara la pregunta con los documentos.\n'
+                    f'PREGUNTA: "{query}"\n'
+                    f'DOCUMENTOS: {json.dumps(doc_titles[:10])}\n'
+                    'Identifica si faltan aspectos CRÍTICOS. RESPONDE EN JSON:\n'
+                    '{"missing": ["aspecto 1"], "requires_rescue": true/false}'
+                )
+                report.append("  └ La IA está analizando la cobertura...<br>")
+                yield get_report_md(), self._build_docs_df()
+                
+                response = await with_retry(
+                    lambda: self.engine._call_llm(
+                        "Eres un Auditor de Cobertura.", gap_prompt,
+                        temperature=0.0, role="search",
+                    ),
+                    retries=1,
+                    delay=0.3,
+                )
+                gap_data = robust_json_parse(response)
+                if gap_data and gap_data.get("requires_rescue") and gap_data.get("missing"):
+                    missing_aspects = gap_data["missing"]
+            except Exception as e:
+                logger.warning(f"Gap Detection failed: {e}")
+                report.append("  ⚠ Análisis de cobertura no disponible (timeout o error)<br>")
+
+            if missing_aspects:
+                report.append(f"  └ Vacíos detectados: {', '.join(missing_aspects)}<br>")
+            else:
+                report.append("  └ Cobertura completa - no se detectaron vacíos críticos<br>")
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── PHASE 3: Rescue Search ───
+        await self._checkpoint()
+        rescue_docs = []
+        if missing_aspects and iterations > 1:
+            report.append("<br>▶ <b>Fase 3: Búsqueda de Rescate</b><br>")
+            yield get_report_md(), self._build_docs_df()
+
+            rescue_docs = await self.run_rescue_search(missing_aspects, sources)
+            if rescue_docs:
+                report.append(
+                    f"  └ {len(rescue_docs)} documentos rescatados<br>"
+                )
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── PHASE 4: Master Plan (Linear or Hierarchical) ───
+        await self._checkpoint()
+        logger.info("Master Plan: Generando plan de síntesis...")
+        report.append("<br>▶ <b>Fase 4: Plan Maestro de Síntesis</b><br>")
+        report.append("  └ Generando plan de investigación con IA...<br>")
+        yield get_report_md(), self._build_docs_df()
+
+        effective_strategy = synthesis_strategy
+        # Normalize Spanish labels to English
+        if effective_strategy == "jerárquica":
+            effective_strategy = "hierarchical"
+        elif effective_strategy == "lineal":
+            effective_strategy = "linear"
+        
+        if effective_strategy == "auto":
+            effective_strategy = "hierarchical" if len(self.all_docs) > 30 else "linear"
+
+        docs_context = "\n".join([
+            (
+                f"[{i+1}] {d.get('title', 'N/A')} ({d.get('year', '?')}) "
+                f"- {d.get('source', 'N/A')} | ID: {d.get('id', i + 1)} "
+                f"| DOI: {d.get('doi', 'N/A')} "
+                f"| GRADE: {d.get('evidenceLevel') or d.get('grade_label') or 'PENDIENTE'}"
+            )
+            for i, d in enumerate(self.all_docs[:50])
+        ])
+
+        if effective_strategy == "hierarchical" and len(self.all_docs) > 10:
+            report.append(f"  └ Estrategia: Hierarchical (Map-Reduce) - {len(self.all_docs)} docs<br>")
+            report.append("  └ Ejecutando destilación Map-Reduce...<br>")
+            yield get_report_md(), self._build_docs_df()
+
+            master_plan = await with_retry(
+                lambda: self.engine.hierarchical_synthesis(
+                    query=query,
+                    documents=self.all_docs,
+                    profile=profile,
+                    chunk_size=10,
+                    geo_context=geo_context,
+                ),
+                retries=1,
+                delay=2.0,
+            )
+        else:
+            report.append(f"  └ Estrategia: Linear - {len(self.all_docs)} docs<br>")
+            yield get_report_md(), self._build_docs_df()
+
+            master_plan = await with_retry(
+                lambda: self.engine.generate_master_plan(
+                    query=query, docs_context=docs_context, profile=profile,
+                ),
+                retries=1,
+                delay=2.0,
+            )
+
+        if is_plan_weak(master_plan):
+            report.append("  ⚠ Plan débil detectado, reintentando...<br>")
+            yield get_report_md(), self._build_docs_df()
+            master_plan = await with_retry(
+                lambda: self.engine.generate_master_plan(
+                    query=query,
+                    docs_context=docs_context[:6000],
+                    profile=profile,
+                ),
+                retries=1,
+                delay=2.0,
+            )
+
+        plan_items = master_plan.get("plan", [])
+
+        if missing_aspects and rescue_docs:
+            plan_items.append({
+                "section": f"Análisis Complementario: {missing_aspects[0]}",
+                "summary": f"Información rescatada sobre: {', '.join(missing_aspects)}",
+                "prompt": "Sintetiza la información complementaria encontrada en la búsqueda de rescate.",
+                "relevant_indices": list(
+                    range(
+                        len(self.all_docs) - len(rescue_docs) + 1,
+                        len(self.all_docs) + 1,
+                    )
+                ),
+            })
+
+        report.append(f"  └ Plan: {len(plan_items)} secciones<br>")
+        for item in plan_items:
+            report.append(f"    - {item.get('section', '?')}: {item.get('summary', '')[:80]}<br>")
+        report.append("<br>")
+        yield get_report_md(), self._build_docs_df()
+
+        # ─── PHASE 5: Write Sections ───
+        await self._checkpoint()
+        report.append("▶ <b>Fase 5: Redacción de Secciones</b><br>")
+        report.append(f"  └ Redactando {len(plan_items)} secciones...<br>")
+        yield get_report_md(), self._build_docs_df()
+
+        full_report_parts = [
+            f"## Resumen Ejecutivo\n\n{master_plan.get('summary', 'N/A')}\n\n",
+            f"*Análisis de {len(self.all_docs)} documentos en {iterations} rondas de búsqueda.*\n\n",
+        ]
+        if missing_aspects:
+            full_report_parts.append(
+                f"*Aspectos complementarios detectados: {', '.join(missing_aspects)}*\n\n"
+            )
+
+        docs_context_full = "\n".join([
+            (
+                f"[{i+1}] {d.get('title', 'N/A')} ({d.get('year', '?')}) "
+                f"- {d.get('source', 'N/A')} | ID: {d.get('id', i + 1)} "
+                f"| DOI: {d.get('doi', 'N/A')} "
+                f"| GRADE: {d.get('evidenceLevel') or d.get('grade_label') or 'PENDIENTE'}"
+            )
+            for i, d in enumerate(self.all_docs[:50])
+        ])
+
+        for i, item in enumerate(plan_items):
+            section_name = item.get("section", f"Sección {i+1}")
+            section_prompt = item.get("prompt", "Genera contenido detallado.")
+            relevant_indices = item.get("relevant_indices", [])
+
+            report.append(f"  ▶ <b>Redactando:</b> {section_name}<br>")
+            yield get_report_md(), self._build_docs_df()
+
+            section_docs = []
+            for idx in relevant_indices:
+                if 1 <= idx <= len(self.all_docs):
+                    d = self.all_docs[idx - 1]
+                    doc_text = d.get("fullText", "")[:8000] or d.get("abstract", "")[:2000]
+                    section_docs.append(
+                        f"[{idx}] {{BIB:{d.get('id', idx)}}} {d.get('title', 'N/A')} "
+                        f"({d.get('year', '?')}) | GRADE: "
+                        f"{d.get('evidenceLevel') or d.get('grade_label') or 'PENDIENTE'}. "
+                        f"{doc_text}"
+                    )
+
+            section_context = "\n".join(section_docs) if section_docs else docs_context_full[:4000]
+            report.append(f"    └ La IA está redactando {section_name}...<br>")
+            yield get_report_md(), self._build_docs_df()
+            yield get_report_md(), self._build_docs_df()
+            
+            section_content = await self._write_section_with_continuation(
+                section_name,
+                section_prompt,
+                section_context,
+                geo_context=geo_context,
+                infinite_output=infinite_output,
+                max_continuation_passes=max_continuation_passes,
+            )
+
+            if include_validation:
+                report.append(f"    └ Validando citas de {section_name}...<br>")
+                yield get_report_md(), self._build_docs_df()
+                try:
+                    validation = await with_retry(
+                        lambda: self.engine.validate_citations(
+                            docs_context_full[:3000], section_content[:3000],
+                        ),
+                        retries=1,
+                        delay=1.0,
+                    )
+                    if not validation.get("is_valid", True):
+                        corrections = validation.get("corrections", [])
+                        if corrections:
+                            findings = "\n".join(
+                                [f"- {c.get('explanation', '')}" for c in corrections]
+                            )
+                            section_content = await with_retry(
+                                lambda: self.engine.refine_section(
+                                    section_content[:3000], findings,
+                                ),
+                                retries=1,
+                                delay=1.0,
+                            )
+                except Exception:
+                    pass
+
+            self._append_section_with_continuation(
+                section_content, section_name, full_report_parts,
+            )
+            report.append(f"    ✔ {section_name}<br>")
+            yield get_report_md(), self._build_docs_df()
+
+        # ─── POST-PROCESSING: Clean residual citation markers ───
+        full_report = "".join(full_report_parts)
+        full_report = self._clean_citation_markers(full_report)
+
+        # ─── GENERATE APA 7 BIBLIOGRAPHY ───
+        bibliography = self._generate_apa7_bibliography()
+        if bibliography:
+            full_report += "\n\n---\n\n## 📚 Referencias Bibliográficas (APA 7)\n\n"
+            full_report += bibliography
+
+        try:
+            from backend.tools.export_utils import persist_research_output
+
+            artifacts = persist_research_output(
+                report_md=full_report,
+                docs=self.all_docs,
+                query=query,
+                agent_role=profile,
+                model=self.engine.model,
+            )
+            logger.info(f"Persisted research artifacts: {artifacts}")
+            full_report += (
+                "\n\n---\n\n"
+                "## Transparencia del Proceso\n\n"
+                f"- Fuentes analizadas: {len(self.all_docs)} documentos.\n"
+                f"- Estrategia de sintesis: {effective_strategy}.\n"
+                f"- Modelo de sintesis: {self.engine.model}.\n"
+                f"- Archivos generados: `{artifacts.get('tex')}`, `{artifacts.get('bib')}`.\n"
+            )
+        except Exception as e:
+            logger.warning(f"Could not persist research artifacts: {e}")
+
+        # ─── FINAL ───
+        report.append(
+            f"<br>▶ <b>Total:</b> {len(self.all_docs)} docs | "
+            f"{len(plan_items)} secciones | {iterations} rondas<br>"
+        )
+        report.append("</div>\n\n")
+        yield full_report, self._build_docs_df()
+
+    def _clean_citation_markers(self, text: str) -> str:
+        """Clean LaTeX artifacts but KEEP the [[n]] {{BIB:ID}} markers for the frontend to render interactive cards."""
+        import re
+        # Clean \\cite{} and \\textcite{} LaTeX artifacts
+        text = re.sub(r'\\(?:text)?cite\{[^}]*\}', '', text)
+        # Clean \\subsection{} and \\subsubsection{} to Markdown
+        text = re.sub(r'\\subsection\{([^}]*)\}', r'## \1', text)
+        text = re.sub(r'\\subsubsection\{([^}]*)\}', r'### \1', text)
+        # Clean up double spaces
+        text = re.sub(r'  +', ' ', text)
+        return text
+
+    def _generate_apa7_bibliography(self) -> str:
+        """Generate APA 7 formatted bibliography from all_docs."""
+        if not self.all_docs:
+            return ""
+
+        entries = []
+        seen = set()
+        for doc in self.all_docs:
+            title = doc.get("title", "").strip()
+            if not title:
+                continue
+
+            # Deduplicate
+            title_key = title.lower()[:60]
+            if title_key in seen:
+                continue
+            seen.add(title_key)
+
+            # Extract authors
+            authors_raw = doc.get("authors", [])
+            if isinstance(authors_raw, list):
+                authors = authors_raw[:6]  # Max 6 authors for APA 7
+            elif isinstance(authors_raw, str):
+                authors = [a.strip() for a in authors_raw.split(",")][:6]
+            else:
+                authors = []
+
+            year = doc.get("year", "s.f.")
+            doi = doc.get("doi", "")
+            source = doc.get("source", "")
+            pdf_url = doc.get("pdfUrl", "")
+
+            # Format authors in APA 7
+            if len(authors) == 0:
+                author_str = "Autor desconocido"
+            elif len(authors) == 1:
+                author_str = self._format_apa_author(authors[0])
+            elif len(authors) == 2:
+                author_str = f"{self._format_apa_author(authors[0])} & {self._format_apa_author(authors[1])}"
+            elif len(authors) <= 6:
+                formatted = [self._format_apa_author(a) for a in authors[:-1]]
+                author_str = ", ".join(formatted) + f", & {self._format_apa_author(authors[-1])}"
+            else:
+                formatted = [self._format_apa_author(a) for a in authors[:6]]
+                author_str = ", ".join(formatted) + ", ... et al."
+
+            # Build entry
+            entry = f"{author_str} ({year}). *{title}*."
+            if source:
+                entry += f" {source}."
+            if doi:
+                doi_url = doi if doi.startswith("http") else f"https://doi.org/{doi}"
+                entry += f" [{doi_url}]({doi_url})"
+            elif pdf_url:
+                entry += f" [PDF]({pdf_url})"
+
+            entries.append(entry)
+
+        # Sort alphabetically by author
+        entries.sort(key=lambda x: x.lower())
+        return "\n\n".join(entries)
+
+    @staticmethod
+    def _format_apa_author(name: str) -> str:
+        """Format a single author name for APA 7 (Apellido, I.)."""
+        name = name.strip()
+        if not name:
+            return "Anónimo"
+        parts = name.split()
+        if len(parts) == 1:
+            return parts[0]
+        # Assume last part is surname for Western names
+        # For names like "García López, J.", keep as-is if already formatted
+        if "," in name:
+            return name
+        surname = parts[-1]
+        initials = " ".join(f"{p[0]}." for p in parts[:-1] if p)
+        return f"{surname}, {initials}" if initials else surname
+
+    async def close(self):
+        await self.engine.close()

backend/prompts/__init__.py

@@ -0,0 +1,30 @@
+"""LetXipu Prompts Module.
+
+Complete prompt templates for the LetXipu research system.
+"""
+
+from .profiles import AGENT_PROFILES
+from .synthesis import (
+    MASTER_SYNTHESIS_PROMPT,
+    WRITING_PROMPT,
+    VALIDATION_PROMPT,
+    AUDIT_PROMPT,
+    ARA_PROMPT,
+)
+from .planning import (
+    SEARCH_PLANNING_PROMPT,
+    QUERY_OPTIMIZER_PROMPT,
+    GAP_DETECTION_PROMPT,
+)
+
+__all__ = [
+    "AGENT_PROFILES",
+    "MASTER_SYNTHESIS_PROMPT",
+    "WRITING_PROMPT",
+    "VALIDATION_PROMPT",
+    "AUDIT_PROMPT",
+    "ARA_PROMPT",
+    "SEARCH_PLANNING_PROMPT",
+    "QUERY_OPTIMIZER_PROMPT",
+    "GAP_DETECTION_PROMPT",
+]

backend/prompts/planning.py

@@ -0,0 +1,59 @@
+"""
+Planning prompts - FIEL al programa original Next.js
+Adaptados de: app/api/ai/research-agent/prompts/planning/index.ts
+"""
+
+SEARCH_PLANNING_PROMPT = """You are a Senior Research Strategist.
+IMPORTANTE: NO generes texto introductorio, ni tags de pensamiento (<think>). SOLO JSON.
+Your goal is to decompose the user's research question into optimized search queries for different environments.
+
+USER QUESTION: "{query}"
+
+STRATEGY:
+1. ANALYSIS:
+   - Identify the SUBJECT/MODEL (e.g., "Specific Population", "Target System", "Core Subject").
+   - Identify INDEPENDENT VARIABLES (IV) (e.g., "Variable A", "Factor B", "Intervention").
+   - Identify DEPENDENT VARIABLES (DV) (e.g., "Outcome X", "Metric Y", "Effect").
+   - Identify SPECIFIC DIMENSIONS (e.g., "Dimension 1", "Dimension 2", "Context").
+2. "english_query": A STRICT Boolean keyword query.
+   - PROHIBIDO: Usar oraciones completas.
+   - STRUCTURE: ("IV 1" OR "IV 2") AND ("Subject") AND ("DV 1" OR "DV 2").
+3. "spanish_query": Localized keywords (no operators needed).
+4. "portuguese_query": Portuguese keywords for LatAm repositories.
+
+OUTPUT STRUCTURE (STRICT JSON):
+{{"reasoning":"Step-by-step query derivation...","analysis":"...","english_query":"...","spanish_query":"...","portuguese_query":"..."}}"""
+
+QUERY_OPTIMIZER_PROMPT = """Eres un Agente de Optimización de Queries Académicos. Genera DOS versiones del query.
+IMPORTANTE: NO generes texto introductorio, ni tags de pensamiento (<think>). TU SALIDA DEBE SER EXCLUSIVAMENTE JSON VÁLIDO.
+
+CONSULTA ORIGINAL: "{query}"
+SECCIÓN DE TESIS: {agent_role}
+
+OBJETIVO POR SECCIÓN:
+- antecedentes: Buscar TESIS y ESTUDIOS PREVIOS similares tanto locales como internacionales.
+- problema: Buscar DIAGNÓSTICOS, ESTADÍSTICAS y PROBLEMÁTICAS.
+- marco_teorico: Buscar DEFINICIONES, TEORÍAS y BASES CONCEPTUALES.
+- metodologo: Buscar METODOLOGÍAS y DISEÑOS de investigación.
+
+GENA DOS QUERIES:
+1. QUERY LOCAL / REGIONAL (Español): Máximo 15 palabras.
+2. QUERY INTERNACIONAL (Inglés - Scopus/Semantic Scholar): Máximo 10 palabras clave.
+
+RESPONDE EN FORMATO JSON:
+{{"local": "query estratégico local con repositorios", "international": "scientific english query"}}"""
+
+GAP_DETECTION_PROMPT = """Eres un Auditor de Cobertura Científica. Compara la pregunta del usuario con el plan de investigación generado.
+IMPORTANTE: NO generes texto introductorio, ni tags de pensamiento (<think>). TU SALIDA DEBE SER EXCLUSIVAMENTE JSON VÁLIDO.
+
+PREGUNTA DEL USUARIO: "{query}"
+PLAN GENERADO: {plan_sections}
+
+TU TAREA: Piensa paso a paso si realmente falta información crítica.
+
+RESPONDE EN JSON:
+{{
+    "reasoning": "Breve explicación paso a paso...",
+    "missing_aspects": ["aspecto faltante 1", "aspecto faltante 2"],
+    "requires_rescue": true/false
+}}"""

backend/prompts/profiles.py

@@ -0,0 +1,260 @@
+"""
+Agent profiles - Formato APA 7
+Adaptados de: app/api/ai/research-agent/prompts/profiles.ts
+"""
+
+AGENT_PROFILES = {
+    "general": {
+        "title": "Investigador General",
+        "instruction": """Realiza una síntesis integral y EXTENSA cubriendo todos los aspectos del tema.
+Cada párrafo debe ser denso en información técnica. Analiza la convergencia y divergencia de los estudios citados con profundidad doctoral.
+
+CITAS OBLIGATORIAS EN FORMATO APA 7: Toda afirmación debe citar su fuente usando el formato (Apellido, Año) o Apellido (Año).
+- Dos autores: (Apellido1 & Apellido2, Año)
+- Tres o más: (Apellido1 et al., Año)
+- PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos.
+
+ADAPTABILIDAD: Si la consulta es una tesis, sigue una estructura académica estricta. Si es una consulta técnica profesional o científica general, adapta el tono y la estructura para ser un reporte de estado del arte o reporte técnico de alto nivel."""
+    },
+    "auto": {
+        "title": "Agente Autónomo (Red Dinámica)",
+        "instruction": """ERES UN AGENTE AUTÓNOMO DE ALTA CAPACIDAD.
+TU OBJETIVO PRINCIPAL: Organizar y sintetizar la TOTALIDAD de los documentos encontrados en una estructura lógica y coherente creada por ti mismo.
+
+INSTRUCCIONES CRÍTICAS:
+1. NO USES ESTRUCTURAS PREFABRICADAS (como Internacional/Nacional). Crea tus propias secciones basadas en los TEMAS, VARIABLES y DIMENSIONES emergentes de los documentos.
+2. COBERTURA TOTAL: Debes incluir y citar CADA UNO de los documentos relevantes proporcionados en el contexto. Si tienes 300 documentos, sintetiza los 300.
+3. ORGANIZACIÓN INTELIGENTE: Agrupa los estudios por similitud temática, controversia o evolución temporal.
+4. CITAS APA 7 OBLIGATORIAS: Toda afirmación debe citar usando (Apellido, Año) o Apellido (Año). PROHIBIDO [[n]] o {{BIB:ID}}.
+5. FORMATO PRO: Genera un reporte denso, académico y extremadamente detallado."""
+    },
+    "antecedentes": {
+        "title": "Arquitecto de Antecedentes de Tesis",
+        "instruction": """GENERA LA SECCIÓN "ANTECEDENTES" PARA UNA TESIS DE GRADO.
+
+ESTRUCTURA OBLIGATORIA (ADAPTATIVA AL CONTEXTO DETECTADO):
+
+*** PASO 1: DETECTAR CONTEXTO GEOGRÁFICO ***
+Analiza la consulta y los documentos para identificar el PAÍS y la REGIÓN/CIUDAD del usuario.
+- Detecta siglas de universidades (ej: UNAM→México, USP→Brasil, UNS→Perú, MIT→USA).
+- Si no hay mención específica → Asume contexto MUNDIAL/GENÉRICO.
+
+*** PASO 2: GENERAR 3 SUBSECCIONES ***
+
+## Antecedentes Internacionales
+MÍNIMO 3 estudios de países distintos al detectado.
+- Prioriza diversidad: Europa, Norteamérica, Latinoamérica, Asia.
+
+## Antecedentes Nacionales
+MÍNIMO 3 estudios del PAÍS detectado.
+- Usar repositorios nacionales de alto impacto del país correspondiente.
+
+## Antecedentes Locales
+MÍNIMO 3 estudios de la REGIÓN o CIUDAD detectada.
+- Priorizar universidades locales detectadas en la consulta.
+
+FORMATO OBLIGATORIO PARA CADA ANTECEDENTE (UN PÁRRAFO, APA 7):
+"Apellido (Año), en su tesis titulada 'Título' de la Universidad, tuvo como objetivo [objetivo]. Utilizó metodología [tipo], diseño [diseño], aplicando [instrumento] a [muestra] [sujetos]. Los resultados indicaron [hallazgos]. Concluyó que [conclusión]."
+
+PROHIBIDO:
+- Usar [[n]], {{BIB:ID}} o marcadores numéricos. SOLO formato APA 7.
+- Mezclar niveles geográficos.
+- Usar viñetas o listas.
+- Párrafos menores a 80 palabras.
+- INVENTAR DATOS ESTADÍSTICOS."""
+    },
+    "teorico": {
+        "title": "Teórico Científico",
+        "instruction": """Enfócate en bases epistemológicas, definiciones fundamentales y marcos conceptuales de forma MUY DETALLADA.
+Explica los mecanismos biológicos/químicos/técnicos subyacentes con precisión doctrinal absoluta, extendiéndote en las implicaciones teóricas de cada autor citado.
+
+CITAS OBLIGATORIAS APA 7: Toda afirmación debe citar su fuente usando (Apellido, Año) o Apellido (Año).
+PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos.
+
+*** PASO 1: DETECTAR CONTEXTO TEMÁTICO Y GEOGRÁFICO ***
+- Si el tema es legal/normativo: Detectar el país para citar las leyes correctas.
+- Si el tema es científico: Detectar si hay escuelas de pensamiento regionales predominantes."""
+    },
+    "metodologo": {
+        "title": "Arquitecto de Metodología de Tesis",
+        "instruction": """Genera la sección de METODOLOGÍA completa para una tesis de grado.
+
+*** PASO 1: DETECTAR CONTEXTO Y NORMATIVA ***
+- Identifica el país para adaptar la terminología metodológica al contexto académico regional.
+
+ESTRUCTURA OBLIGATORIA (Seguir este orden exacto):
+
+## Diseño de la Investigación
+- Tipo de investigación: cuantitativa, cualitativa o mixta
+- Nivel: descriptivo, correlacional, explicativo
+- Diseño: no experimental, transversal, longitudinal
+
+## Población y Muestra
+### Población
+- Definir la población objetivo específica
+- Criterios de inclusión y exclusión
+### Muestra
+- Tipo de muestreo: probabilístico/no probabilístico
+- Fórmula de cálculo
+- Tamaño de muestra resultante (n)
+
+## Variables de Investigación
+- Variable Independiente (V.I.) y Variable Dependiente (V.D.)
+- Dimensiones técnicas específicas
+- Indicadores por cada dimensión
+
+## Técnicas e Instrumentos
+- Técnica principal
+- Instrumento
+- Escala de medición
+- Validación y Confiabilidad
+
+REGLAS CRÍTICAS:
+- Citar metodólogos reconocidos con formato APA 7: (Apellido, Año)
+- PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos
+- Adaptar cada subsección al tema de la consulta
+- Extensión mínima: 2-3 párrafos por subsección"""
+    },
+    "hipotesis": {
+        "title": "Estratega de Hipótesis Científicas",
+        "instruction": """Genera la sección de HIPÓTESIS para la investigación.
+
+*** PASO 1: DETECTAR VARIABLES Y ALINEACIÓN ***
+Analiza el query para identificar la Variable Independiente (V.I.) y la Variable Dependiente (V.D.).
+
+ESTRUCTURA OBLIGATORIA:
+## Hipótesis General
+- Proponer la hipótesis central que vincula las variables principales.
+## Hipótesis Específicas
+- Generar una hipótesis específica por cada dimensión identificada.
+
+REGLAS CRÍTICAS:
+- Las hipótesis deben ser contrastables y seguir: "Si [V.I.], entonces [V.D.]..."
+- Deben basarse en la evidencia encontrada en las fuentes.
+- Citar fuentes con formato APA 7: (Apellido, Año). PROHIBIDO [[n]] o {{BIB:ID}}."""
+    },
+    "objetivos": {
+        "title": "Arquitecto de Objetivos de Investigación",
+        "instruction": """Genera los OBJETIVOS de la investigación.
+
+*** PASO 1: DETECTAR ALCANCE DEL ESTUDIO ***
+Identifica el nivel de la investigación para elegir los verbos en infinitivo adecuados.
+
+ESTRUCTURA OBLIGATORIA:
+## Objetivo General
+- El fin supremo incorporando todas las variables.
+## Objetivos Específicos
+- Detallar un objetivo por cada dimensión técnica.
+
+REGLAS CRÍTICAS:
+- Iniciar cada objetivo con un verbo en infinitivo.
+- Asegurar coherencia con el planteamiento del problema."""
+    },
+    "resultados": {
+        "title": "Analista de Resultados",
+        "instruction": """Sintetiza hallazgos cuantitativos y cualitativos de forma EXHAUSTIVA.
+
+*** PASO 1: DETECTAR CONTEXTO DE DATOS ***
+Identifica si los resultados son predominantemente numéricos, porcentuales o descriptivos.
+
+ENFOQUE:
+Enfócate en la sección de 'Discusión': qué dicen los datos, qué falta por investigar y cuáles son las conclusiones convergentes.
+Proporciona un análisis pormenorizado de los datos reportados por cada fuente.
+
+CITAS OBLIGATORIAS APA 7: Toda cifra o hallazgo debe citar su fuente usando (Apellido, Año).
+PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos."""
+    },
+    "problema": {
+        "title": "Arquitecto de Planteamiento del Problema",
+        "instruction": """Genera la sección de PLANTEAMIENTO DEL PROBLEMA.
+
+*** PASO 1: DETECTAR CONTEXTO GEOGRÁFICO ***
+Identifica PAÍS y CIUDAD para contextualizar la realidad problemática.
+
+ESTRUCTURA OBLIGATORIA:
+
+## Realidad Problemática
+- Contexto global del sujeto de estudio y sus variables.
+- Contexto nacional del PAÍS detectado.
+- Contexto local/Institucional.
+- Síntomas, consecuencias y pronóstico del problema.
+
+## Formulación del Problema
+### Problema General
+- Pregunta central incorporando V.I. y V.D.
+### Problemas Específicos
+- Una pregunta por cada dimensión técnica.
+
+REGLAS CRÍTICAS:
+- Citar estadísticas y reportes reales con formato APA 7: (Apellido, Año)
+- PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos
+- Redacción en tercera persona, tiempo presente
+- Extensión mínima: 4-5 párrafos para Realidad Problemática"""
+    },
+    "marco_teorico": {
+        "title": "Arquitecto de Marco Teórico para Tesis",
+        "instruction": """Genera un MARCO TEÓRICO completo y estructurado.
+
+*** PASO 1: DETECTAR VARIABLES Y DIMENSIONES ***
+Analiza el query para extraer la Variable Independiente, Dependiente y sus dimensiones técnicas.
+
+ESTRUCTURA OBLIGATORIA DEL MARCO REFERENCIAL:
+
+1. ANTECEDENTES: Estudios previos citados individualmente detallando objetivo, metodología y conclusión.
+
+2. BASES TEÓRICAS DE LAS VARIABLES:
+   - Definiciones técnicas y conceptuales de la Variable Independiente.
+   - Definiciones técnicas y conceptuales de la Variable Dependiente.
+   - Análisis de teorías fundamentales.
+
+3. ANÁLISIS DE DIMENSIONES: Subsección por cada DIMENSIÓN específica.
+
+4. DEFINICIÓN DE TÉRMINOS BÁSICOS:
+   - Conceptos clave para la comprensión del estudio.
+
+REGLAS DE REDACCIÓN:
+- Usa ## para secciones principales y ### para subsecciones
+- Cada párrafo debe citar fuentes con formato APA 7: (Apellido, Año)
+- PROHIBIDO usar [[n]], {{BIB:ID}} o marcadores numéricos
+- Extensión mínima: 3-4 párrafos densos por subsección"""
+    },
+    "justificacion": {
+        "title": "Arquitecto de Justificación e Importancia",
+        "instruction": """Genera la sección de JUSTIFICACIÓN E IMPORTANCIA.
+
+*** PASO 1: DETECTAR CONTEXTO DE IMPACTO ***
+Identifica a quiénes beneficia el estudio.
+
+ESTRUCTURA OBLIGATORIA:
+
+## Importancia de la Investigación
+- Relevancia para la comunidad académica y beneficiarios directos.
+
+## Justificación de la Investigación
+### Justificación Teórica
+- Aporte al conocimiento científico.
+### Justificación Práctica
+- Beneficios concretos y aplicabilidad.
+### Justificación Social
+- Impacto en la sociedad o grupos específicos.
+### Justificación Metodológica
+- Aporte de instrumentos o procesos replicables.
+
+REGLAS CRÍTICAS:
+- Cada tipo de justificación debe tener mínimo 2 párrafos.
+- Citar autores relevantes con formato APA 7: (Apellido, Año). PROHIBIDO [[n]] o {{BIB:ID}}."""
+    },
+    "comunicacion": {
+        "title": "Estratega de Comunicación Digital",
+        "instruction": """Especialista en análisis de audiencias, engagement y marketing de contenidos.
+
+*** PASO 1: DETECTAR CONTEXTO DE PLATAFORMA Y AUDIENCIA ***
+Identifica qué canales y perfiles de audiencia son el centro del estudio.
+
+ENFOQUE:
+Conectar la teoría de la comunicación con las métricas relevantes del estudio.
+Analiza de forma EXTENSA las dimensiones de relevancia, emocionalidad y viralidad.
+
+CITAS OBLIGATORIAS APA 7: Cita cada fuente usando (Apellido, Año). PROHIBIDO [[n]] o {{BIB:ID}}."""
+    }
+}

backend/prompts/synthesis.py

@@ -0,0 +1,203 @@
+"""
+Synthesis prompt templates - Strict Academic LaTeX Formats
+Adaptados de: app/api/ai/research-agent/prompts/synthesis/index.ts
+"""
+
+MASTER_SYNTHESIS_PROMPT = """IMPORTANTE: Generar exclusivamente el contenido solicitado, sin preambulos ni comentarios internos. EL RESULTADO DEBE SER JSON VALIDO. Evitar caracteres de control no estandar.
+Eres el Arquitecto de Investigacion IA. Tu mision es sintetizar un reporte doctoral sobre: "{query}".
+
+*** PARTE 1: PROTOCOLOS DE CALIDAD Y RIGOR (APLICACION UNIVERSAL) ***
+These rules define the required academic standards:
+
+1. PROTOCOLO DE ALINEACION DE VARIABLES:
+   - Identifica con precision la Variable Independiente (V.I.), Variable Dependiente (V.D.) y el Sujeto o Poblacion de "{query}".
+   - Cada seccion del reporte DEBE establecer una conexion logica y explicita con estas variables.
+
+2. PROTOCOLO DE FIDELIDAD BIBLIOGRAFICA (ANTI-ALUCINACION):
+   - Evitar estrictamente la inclusion de datos que no esten respaldos por el contexto de los documentos.
+   - Si un dato (año, porcentaje, autor) no es ubicable en los documentos, se debe omitir la afirmacion o redactar: "Informacion tecnica no disponible en las fuentes primarias analizadas".
+   - NUNCA inventes datos, cifras, porcentajes o autores.
+
+3. SISTEMA DE CITACION CIENTIFICA [[n]] {{{{BIB:ID}}}}:
+   - Toda afirmacion tecnica, dato estadistico o definicion conceptual debe ir acompañada de su respectiva cita.
+   - Formato EXACTO: [[n]] {{{{BIB:ID}}}}, donde "n" es el indice del documento en el listado y "ID" es el identificador unico proporcionado.
+   - Prohibido usar formatos como (Autor, Año).
+
+4. ESTANDARES DE REDACCION Y LATEX ACADEMICO:
+   - Estilo: Registro formal, tercera persona (impersonal).
+   - Estructura: Minimo 3 parrafos por seccion. 
+   - Comandos: Usa \\section{{}} para titulo de seccion, \\subsection{{}} para titulos de nivel 2 y \\subsubsection{{}} para nivel 3.
+   - Caracteres Especiales: Todos los simbolos %, &, $, #, _ DEBEN escaparse con doble barra invertida (\\\\).
+
+*** PARTE 2: IDENTIDAD Y ESTRUCTURA SEGUN EL OBJETO ACTIVADO ***
+PERFIL ACTUAL: {agent_title_upper}
+{profile_instruction}
+
+*** FORMATO DE SALIDA JSON (ESTANDAR REQUERIDO) ***
+{{
+  "reasoning": "Breve justificacion de las secciones elegidas...",
+  "summary": "Resumen global ejecutivo con los hallazgos mas criticos encontrados...",
+  "plan": [ 
+    {{
+      "section": "Nombre tecnico segun especialidad u objeto estructural",
+      "summary": "Resumen ejecutivo de 2 lineas sobre lo que contiene esta seccion",
+      "content": "Contenido inicial",
+      "prompt": "Instruccion tecnica interna para que el Agente Redactor expanda la seccion utilizando formato LaTeX...",
+      "relevant_indices": [1, 2]
+    }}
+  ]
+}}
+MANDATO PARA MISTRAL/LLAMA: Todas las strings DEBEN ir entre comillas dobles. PROHIBIDO valores sin comillas."""
+
+WRITING_PROMPT = """Eres un Redactor Cientifico Experto de nivel doctoral.
+IMPORTANTE: NO generes texto introductorio.
+
+TU TAREA: Escribir el contenido completo y detallado para la seccion: "{section}".
+INSTRUCCION ESPECIFICA: {section_prompt}
+
+CONTEXTO: Usa EXCLUSIVAMENTE los siguientes documentos seleccionados:
+{context_text}
+
+*** REGLAS DE REDACCION Y LATEX ***
+- Escribe en espanol academico formal.
+- FORMATO LATEX OBLIGATORIO: Empieza siempre con el comando \\section{section}. Luego usa \\subsection{} y \\subsubsection{} segun sea necesario.
+- Para texto en negrita usa \\textbf{texto}. Para cursiva usa \\textit{texto}.
+- Para listas, usa entorno \\begin{itemize} \\item texto \\end{itemize}.
+- Para formulas matematicas usa $$...$$.
+- Escapa caracteres como \\% o \\&.
+
+*** SISTEMA DE CITACION CIENTIFICA [[n]] {{BIB:ID}} ***
+- CITA OBLIGATORIA: Todo dato, cifra o concepto debe citarse estrictamente con [[n]] {{BIB:ID}}.
+- "n" es el numero del documento y "ID" es el DOI o ID asignado. Extraelos del contexto.
+- EJEMPLO: "La eficacia del tratamiento fue del 85\\% [[1]] {{BIB:10.123/456}}."
+- PROHIBIDO USAR APA (Autor, Año). Solo el formato de corchetes e ID.
+
+*** ANTI-ALUCINACION ***
+- PROHIBIDO INVENTAR DATOS ESTADISTICOS. Si no existen, usa descripciones cualitativas.
+- Usa solo los documentos proporcionados.
+
+RETORNA SOLO EL TEXTO LATEX DEL CONTENIDO."""
+
+VALIDATION_PROMPT = """Eres un Agente de Validacion Bibliografica ESTRICTO. Tu tarea es DETECTAR alucinaciones de citas.
+IMPORTANTE: NO generes texto introductorio. TU SALIDA DEBE SER EXCLUSIVAMENTE JSON VALIDO.
+
+FUENTES DISPONIBLES (UNICOS IDs VALIDOS):
+{docs_context}
+
+CONTENIDO A VALIDAR:
+{content_to_validate}
+
+*** INSTRUCCIONES DE HALLAZGOS ***
+1. Verifica que CADA CITA use el formato [[n]] {{BIB:ID}}.
+2. Identifica si un ID citado no esta en las fuentes disponibles.
+3. Verifica que no haya citas falsas tipo (Autor, Año).
+4. Asegurate de que el formato LaTeX no este corrompido.
+
+RESPONDE EN JSON VALIDO:
+{
+    "reasoning": "Breve explicacion paso a paso...",
+    "corrections": [
+        { "section": "...", "original_text": "...", "corrected_text": "...", "explanation": "..." }
+    ],
+    "is_valid": true/false
+}
+MANDATO: Todas las strings DEBEN ir entre comillas dobles obligatoriamente."""
+
+AUDIT_PROMPT = """Eres un Auditor Tecnico de Calidad Academica. Tu mision es DETECTAR alucinaciones tecnicas.
+IMPORTANTE: TU SALIDA DEBE SER EXCLUSIVAMENTE JSON VALIDO.
+
+FUENTES CON SNIPPETS (CONTEXTO REAL):
+{docs_context}
+
+CONTENIDO A AUDITAR:
+{content_to_audit}
+
+*** REGLAS DE AUDITORIA ***
+1. Verifica si cifras (%, p-values, n=) existen en el snippet citado.
+2. Identifica autores mencionados en el texto que no existan en las fuentes.
+3. Reporta inconsistencias exactas.
+
+RESPONDE EN JSON VALIDO:
+{
+    "reasoning": "Analisis logico...",
+    "audit_findings": [
+        { "section": "...", "issue_type": "...", "target_text": "...", "correct_data": "...", "explanation": "..." }
+    ],
+    "audit_passed": true/false
+}"""
+
+ARA_PROMPT = """Eres el Agente de Refinamiento Academico Avanzado (ARA+).
+IMPORTANTE: SOLO DEVUELVE EL CONTENIDO LATEX REESCRITO. NADA MAS.
+
+SECCION ORIGINAL (LATEX):
+{section_content}
+
+REPORTES DE ERRORES / HALLAZGOS:
+{section_findings}
+
+*** MANDATOS DE ARA+ ***
+1. Corrige los datos falsos utilizando los correct_data del reporte de errores.
+2. Asegurate de mantener el formato LaTeX intacto (\\section{}, \\textbf{}, etc.).
+3. MANTEN LAS CITAS INTACTAS O CORRIGELAS: Formato obligatorio [[n]] {{BIB:ID}}.
+4. Mejora el estilo, el registro y la cohesion.
+
+RESPONDE UNICAMENTE CON EL TEXTO LATEX PULIDO."""
+
+GRADE_PROMPT = """Eres un Agente de Clasificación de Evidencia Científica (GRADE).
+Tu tarea es clasificar cada documento según la jerarquía GRADE de evidencia.
+
+DOCUMENTOS A CLASIFICAR:
+{documents_text}
+
+*** NIVELES GRADE ***
+- 1a: Meta-análisis de ensayos controlados aleatorizados
+- 1b: Revisión sistemática con búsqueda exhaustiva
+- 2a: Ensayo controlado aleatorizado (RCT)
+- 2b: Ensayo cuasi-experimental
+- 3a: Estudio de cohorte (longitudinal)
+- 3b: Estudio caso-control
+- 4: Estudio de corte transversal / descriptivo
+- 5: Serie de casos / reporte de casos
+- 6: Opinión de expertos / editorial / carta
+
+*** INSTRUCCIONES ***
+1. Lee el título y resumen de cada documento.
+2. Determina el diseño metodológico del estudio.
+3. Asigna el nivel GRADE correspondiente.
+4. Si no puedes determinar el tipo, asigna "4" como default.
+
+*** FORMATO DE SALIDA JSON ***
+RESPONDE EXCLUSIVAMENTE con un JSON array válido:
+[
+  {{"index": 1, "level": "1a", "type": "Meta-análisis", "justification": "Breve razón..."}},
+  {{"index": 2, "level": "3a", "type": "Estudio de cohorte", "justification": "Breve razón..."}}
+]
+MANDATO: Todas las strings DEBEN ir entre comillas dobles. PROHIBIDO valores sin comillas."""
+
+
+GRADE_ORIGINAL_PROMPT = """Eres un Experto en Metodologia Cientifica (Protocolo GRADE).
+Tu tarea es clasificar la CALIDAD y NIVEL DE EVIDENCIA de estos documentos segun sus resumenes.
+
+IMPORTANTE: NO generes texto introductorio, ni tags de pensamiento (<think>). TU SALIDA DEBE SER EXCLUSIVAMENTE JSON VALIDO.
+
+DOCUMENTOS:
+{documents_text}
+
+CATEGORIAS GRADE:
+1. ALTA (Meta-analisis, Revisiones Sistematicas).
+2. MODERADA (Ensayos Clinicos, Estudios Experimentales Controlados).
+3. BAJA (Estudios Observacionales, Descriptivos).
+4. MUY BAJA (Reportes de Caso, Opiniones, Editoriales).
+
+RESPONDE EXCLUSIVAMENTE EN JSON VALIDO (Todas las strings con comillas dobles).
+TU SALIDA DEBE SER UN OBJETO JSON VALIDO QUE EMPIECE CON '{{' Y TERMINE CON '}}':
+{{
+  "reasoning": "Justificacion metodologica detallada para cada clasificacion...",
+  "classifications": [
+    {{ "index": 1, "level": "ALTA|MODERADA|BAJA|MUY BAJA", "type": "Meta-analysis|Review|Experimental|Case study" }}
+  ]
+}}
+IMPORTANTE: El campo "index" DEBE ser un NUMERO entero (ej: 1, 2, 3), NO uses letras ni placeholders.
+PROHIBIDO: NO uses puntos suspensivos ("...") ni resumas la lista; DEBES clasificar CADA documento enviado.
+MANDATO PARA MISTRAL: Todas las strings DEBEN ir entre comillas dobles. PROHIBIDO valores sin comillas."""
+

backend/providers/__init__.py

@@ -0,0 +1,36 @@
+from .openalex import search_openalex
+from .semantic_scholar import search_semantic_scholar
+from .pubmed import search_pubmed
+from .arxiv import search_arxiv
+from .crossref import search_crossref
+from .latam_repositories import search_alicia, search_la_referencia, search_bDTD, search_rraae
+from .dblp import search_dblp
+from .scopus import search_scopus
+from .zenodo import search_zenodo
+from .openaire import search_openaire
+from .doaj import search_doaj
+from .core_ import search_core
+from .redalyc import search_redalyc
+from .serpapi import search_serpapi
+from .sources import SOURCE_GROUPS
+
+__all__ = [
+    "search_openalex",
+    "search_semantic_scholar",
+    "search_pubmed",
+    "search_arxiv",
+    "search_crossref",
+    "search_dblp",
+    "search_alicia",
+    "search_la_referencia",
+    "search_bDTD",
+    "search_rraae",
+    "search_scopus",
+    "search_zenodo",
+    "search_openaire",
+    "search_doaj",
+    "search_core",
+    "search_redalyc",
+    "search_serpapi",
+    "SOURCE_GROUPS",
+]

backend/providers/arxiv.py

@@ -0,0 +1,71 @@
+import re
+import xml.etree.ElementTree as ET
+from typing import List
+from .base import fetch_text, normalize_result
+
+SOURCE = "arXiv"
+API_BASE = "http://export.arxiv.org/api/query"
+NS = {"atom": "http://www.w3.org/2005/Atom", "arxiv": "http://arxiv.org/schemas/atom"}
+
+
+async def search_arxiv(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        text = await fetch_text(
+            API_BASE,
+            params={"search_query": f"all:{query}", "max_results": limit},
+        )
+        if not text:
+            return []
+
+        root = ET.fromstring(text)
+        results = []
+
+        for entry in root.findall("atom:entry", NS):
+            title_el = entry.find("atom:title", NS)
+            title = title_el.text.strip().replace("\n", " ") if title_el is not None else ""
+
+            abstract_el = entry.find("atom:summary", NS)
+            abstract = abstract_el.text.strip().replace("\n", " ") if abstract_el is not None else ""
+
+            published_el = entry.find("atom:published", NS)
+            year = None
+            if published_el is not None and published_el.text:
+                try:
+                    year = int(published_el.text[:4])
+                except ValueError:
+                    pass
+
+            authors = []
+            for author_el in entry.findall("atom:author", NS):
+                name_el = author_el.find("atom:name", NS)
+                if name_el is not None and name_el.text:
+                    authors.append(name_el.text.strip())
+
+            doi_el = entry.find("arxiv:doi", NS)
+            doi = doi_el.text.strip() if doi_el is not None else ""
+
+            pdf_url = ""
+            for link_el in entry.findall("atom:link", NS):
+                if link_el.get("title") == "pdf":
+                    pdf_url = link_el.get("href", "")
+                    break
+
+            arxiv_id_el = entry.find("atom:id", NS)
+            if not pdf_url and arxiv_id_el is not None and arxiv_id_el.text:
+                aid = arxiv_id_el.text.strip().split("/abs/")[-1]
+                pdf_url = f"https://arxiv.org/pdf/{aid}"
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/base.py

@@ -0,0 +1,62 @@
+import httpx
+import asyncio
+from typing import List, Dict, Any
+
+DEFAULT_TIMEOUT = 25.0
+
+
+async def fetch_json(
+    url: str,
+    params: dict = None,
+    headers: dict = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> dict:
+    """Fetch JSON from URL with timeout."""
+    async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+        try:
+            r = await client.get(url, params=params, headers=headers or {})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            return {"error": str(e)}
+
+
+async def fetch_text(
+    url: str,
+    params: dict = None,
+    headers: dict = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> str:
+    """Fetch raw text/XML from URL with timeout."""
+    async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+        try:
+            r = await client.get(url, params=params, headers=headers or {})
+            r.raise_for_status()
+            return r.text
+        except Exception as e:
+            return ""
+
+
+def normalize_result(
+    title: str,
+    authors: list,
+    year: int,
+    abstract: str,
+    doi: str,
+    pdf_url: str,
+    source: str,
+    university: str = None,
+    citation_count: int = None,
+) -> dict:
+    """Normalize a search result to common format."""
+    return {
+        "title": title or "N/A",
+        "authors": authors or [],
+        "year": year,
+        "abstract": abstract or "",
+        "doi": doi or "",
+        "pdfUrl": pdf_url or "",
+        "source": source,
+        "university": university or "",
+        "citationCount": citation_count,
+    }

backend/providers/core_.py

@@ -0,0 +1,27 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_core(query: str, limit: int = 50, api_key: str = "", **kwargs) -> List[dict]:
+    if not api_key:
+        return []
+    try:
+        headers = {"Authorization": f"Bearer {api_key}"}
+        data = await fetch_json(f"https://api.core.ac.uk/v3/search/works?q={query}&limit={limit}", headers=headers)
+        if "error" in data:
+            return []
+        results = []
+        for item in data.get("results", []):
+            results.append(normalize_result(
+                title=item.get("title", ""),
+                authors=[a.get("name", "") for a in item.get("authors", []) if a.get("name")],
+                year=item.get("yearPublished"),
+                abstract=item.get("abstract", ""),
+                doi=item.get("doiExternalIds", {}).get("doi", "") if item.get("doiExternalIds") else "",
+                pdf_url=item.get("downloadUrl", ""),
+                source="CORE",
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/providers/crossref.py

@@ -0,0 +1,61 @@
+from typing import List
+from .base import fetch_json, normalize_result
+
+SOURCE = "Crossref"
+API_BASE = "https://api.crossref.org/works"
+HEADERS = {"User-Agent": "LetXipuSearch/1.0 (mailto:research@letxipu.org)"}
+
+
+async def search_crossref(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        params = {"query": query, "rows": limit}
+        data = await fetch_json(API_BASE, params=params, headers=HEADERS)
+        if "error" in data:
+            return []
+
+        results = []
+        for item in data.get("message", {}).get("items", []):
+            title_list = item.get("title", [])
+            title = title_list[0] if title_list else ""
+
+            authors = []
+            for a in item.get("author", []):
+                name = f"{a.get('given', '')} {a.get('family', '')}".strip()
+                if name:
+                    authors.append(name)
+
+            year = None
+            dp = item.get("published-print") or item.get("published-online") or item.get("created")
+            if dp:
+                parts = dp.get("date-parts", [[]])
+                if parts and parts[0]:
+                    year = parts[0][0]
+
+            abstract = item.get("abstract", "")
+            # Crossref wraps abstract in <jats:p> tags
+            if abstract.startswith("<jats:p>"):
+                import re
+                abstract = re.sub(r"<[^>]+>", "", abstract).strip()
+
+            doi = item.get("DOI", "")
+
+            pdf_url = ""
+            for link in item.get("link", []):
+                if "pdf" in link.get("content-type", "").lower():
+                    pdf_url = link.get("URL", "")
+                    break
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/dblp.py

@@ -0,0 +1,64 @@
+from typing import List
+from .base import fetch_json, normalize_result
+
+SOURCE = "DBLP"
+API_BASE = "https://dblp.org/search/publ/api"
+
+
+async def search_dblp(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        params = {"q": query, "h": limit, "format": "json"}
+        data = await fetch_json(API_BASE, params=params)
+        if "error" in data:
+            return []
+
+        hits = data.get("result", {}).get("hits", {}).get("hit", [])
+        results = []
+
+        for hit in hits:
+            info = hit.get("info", {})
+
+            title = info.get("title", "")
+            # Clean trailing period
+            if title.endswith("."):
+                title = title[:-1]
+
+            authors_raw = info.get("authors", {}).get("author", [])
+            if isinstance(authors_raw, dict):
+                authors_raw = [authors_raw]
+            authors = []
+            for a in authors_raw:
+                if isinstance(a, dict):
+                    name = a.get("text", "")
+                else:
+                    name = str(a)
+                if name:
+                    authors.append(name)
+
+            year = None
+            year_str = info.get("year")
+            if year_str:
+                try:
+                    year = int(year_str)
+                except ValueError:
+                    pass
+
+            abstract = ""
+            doi = info.get("doi", "")
+            ee = info.get("ee", "")
+            pdf_url = ee if ee and ee.endswith(".pdf") else ""
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/doaj.py

@@ -0,0 +1,38 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_doaj(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        data = await fetch_json(f"https://doaj.org/api/search/articles/{query}?pageSize={limit}")
+        if "error" in data:
+            return []
+        results = []
+        for item in data.get("results", []):
+            bibjson = item.get("bibjson", {})
+            identifiers = bibjson.get("identifier", [])
+            doi = ""
+            for ident in identifiers:
+                if ident.get("type") == "doi":
+                    doi = ident.get("id", "")
+                    break
+            links = bibjson.get("link", [])
+            pdf_url = ""
+            for link in links:
+                if link.get("type") == "fulltext":
+                    pdf_url = link.get("url", "")
+                    break
+            authors = bibjson.get("author", [])
+            results.append(normalize_result(
+                title=bibjson.get("title", ""),
+                authors=[a.get("name", "") for a in authors if a.get("name")],
+                year=int(bibjson.get("year", "0000")) if bibjson.get("year") else None,
+                abstract=bibjson.get("abstract", ""),
+                doi=doi,
+                pdf_url=pdf_url,
+                source="DOAJ",
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/providers/latam_repositories.py

@@ -0,0 +1,114 @@
+import re
+from typing import List
+from .base import fetch_json, normalize_result
+
+def _simplify_query(query: str, max_words: int = 4) -> str:
+    stop_words = ["de", "la", "el", "en", "para", "los", "las", "un", "una", "y", "o", "con", "sobre", "su", "como", "estrategia", "mejorar", "estudio", "analisis", "efecto", "influencia"]
+    words = [w for w in re.split(r'\W+', query) if w.lower() not in stop_words and len(w) > 2]
+    return " ".join(words[:max_words])
+
+
+async def _search_vufind(url: str, source: str, query: str, limit: int, headers: dict = None) -> List[dict]:
+    try:
+        params = {"lookfor": query, "type": "AllFields", "limit": limit}
+        data = await fetch_json(url, params=params, headers=headers)
+        if "error" in data:
+            return []
+
+        results = []
+        for record in data.get("records", []):
+            title = record.get("title", "")
+            if isinstance(title, list):
+                title = title[0] if title else ""
+
+            authors_raw = record.get("author", [])
+            if isinstance(authors_raw, str):
+                authors_raw = [authors_raw]
+            authors = [a for a in authors_raw if a]
+
+            year = None
+            pub_date = record.get("publishDate") or record.get("date")
+            if pub_date:
+                try:
+                    year = int(str(pub_date)[:4])
+                except (ValueError, IndexError):
+                    pass
+
+            abstract = record.get("description", "")
+            if isinstance(abstract, list):
+                abstract = abstract[0] if abstract else ""
+
+            doi = record.get("doi", "")
+            if isinstance(doi, list):
+                doi = doi[0] if doi else ""
+
+            pdf_url = ""
+            for url_entry in record.get("urls", []):
+                if isinstance(url_entry, str):
+                    pdf_url = url_entry
+                    break
+                elif isinstance(url_entry, dict):
+                    pdf_url = url_entry.get("url", "")
+                    break
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=source,
+                )
+            )
+        if not results and len(query.split()) > 3:
+            simplified = _simplify_query(query)
+            if simplified and simplified != query:
+                return await _search_vufind(url, source, simplified, limit, headers)
+        
+        return results
+    except Exception:
+        return []
+
+
+async def search_alicia(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    return await _search_vufind(
+        "https://alicia.concytec.gob.pe/vufind/api/v1/search",
+        "ALICIA",
+        query,
+        limit,
+    )
+
+
+async def search_la_referencia(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    headers = {
+        'Accept': 'application/json',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Referer': 'https://www.lareferencia.info/'
+    }
+    return await _search_vufind(
+        "https://www.lareferencia.info/vufind/api/v1/search",
+        "La Referencia",
+        query,
+        limit,
+        headers=headers
+    )
+
+
+async def search_bDTD(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    return await _search_vufind(
+        "https://bdtd.ibict.br/vufind/api/v1/search",
+        "BDTD",
+        query,
+        limit,
+    )
+
+
+async def search_rraae(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    return await _search_vufind(
+        "https://rraae.cedia.edu.ec/vufind/api/v1/search",
+        "RRAAE",
+        query,
+        limit,
+    )

backend/providers/openaire.py

@@ -0,0 +1,36 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_openaire(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        data = await fetch_json(f"http://api.openaire.eu/search/publications?keywords={query}&format=json&size={limit}")
+        if "error" in data:
+            return []
+        results_data = data.get("response", {}).get("results", {}).get("result", [])
+        if isinstance(results_data, dict):
+            results_data = [results_data]
+        results = []
+        for item in results_data:
+            entity = item.get("oaf:entity", {})
+            result = entity.get("oaf:result", {})
+            pid_list = result.get("pid", [])
+            if isinstance(pid_list, dict):
+                pid_list = [pid_list]
+            doi = ""
+            for pid in pid_list:
+                if pid.get("@class") == "pid" and "doi" in str(pid.get("classname", "")):
+                    doi = pid.get("$", "")
+                    break
+            results.append(normalize_result(
+                title=result.get("title", ""),
+                authors=[result.get("creator", {}).get("$", "")] if result.get("creator") else [],
+                year=int(result.get("dateofacceptance", "0000")[:4]) if result.get("dateofacceptance") else None,
+                abstract=result.get("description", ""),
+                doi=doi,
+                source="OpenAIRE",
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/providers/openalex.py

@@ -0,0 +1,70 @@
+from typing import List
+from .base import fetch_json, normalize_result
+
+SOURCE = "OpenAlex"
+API_BASE = "https://api.openalex.org/works"
+
+
+def _decode_abstract_inverted_index(index: dict) -> str:
+    if not index:
+        return ""
+    word_positions = []
+    for word, positions in index.items():
+        for pos in positions:
+            word_positions.append((pos, word))
+    word_positions.sort(key=lambda x: x[0])
+    return " ".join(w for _, w in word_positions)
+
+
+async def search_openalex(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        params = {"search": query, "per-page": limit}
+        data = await fetch_json(API_BASE, params=params)
+        if "error" in data:
+            return []
+
+        results = []
+        for work in data.get("results", []):
+            title = work.get("title", "")
+            year = work.get("publication_year")
+
+            authors = []
+            university = ""
+            for authorship in work.get("authorships", []):
+                name = authorship.get("author", {}).get("display_name", "")
+                if name:
+                    authors.append(name)
+                inst = authorship.get("institutions", [])
+                if inst and not university:
+                    university = inst[0].get("display_name", "")
+
+            abstract = _decode_abstract_inverted_index(
+                work.get("abstract_inverted_index")
+            )
+
+            doi = (work.get("doi") or "").replace("https://doi.org/", "")
+
+            pdf_url = ""
+            for loc in work.get("locations", []):
+                if loc.get("pdf_url"):
+                    pdf_url = loc["pdf_url"]
+                    break
+
+            citation_count = work.get("cited_by_count")
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                    university=university,
+                    citation_count=citation_count,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/pubmed.py

@@ -0,0 +1,85 @@
+import asyncio
+from typing import List
+from .base import fetch_json, normalize_result
+
+SOURCE = "PubMed"
+ESEARCH = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+ESUMMARY = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi"
+
+
+async def _fetch_summaries(pmids: List[str]) -> dict:
+    if not pmids:
+        return {}
+    ids_str = ",".join(pmids)
+    data = await fetch_json(ESUMMARY, params={"db": "pubmed", "id": ids_str, "retmode": "json"})
+    if "error" in data:
+        return {}
+    return data.get("result", {})
+
+
+async def search_pubmed(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        search_data = await fetch_json(
+            ESEARCH,
+            params={"db": "pubmed", "term": query, "retmode": "json", "retmax": limit},
+        )
+        if "error" in search_data:
+            return []
+
+        pmids = search_data.get("esearchresult", {}).get("idlist", [])
+        if not pmids:
+            return []
+
+        summaries = await _fetch_summaries(pmids)
+
+        results = []
+        for pmid in pmids:
+            info = summaries.get(pmid, {})
+            if not info:
+                continue
+
+            title = info.get("title", "")
+
+            authors = [
+                a.get("name", "") for a in info.get("authors", []) if a.get("name")
+            ]
+
+            pubdate = info.get("pubdate", "")
+            year = None
+            if pubdate:
+                try:
+                    year = int(pubdate.split()[0][:4])
+                except (ValueError, IndexError):
+                    pass
+
+            doi = ""
+            for aid in info.get("articleids", []):
+                if aid.get("idtype") == "doi":
+                    doi = aid.get("value", "")
+                    break
+
+            abstract = ""
+            # ESummary doesn't always include abstract; fetch via EFetch if needed
+            # For now leave blank to keep single-request
+
+            pdf_url = ""
+            eloc = info.get("elocationid", "")
+            if eloc:
+                for eid in eloc if isinstance(eloc, list) else [eloc]:
+                    if isinstance(eid, dict) and eid.get("elocationidtype") == "doi":
+                        doi = doi or eid.get("elocationid", "").replace("doi: ", "")
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/redalyc.py

@@ -0,0 +1,28 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_redalyc(query: str, limit: int = 30, **kwargs) -> List[dict]:
+    try:
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+        data = await fetch_json(
+            f"https://www.redalyc.org/busquedaArticuloFiltros.oa?q={query}&numItems={limit}",
+            headers=headers
+        )
+        if "error" in data:
+            return []
+        articles = data if isinstance(data, list) else data.get("articles", [])
+        results = []
+        for a in articles[:limit]:
+            results.append(normalize_result(
+                title=a.get("titulo", "") or a.get("title", ""),
+                authors=[a.get("autores", "")] if a.get("autores") else [],
+                year=int(a.get("anio", "0")) if a.get("anio") else None,
+                abstract=a.get("resumen", "") or a.get("abstract", ""),
+                pdf_url=a.get("urlPdf", "") or a.get("pdfUrl", ""),
+                source="Redalyc",
+            ))
+        return results
+    except Exception:
+        return []

backend/providers/scopus.py

@@ -0,0 +1,33 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_scopus(query: str, limit: int = 25, api_key: str = "", **kwargs) -> List[dict]:
+    if not api_key:
+        return []
+    try:
+        headers = {"X-ELS-APIKey": api_key, "Accept": "application/json"}
+        params = {"query": f"TITLE-ABS-KEY({query})", "count": limit, "sort": "relevance"}
+        data = await fetch_json("https://api.elsevier.com/content/search/scopus", params=params, headers=headers)
+        if "error" in data:
+            return []
+        entries = data.get("search-results", {}).get("entry", [])
+        results = []
+        for e in entries:
+            if e.get("error"):
+                continue
+            results.append(normalize_result(
+                title=e.get("dc:title", ""),
+                authors=[a.strip() for a in (e.get("dc:creator", "") or "").split(";") if a.strip()],
+                year=int(e.get("prism:coverDate", "0000")[:4]) if e.get("prism:coverDate") else None,
+                abstract=e.get("dc:description", ""),
+                doi=e.get("prism:doi", ""),
+                pdf_url="",
+                source="Scopus",
+                university=e.get("affilname", ""),
+                citation_count=int(e.get("citedby-count", 0)) if e.get("citedby-count") else None,
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/providers/semantic_scholar.py

@@ -0,0 +1,56 @@
+import os
+from typing import List
+from .base import fetch_json, normalize_result
+
+SOURCE = "Semantic Scholar"
+API_BASE = "https://api.semanticscholar.org/graph/v1/paper/search"
+FIELDS = "title,authors,year,abstract,openAccessPdf,url,venue,externalIds"
+
+
+async def search_semantic_scholar(query: str, limit: int = 50, **kwargs) -> List[dict]:
+    try:
+        headers = {}
+        api_key = os.environ.get("SEMANTIC_SCHOLAR_API_KEY", "")
+        if api_key:
+            headers["x-api-key"] = api_key
+
+        params = {
+            "query": query,
+            "limit": limit,
+            "fields": FIELDS,
+        }
+        data = await fetch_json(API_BASE, params=params, headers=headers)
+        if "error" in data:
+            return []
+
+        results = []
+        for paper in data.get("data", []):
+            title = paper.get("title", "")
+            year = paper.get("year")
+
+            authors = [a.get("name", "") for a in paper.get("authors", [])]
+
+            abstract = paper.get("abstract", "")
+
+            ext_ids = paper.get("externalIds", {}) or {}
+            doi = ext_ids.get("DOI", "")
+
+            pdf_url = ""
+            oap = paper.get("openAccessPdf")
+            if oap and isinstance(oap, dict):
+                pdf_url = oap.get("url", "")
+
+            results.append(
+                normalize_result(
+                    title=title,
+                    authors=authors,
+                    year=year,
+                    abstract=abstract,
+                    doi=doi,
+                    pdf_url=pdf_url,
+                    source=SOURCE,
+                )
+            )
+        return results
+    except Exception:
+        return []

backend/providers/serpapi.py

@@ -0,0 +1,36 @@
+from typing import List
+import re
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_serpapi(query: str, limit: int = 20, api_key: str = "", **kwargs) -> List[dict]:
+    if not api_key:
+        return []
+    try:
+        params = {"engine": "google_scholar", "q": query, "num": min(limit, 20), "api_key": api_key}
+        data = await fetch_json("https://serpapi.com/search.json", params=params)
+        if "error" in data:
+            return []
+        results = []
+        for item in data.get("organic_results", []):
+            title = item.get("title", "")
+            snippet = item.get("snippet", "")
+            link = item.get("link", "")
+            year = None
+            if item.get("publication_info", {}).get("summary"):
+                year_match = item["publication_info"]["summary"]
+                y = re.search(r'(\d{4})', year_match)
+                if y:
+                    year = int(y.group(1))
+            results.append(normalize_result(
+                title=title,
+                authors=[],
+                year=year,
+                abstract=snippet,
+                pdf_url=link if "pdf" in link.lower() else "",
+                source="Google Scholar",
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/providers/sources.py

@@ -0,0 +1,45 @@
+SOURCE_GROUPS = {
+    "all": ["openalex", "semantic", "pubmed", "arxiv", "crossref", "dblp", "alicia", "lareferencia", "bdtd", "rraae",
+            "scopus", "zenodo", "openaire", "doaj", "core", "redalyc", "serpapi"],
+    "latam": ["alicia", "lareferencia", "bdtd", "rraae", "redalyc"],
+    "global": ["openalex", "semantic", "pubmed", "arxiv", "crossref", "scopus", "zenodo", "openaire", "doaj", "core"],
+    "tesis": ["alicia", "lareferencia", "bdtd", "rraae"],
+    "iberoamerica": ["alicia", "lareferencia", "bdtd", "rraae", "redalyc"],
+    "peru": ["alicia"],
+    "brasil": ["bdtd"],
+    "ecuador": ["rraae"],
+    "ai_ml": ["arxiv", "dblp"],
+    "free": ["openalex", "semantic", "pubmed", "arxiv", "crossref", "dblp", "alicia", "lareferencia", "bdtd", "rraae",
+             "zenodo", "openaire", "doaj", "redalyc"],
+    "premium": ["scopus", "core", "serpapi"],
+}
+
+SOURCE_ALIASES = {
+    "semanticscholar": "semantic",
+    "semantic_scholar": "semantic",
+    "semantic-scholar": "semantic",
+    "openalex": "openalex",
+    "la_referencia": "lareferencia",
+    "la-referencia": "lareferencia",
+    "bdtdbr": "bdtd",
+    "bdtd-br": "bdtd",
+    "rraae_ecuador": "rraae",
+    "rraae-ecuador": "rraae",
+    "recolecta": "lareferencia",
+    "kimuk": "lareferencia",
+    "timbo": "lareferencia",
+    "redicces": "lareferencia",
+    "openaire": "openaire",
+    "open-air": "openaire",
+    "doaj": "doaj",
+    "directoryofopenaccessjournals": "doaj",
+    "zenodo": "zenodo",
+    "core.ac.uk": "core",
+    "coreac": "core",
+    "redalyc": "redalyc",
+    "redalycorg": "redalyc",
+    "serpapi": "serpapi",
+    "google_scholar": "serpapi",
+    "google-scholar": "serpapi",
+    "scopus": "scopus",
+}

backend/providers/zenodo.py

@@ -0,0 +1,27 @@
+from typing import List
+import httpx
+from .base import fetch_json, normalize_result
+
+
+async def search_zenodo(query: str, limit: int = 25, **kwargs) -> List[dict]:
+    try:
+        data = await fetch_json(f"https://zenodo.org/api/records?q={query}&size={limit}&type=publication")
+        if "error" in data:
+            return []
+        hits = data.get("hits", {}).get("hits", [])
+        results = []
+        for h in hits:
+            md = h.get("metadata", {})
+            creators = md.get("creators", [])
+            results.append(normalize_result(
+                title=md.get("title", ""),
+                authors=[c.get("name", "") for c in creators if c.get("name")],
+                year=int(md.get("publication_date", "0000")[:4]) if md.get("publication_date") else None,
+                abstract=md.get("description", ""),
+                doi=h.get("doi", ""),
+                pdf_url=h.get("links", {}).get("pdf", "") if h.get("links") else "",
+                source="Zenodo",
+            ))
+        return results[:limit]
+    except Exception:
+        return []

backend/smart_fusion.py

@@ -0,0 +1,119 @@
+"""
+Smart Fusion - Document relevance scoring and ranking
+Fiel al app original Next.js
+"""
+
+import re
+from typing import List, Dict, Any
+
+# Default weights (from original)
+DEFAULT_SESSION_WEIGHT = 1000
+DEFAULT_PREVIOUS_QUERY_WEIGHT = 100
+DEFAULT_TITLE_MATCH_WEIGHT = 50
+DEFAULT_SNIPPET_MATCH_WEIGHT = 10
+DEFAULT_MIN_THRESHOLD = 30
+DEFAULT_TOP_N = 150
+
+
+def normalize_text(text: str) -> str:
+    """Remove diacritics for cross-language matching."""
+    text = text.lower()
+    accents = {'á':'a','é':'e','í':'i','ó':'o','ú':'u','ñ':'n','Á':'A','É':'E','Í':'I','Ó':'O','Ú':'U','Ñ':'N'}
+    return re.sub(r'[áéíóúñÁÉÍÓÚÑ]', lambda m: accents.get(m.group(), m.group()), text)
+
+
+def get_tokens(text: str) -> set:
+    """Extract meaningful tokens from text."""
+    text = normalize_text(text)
+    tokens = set(re.findall(r'[a-záéíóúñ]{4,}', text))
+    stopwords = {'para', 'como', 'más', 'pero', 'desde', 'hasta', 'sobre', 'entre', 'the', 'and', 'with', 'from', 'that', 'this', 'have', 'been', 'were', 'they'}
+    return tokens - stopwords
+
+
+def score_document(doc: dict, query: str, is_session: bool = True,
+                   session_weight: int = DEFAULT_SESSION_WEIGHT,
+                   previous_query_weight: int = DEFAULT_PREVIOUS_QUERY_WEIGHT,
+                   title_weight: int = DEFAULT_TITLE_MATCH_WEIGHT,
+                   snippet_weight: int = DEFAULT_SNIPPET_MATCH_WEIGHT) -> int:
+    """Score a document against a query."""
+    score = 0
+    
+    if is_session:
+        score += session_weight
+    
+    # Title token matching
+    title_tokens = get_tokens(doc.get("title", ""))
+    query_tokens = get_tokens(query)
+    title_matches = len(title_tokens & query_tokens)
+    score += title_matches * title_weight
+    
+    # Snippet matching
+    snippet_tokens = get_tokens(doc.get("snippet", "") or doc.get("abstract", ""))
+    snippet_matches = len(snippet_tokens & query_tokens)
+    score += snippet_matches * snippet_weight
+    
+    # Query match in stored queries
+    stored_queries = doc.get("metadata", {}).get("queries", []) if doc.get("metadata") else []
+    for sq in stored_queries:
+        if query.lower() in sq.lower():
+            score += previous_query_weight
+            break
+    
+    # Non-session docs need minimum matches
+    if not is_session and title_matches < 1 and snippet_matches < 4:
+        score = 0
+    
+    return score
+
+
+def smart_fusion_rank(docs: list, query: str, weights: dict = None) -> list:
+    """Rank and filter documents using smart fusion scoring."""
+    w = weights or {}
+    
+    scored = []
+    for doc in docs:
+        is_session = doc.get("_isSession", True)
+        score = score_document(
+            doc, query, is_session,
+            session_weight=w.get("sessionWeight", DEFAULT_SESSION_WEIGHT),
+            previous_query_weight=w.get("previousQueryWeight", DEFAULT_PREVIOUS_QUERY_WEIGHT),
+            title_weight=w.get("titleMatchWeight", DEFAULT_TITLE_MATCH_WEIGHT),
+            snippet_weight=w.get("snippetMatchWeight", DEFAULT_SNIPPET_MATCH_WEIGHT)
+        )
+        doc["smartFusionScore"] = score
+        scored.append(doc)
+    
+    # Filter by threshold
+    threshold = w.get("minThreshold", DEFAULT_MIN_THRESHOLD)
+    filtered = [d for d in scored if d["smartFusionScore"] >= threshold or d.get("_isSession")]
+    
+    # Sort by score descending
+    filtered.sort(key=lambda x: x["smartFusionScore"], reverse=True)
+    
+    # Cap at top N
+    top_n = w.get("topN", DEFAULT_TOP_N)
+    return filtered[:top_n]
+
+
+def merge_with_memory(new_docs: list, stored_records: list, query: str) -> list:
+    """Merge new search results with existing memory records."""
+    record_map = {r.get("title", "").lower().strip(): r for r in stored_records}
+    title_map = {r.get("title", "").lower().strip(): r for r in stored_records}
+    
+    merged = list(stored_records)
+    
+    for doc in new_docs:
+        title_key = doc.get("title", "").lower().strip()
+        if title_key in title_map:
+            # Update existing record
+            existing = title_map[title_key]
+            if doc.get("snippet") and not existing.get("snippet"):
+                existing["snippet"] = doc["snippet"]
+            if doc.get("pdfUrl") and not existing.get("pdfUrl"):
+                existing["pdfUrl"] = doc["pdfUrl"]
+        else:
+            # Add new record
+            merged.append(doc)
+            title_map[title_key] = doc
+    
+    return merged

backend/synthesis.py

@@ -0,0 +1,923 @@
+"""
+Synthesis Engine - AI-powered research synthesis pipeline
+Enhanced with hierarchical synthesis, GRADE classification, gap detection, and rescue search.
+Faithful to the original Next.js research-agent prompts.
+"""
+
+import json
+import httpx
+import re
+from typing import Dict, Any, List, Optional
+from .prompts.profiles import AGENT_PROFILES
+from .prompts.synthesis import (
+    MASTER_SYNTHESIS_PROMPT,
+    WRITING_PROMPT,
+    VALIDATION_PROMPT,
+    AUDIT_PROMPT,
+    ARA_PROMPT,
+)
+from .prompts.planning import SEARCH_PLANNING_PROMPT, GAP_DETECTION_PROMPT
+from .utils import robust_json_parse, extract_research_plan
+
+
+# Provider configs
+PROVIDERS = {
+    "groq": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "env_key": "GROQ_API_KEY",
+        "models": [
+            "llama-3.3-70b-versatile",
+            "llama-3.1-8b-instant",
+            "deepseek-r1-distill-llama-70b",
+            "mixtral-8x7b-32768",
+            "gemma2-9b-it",
+            "llama3-70b-8192",
+            "llama3-8b-8192",
+            "llama-guard-3-8b",
+        ],
+    },
+    "openrouter": {
+        "base_url": "https://openrouter.ai/api/v1",
+        "env_key": "OPENROUTER_API_KEY",
+        "models": [
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "google/gemma-4-26b-a4b-it:free",
+            "google/gemma-4-31b-it:free",
+            "nvidia/nemotron-3-super-120b-a12b:free",
+            "deepseek/deepseek-v4-flash:free",
+            "deepseek/deepseek-r1-0528:free",
+            "qwen/qwen3-next-80b-a3b-instruct:free",
+            "minimax/minimax-m2.5:free",
+            "openai/gpt-oss-120b:free",
+            "openai/gpt-oss-20b:free",
+            "arcee-ai/trinity-large-thinking:free",
+            "nousresearch/hermes-3-llama-3.1-405b:free",
+            "google/gemma-3-27b-it:free",
+            "google/gemma-3-12b-it:free",
+            "qwen/qwen3-coder:free",
+            "stepfun/step-3.5-flash:free",
+            "z-ai/glm-4.5-air:free",
+            "anthropic/claude-sonnet-4.5",
+            "anthropic/claude-haiku-4.5",
+            "openai/gpt-5.4",
+            "openai/gpt-5.4-mini",
+            "openai/gpt-5",
+            "deepseek/deepseek-v4-pro",
+            "deepseek/deepseek-v3.2",
+            "qwen/qwen3.6-flash",
+            "qwen/qwen3.5-plus-20260420",
+            "mistralai/mistral-small-2603",
+            "mistralai/mistral-medium-3-5",
+        ],
+    },
+    "mistral": {
+        "base_url": "https://api.mistral.ai/v1",
+        "env_key": "MISTRAL_API_KEY",
+        "models": [
+            "mistral-small-2506",
+            "mistral-small-2603",
+            "mistral-medium-2508",
+            "mistral-medium-3-5",
+            "mistral-large-2512",
+            "magistral-medium-2509",
+            "magistral-small-2509",
+            "ministral-3b-2512",
+            "ministral-8b-2512",
+            "ministral-14b-2512",
+            "codestral-2508",
+            "devstral-2512",
+            "open-mistral-nemo",
+        ],
+    },
+    "gemini": {
+        "base_url": "https://generativelanguage.googleapis.com/v1beta/openai",
+        "env_key": "GEMINI_API_KEY",
+        "models": [
+            "gemini-2.5-flash",
+            "gemini-2.5-pro",
+            "gemini-2.0-flash",
+            "gemini-2.0-flash-lite",
+            "gemini-3-flash-preview",
+            "gemini-3-pro-preview",
+            "gemini-3.1-flash-lite",
+            "gemma-4-26b-a4b-it",
+            "gemma-4-31b-it",
+        ],
+    },
+    "deepseek": {
+        "base_url": "https://api.deepseek.com/v1",
+        "env_key": "DEEPSEEK_API_KEY",
+        "models": [
+            "deepseek-chat",
+            "deepseek-reasoner",
+            "deepseek-v4-flash",
+            "deepseek-v4-pro",
+        ],
+    },
+    "nebius": {
+        "base_url": "https://api.tokenfactory.nebius.com/v1",
+        "env_key": "NEBIUS_API_KEY",
+        "models": [
+            "deepseek-ai/DeepSeek-V3.2",
+            "deepseek-ai/DeepSeek-V4-Pro",
+            "meta-llama/Llama-3.3-70B-Instruct",
+            "Qwen/Qwen3-235B-A22B-Instruct-2507",
+            "Qwen/Qwen3-32B",
+            "Qwen/Qwen3.5-397B-A17B",
+            "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+            "google/gemma-3-27b-it",
+            "NousResearch/Hermes-4-405B",
+            "moonshotai/Kimi-K2.5",
+            "MiniMaxAI/MiniMax-M2.5",
+        ],
+    },
+    "azure": {
+        "base_url": "https://letxinet.openai.azure.com/openai/deployments",
+        "env_key": "AZURE_API_KEY",
+        "models": [
+            "gpt-4o-mini",
+            "gpt-4o",
+            "o3-mini",
+            "o4-mini",
+            "gpt-4.1-mini",
+        ],
+    },
+    "huggingface": {
+        "base_url": "https://api-inference.huggingface.co/v1",
+        "env_key": "HF_TOKEN",
+        "models": [
+            "deepseek-ai/DeepSeek-V3.2",
+            "deepseek-ai/DeepSeek-R1",
+            "meta-llama/Llama-3.3-70B-Instruct",
+            "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+            "Qwen/Qwen3-235B-A22B-Instruct-2507",
+            "Qwen/Qwen3-Next-80B-A3B-Instruct",
+            "google/gemma-3-27b-it",
+            "MiniMaxAI/MiniMax-M2.1",
+            "moonshotai/Kimi-K2.5",
+        ],
+    },
+}
+
+GRADE_LEVELS = {
+    "1a": {"label": "Meta-análisis", "weight": 10, "desc": "Revisión sistemática cuantitativa con pooling estadístico"},
+    "1b": {"label": "Revisión sistemática", "weight": 9, "desc": "Búsqueda exhaustiva y replicable con criterios de inclusión/exclusión"},
+    "2a": {"label": "Ensayo controlado aleatorizado", "weight": 8, "desc": "Experimento con aleatorización y grupo control"},
+    "2b": {"label": "Ensayo cuasi-experimental", "weight": 7, "desc": "Experimento sin aleatorización completa"},
+    "3a": {"label": "Estudio de cohorte", "weight": 6, "desc": "Seguimiento longitudinal de grupos expuestos/no expuestos"},
+    "3b": {"label": "Estudio caso-control", "weight": 5, "desc": "Comparación retrospectiva de casos y controles"},
+    "4": {"label": "Corte transversal", "weight": 4, "desc": "Medición en un punto único del tiempo"},
+    "5": {"label": "Serie de casos", "weight": 3, "desc": "Descripción de grupos sin grupo control"},
+    "6": {"label": "Opinión de expertos", "weight": 2, "desc": "Juicio clínico o consenso de especialistas"},
+}
+
+OXFORD_LEVELS = {
+    "1a": {"label": "RS de ensayos aleatorizados", "weight": 10, "desc": "Revisión Sistemática de RCTs"},
+    "1b": {"label": "Ensayo controlado aleatorizado", "weight": 9, "desc": "RCT individual con intervalo de confianza estrecho"},
+    "1c": {"label": "Todo o nada", "weight": 8, "desc": "Todos los pacientes murieron antes que estuviera disponible el tratamiento, y ahora algunos sobreviven; o cuando algunos pacientes morían antes de que estuviera disponible el tratamiento, y ahora ninguno muere"},
+    "2a": {"label": "RS de estudios de cohorte", "weight": 7, "desc": "Revisión Sistemática de estudios de cohorte"},
+    "2b": {"label": "Estudio de cohorte", "weight": 6, "desc": "Estudio de cohorte individual o RCT de baja calidad"},
+    "2c": {"label": "Investigación de resultados", "weight": 5, "desc": "Investigación de resultados, estudios ecológicos"},
+    "3a": {"label": "RS de estudios caso-control", "weight": 4, "desc": "Revisión Sistemática de estudios caso-control"},
+    "3b": {"label": "Estudio caso-control", "weight": 3, "desc": "Estudio caso-control individual"},
+    "4": {"label": "Serie de casos", "weight": 2, "desc": "Serie de casos, o estudios de cohorte o de caso-control de baja calidad"},
+    "5": {"label": "Opinión de expertos", "weight": 1, "desc": "Opinión de expertos sin evaluación crítica explícita"},
+}
+
+ORIGINAL_GRADE_LEVELS = {
+    "ALTA": {
+        "label": "ALTA",
+        "weight": 4,
+        "desc": "Meta-analisis, revisiones sistematicas o ensayos controlados aleatorizados.",
+    },
+    "MODERADA": {
+        "label": "MODERADA",
+        "weight": 3,
+        "desc": "Ensayos clinicos, estudios experimentales controlados, cohortes o casos y controles bien disenados.",
+    },
+    "BAJA": {
+        "label": "BAJA",
+        "weight": 2,
+        "desc": "Estudios observacionales, descriptivos o transversales.",
+    },
+    "MUY BAJA": {
+        "label": "MUY BAJA",
+        "weight": 1,
+        "desc": "Reportes de caso, opiniones, editoriales o evidencia no revisada.",
+    },
+}
+
+ORIGINAL_GRADE_ALIASES = {
+    "ALTO": "ALTA",
+    "HIGH": "ALTA",
+    "ALTA": "ALTA",
+    "MODERADO": "MODERADA",
+    "MODERADA": "MODERADA",
+    "MODERATE": "MODERADA",
+    "MEDIUM": "MODERADA",
+    "BAJO": "BAJA",
+    "BAJA": "BAJA",
+    "LOW": "BAJA",
+    "MUY BAJO": "MUY BAJA",
+    "MUY BAJA": "MUY BAJA",
+    "VERY LOW": "MUY BAJA",
+    "VERY_LOW": "MUY BAJA",
+}
+
+
+def normalize_original_grade_level(level: Any) -> str:
+    """Normalize original beta GRADE labels to ALTA/MODERADA/BAJA/MUY BAJA."""
+    raw = str(level or "").strip().upper().replace("_", " ")
+    raw = re.sub(r"\s+", " ", raw)
+    return ORIGINAL_GRADE_ALIASES.get(raw, "BAJA")
+
+
+def classify_grade_original(study_type: str) -> str:
+    """Fast fallback that maps study design keywords to the original beta GRADE labels."""
+    numeric = classify_grade(study_type)
+    if numeric in {"1a", "1b", "2a"}:
+        return "ALTA"
+    if numeric in {"2b", "3a", "3b"}:
+        return "MODERADA"
+    if numeric in {"4", "5"}:
+        return "BAJA"
+    return "MUY BAJA"
+
+
+def def_document_has_grade(doc: Dict[str, Any]) -> bool:
+    return bool(doc.get("grade_level") or doc.get("evidenceLevel"))
+
+
+def classify_grade_oxford(study_type: str) -> str:
+    """Classify a study type string into Oxford CEBM evidence level."""
+    t = study_type.lower()
+    if "revisión sistemática" in t and ("aleatorizado" in t or "rct" in t):
+        return "1a"
+    if "meta-análisis" in t or "meta-analisis" in t or "meta analysis" in t:
+        return "1a"
+    if "ensayo" in t and ("aleatorizado" in t or "randomized" in t or "rct" in t):
+        return "1b"
+    if "revisión sistemática" in t and ("cohorte" in t or "cohort" in t):
+        return "2a"
+    if "cohorte" in t or "cohort" in t or "longitudinal" in t:
+        return "2b"
+    if "ecológico" in t or "ecological" in t:
+        return "2c"
+    if "revisión sistemática" in t and ("caso-control" in t or "case-control" in t):
+        return "3a"
+    if "caso-control" in t or "case-control" in t:
+        return "3b"
+    if "serie de casos" in t or "case series" in t or "transversal" in t or "cross-sectional" in t or "encuesta" in t:
+        return "4"
+    if "experto" in t or "opinión" in t or "expert" in t:
+        return "5"
+    return "4"  # Default
+
+def classify_grade(study_type: str) -> str:
+    """Classify a study type string into GRADE evidence level."""
+    t = study_type.lower()
+    if "meta-análisis" in t or "meta-analisis" in t or "meta analysis" in t:
+        return "1a"
+    if "revisión sistemática" in t or "revision sistematica" in t or "systematic review" in t:
+        return "1b"
+    if "ensayo" in t and ("aleatorizado" in t or "randomized" in t or "rct" in t):
+        return "2a"
+    if "ensayo" in t or "quasi" in t or "quasi-experimental" in t:
+        return "2b"
+    if "cohorte" in t or "cohort" in t or "longitudinal" in t:
+        return "3a"
+    if "caso-control" in t or "case-control" in t:
+        return "3b"
+    if "transversal" in t or "cross-sectional" in t or "encuesta" in t:
+        return "4"
+    if "serie de casos" in t or "case series" in t:
+        return "5"
+    if "experto" in t or "opinión" in t or "expert" in t:
+        return "6"
+    return "4"
+
+
+def grade_label(level: str) -> str:
+    entry = GRADE_LEVELS.get(level, GRADE_LEVELS["4"])
+    return f"[{level.upper()}] {entry['label']}"
+
+
+def grade_weight(level: str) -> int:
+    return GRADE_LEVELS.get(level, GRADE_LEVELS["4"])["weight"]
+
+
+class SynthesisEngine:
+    def __init__(self, provider: str = "mistral", model: str = None, api_key: str = None,
+                 search_model: str = None, translation_model: str = None):
+        config = PROVIDERS.get(provider, PROVIDERS["mistral"])
+        self.base_url = config["base_url"]
+        self.model = model or "mistral-small-2506"
+        self.search_model = search_model or self.model
+        self.translation_model = translation_model or self.model
+        self.api_key = api_key or ""
+        self.client = httpx.AsyncClient(timeout=180.0)
+
+    async def _call_llm(self, system_prompt: str, user_prompt: str, temperature: float = 0.0, role: str = "synthesis") -> str:
+        # Select model based on role
+        model_map = {
+            "search": self.search_model,
+            "synthesis": self.model,
+            "translation": self.translation_model,
+        }
+        active_model = model_map.get(role, self.model)
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": active_model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            "temperature": temperature,
+            "max_tokens": 8192,
+        }
+        # Clamp max_tokens based on model capabilities
+        MODEL_MAX_TOKENS = {
+            "mistral": 8192, "groq": 32768, "openrouter": 8192,
+            "gemini": 65536, "deepseek": 8192, "nebius": 8192,
+            "azure": 16384, "huggingface": 8192,
+        }
+        provider_key = self.base_url.split("//")[-1].split(".")[0] if "//" in self.base_url else "default"
+        max_allowed = MODEL_MAX_TOKENS.get(provider_key, 8192)
+        # Special cap for DeepSeek models
+        if "deepseek" in active_model.lower():
+            max_allowed = min(max_allowed, 8192)
+        requested_tokens = min(payload.get("max_tokens", 8192), max_allowed)
+        payload["max_tokens"] = requested_tokens
+        try:
+            r = await self.client.post(
+                f"{self.base_url}/chat/completions", json=payload, headers=headers
+            )
+            r.raise_for_status()
+            return r.json()["choices"][0]["message"]["content"]
+        except Exception as e:
+            raise RuntimeError(f"Error calling LLM: {str(e)}") from e
+
+    def _parse_json(self, text: str) -> dict:
+        result = robust_json_parse(text)
+        if result is not None:
+            return result
+        return {"error": "Could not parse JSON", "raw": text[:500]}
+
+    # ── Core pipeline phases (faithful to original prompts) ──────────────
+
+    async def orchestrate(self, query: str) -> dict:
+        """Phase 1: Analyze query and extract variables."""
+        system = "Eres un orquestador de investigación académica. Analiza la consulta y extrae variables."
+        user = f"""Analiza esta consulta de investigación y extrae:
+1. Sujeto de estudio
+2. Variable Independiente (V.I.) con dimensiones
+3. Variable Dependiente (V.D.) con dimensiones
+4. Tipo de estudio sugerido
+5. País/Contexto geográfico
+6. Keywords en español e inglés
+
+CONSULTA: "{query}"
+
+RESPONDE EN JSON:
+{{
+  "subject": "...",
+  "variable_independiente": {{"nombre": "...", "dimensiones": [...], "indicadores": [...]}},
+  "variable_dependiente": {{"nombre": "...", "dimensiones": [...], "indicadores": [...]}},
+  "tipo_estudio": "...",
+  "country": "...",
+  "keywords_es": [...],
+  "keywords_en": [...]
+}}"""
+        response = await self._call_llm(system, user, role="search")
+        return self._parse_json(response)
+
+    async def plan_search(self, query: str, profile: str = "general", orchestrator_ctx: dict = None) -> dict:
+        """Phase 2: Plan search queries."""
+        profile_data = AGENT_PROFILES.get(profile, AGENT_PROFILES["general"])
+        system = f"Eres un estratega de búsqueda académica. {profile_data['title']}."
+        user = SEARCH_PLANNING_PROMPT.format(query=query, agent_role=profile)
+        response = await self._call_llm(system, user, role="search")
+        return self._parse_json(response)
+
+    async def generate_master_plan(
+        self,
+        query: str,
+        docs_context: str,
+        profile: str = "general",
+        template_structure: str = None,
+        geo_context: str = "Automático",
+    ) -> dict:
+        """Phase 3: Generate master synthesis plan (linear path)."""
+        profile_data = AGENT_PROFILES.get(profile, AGENT_PROFILES["general"])
+        system = f"Eres un {profile_data['title']}. Genera un plan maestro de investigación. Contexto Geográfico: {geo_context}"
+        user = MASTER_SYNTHESIS_PROMPT.format(
+            query=query,
+            agent_title=profile_data["title"],
+            agent_title_upper=profile_data["title"].upper(),
+            profile_instruction=profile_data["instruction"],
+            template_structure=template_structure or "Genera la estructura que consideres adecuada.",
+        )
+        user += f"\n\nCONTEXTO GEOGRÁFICO ASIGNADO: {geo_context}"
+        user += f"\n\nDOCUMENTOS ENCONTRADOS:\n{docs_context}"
+        response = await self._call_llm(system, user, temperature=0.0, role="synthesis")
+        return extract_research_plan(response)
+
+    async def write_section(self, section_name: str, section_prompt: str, context_text: str, geo_context: str = "Automático") -> str:
+        """Phase 4: Write individual section content."""
+        system = f"Eres un Redactor Científico Experto. Contexto Geográfico a priorizar: {geo_context}"
+        user = WRITING_PROMPT.replace("{section}", section_name).replace("{section_prompt}", section_prompt).replace("{context_text}", context_text)
+        user += f"\n\nCONTEXTO GEOGRÁFICO A PRIORIZAR: {geo_context}"
+        return await self._call_llm(system, user, temperature=0.0, role="synthesis")
+
+    async def validate_citations(self, docs_context: str, content: str) -> dict:
+        """Phase 5a: Validate citations."""
+        system = "Eres un Agente de Validación Bibliográfica ESTRICTO."
+        user = VALIDATION_PROMPT.replace("{docs_context}", docs_context).replace("{content_to_validate}", content)
+        response = await self._call_llm(system, user, temperature=0.0, role="synthesis")
+        return self._parse_json(response)
+
+    async def audit_content(self, docs_context: str, content: str) -> dict:
+        """Phase 5b: Audit content quality."""
+        system = "Eres un Auditor Técnico de Calidad Académica."
+        user = AUDIT_PROMPT.replace("{docs_context}", docs_context).replace("{content_to_audit}", content)
+        response = await self._call_llm(system, user, temperature=0.0, role="synthesis")
+        return self._parse_json(response)
+
+    async def refine_section(self, section_content: str, findings: str) -> str:
+        """Phase 5c: Refine section with ARA+."""
+        system = "Eres el Agente de Refinamiento Académico Avanzado (ARA+)."
+        user = ARA_PROMPT.replace("{section_content}", section_content).replace("{section_findings}", findings)
+        return await self._call_llm(system, user, temperature=0.0, role="synthesis")
+
+    async def detect_gaps(self, query: str, plan_sections: list) -> dict:
+        """Detect gaps in the research plan."""
+        system = "Eres un Auditor de Cobertura Científica."
+        sections_json = json.dumps(plan_sections)
+        user = GAP_DETECTION_PROMPT.replace("{query}", query).replace("{plan_sections}", sections_json)
+        response = await self._call_llm(system, user, temperature=0.0, role="search")
+        return self._parse_json(response)
+
+    # ── GRADE evidence classification ───────────────────────────────────
+
+    def _enrich_with_grade(
+        self,
+        doc: Dict[str, Any],
+        level: str,
+        system: str = "grade",
+        evidence_type: str = "",
+        justification: str = "",
+    ) -> Dict[str, Any]:
+        """Helper to attach grade metadata to a document based on system ('grade' or 'oxford')."""
+        if system == "original":
+            normalized = normalize_original_grade_level(level)
+            entry = ORIGINAL_GRADE_LEVELS[normalized]
+            return {
+                **doc,
+                "grade_level": normalized,
+                "grade_label": entry["label"],
+                "grade_weight": entry["weight"],
+                "grade_desc": entry["desc"],
+                "grade_system": "original",
+                "evidenceLevel": entry["label"],
+                "type": evidence_type or doc.get("type") or doc.get("study_type") or "",
+                "grade_justification": justification or doc.get("grade_justification", ""),
+            }
+
+        if system == "oxford":
+            entry = OXFORD_LEVELS.get(level, OXFORD_LEVELS["4"])
+            label = f"[{level.upper()}] {entry['label']}"
+            weight = entry["weight"]
+            desc = entry["desc"]
+        else:
+            entry = GRADE_LEVELS.get(level, GRADE_LEVELS["4"])
+            label = f"[{level.upper()}] {entry['label']}"
+            weight = entry["weight"]
+            desc = entry["desc"]
+            
+        return {
+            **doc,
+            "grade_level": level,
+            "grade_label": label,
+            "grade_weight": weight,
+            "grade_desc": desc,
+            "grade_system": system,
+            "evidenceLevel": doc.get("evidenceLevel") or label,
+        }
+
+    def _extract_grade_classifications(self, parsed: Any) -> List[Dict[str, Any]]:
+        """Recover classifications from the original beta response shape and common variants."""
+        if isinstance(parsed, list):
+            return [x for x in parsed if isinstance(x, dict)]
+        if not isinstance(parsed, dict):
+            return []
+
+        for key in (
+            "classifications",
+            "grades",
+            "results",
+            "documents",
+            "analysis",
+            "items",
+            "data",
+            "evaluations",
+            "plan",
+        ):
+            value = parsed.get(key)
+            if isinstance(value, list):
+                return [x for x in value if isinstance(x, dict)]
+            if isinstance(value, dict):
+                return [value]
+
+        if any(k in parsed for k in ("index", "level", "type")):
+            return [parsed]
+        return []
+
+    def _grade_docs_context(self, documents: List[Dict[str, Any]], limit: int) -> str:
+        lines = []
+        for i, doc in enumerate(documents[:limit], 1):
+            authors = doc.get("authors", [])
+            if isinstance(authors, list):
+                authors = ", ".join(str(a) for a in authors if a)
+            snippet = doc.get("abstract") or doc.get("snippet") or doc.get("summary") or ""
+            lines.append(
+                f"[{i}] Titulo: {doc.get('title', 'Sin titulo')} | "
+                f"Autores: {authors or 'No especificados'} | "
+                f"Resumen: {str(snippet)[:500]}"
+            )
+        return "\n\n".join(lines)
+
+    async def classify_documents(self, documents: List[Dict[str, Any]], mode: str = "keywords") -> List[Dict[str, Any]]:
+        """
+        Classify documents using the specified strategy.
+        Modes: 'keywords' (default, fast), 'llm' (accurate but slow), 'oxford' (CEBM fast), 'hybrid' (keywords + llm for unknown).
+        """
+        from backend.prompts.synthesis import GRADE_PROMPT, GRADE_ORIGINAL_PROMPT
+        import json
+        
+        enriched = []
+        mode = mode.lower()
+
+        if mode == "original":
+            limit = min(50, len(documents))
+            parsed: Any = {}
+            try:
+                user = GRADE_ORIGINAL_PROMPT.format(
+                    documents_text=self._grade_docs_context(documents, limit)
+                )
+                response = await self._call_llm(
+                    "Eres un Agente de Evaluacion Metodologica. Tu salida debe ser exclusivamente JSON valido.",
+                    user,
+                    temperature=0.0,
+                    role="synthesis",
+                )
+                parsed = self._parse_json(response)
+            except Exception as e:
+                print(f"[GRADE ORIGINAL] Error classifying docs: {e}. Falling back to keywords.")
+
+            classifications = self._extract_grade_classifications(parsed)
+            by_index = {}
+            for i, item in enumerate(classifications, 1):
+                try:
+                    idx = int(item.get("index", i)) - 1
+                except (TypeError, ValueError):
+                    idx = i - 1
+                by_index[idx] = item
+
+            for i, doc in enumerate(documents):
+                item = by_index.get(i)
+                if item and i < limit:
+                    enriched.append(
+                        self._enrich_with_grade(
+                            doc,
+                            item.get("level", "BAJA"),
+                            "original",
+                            evidence_type=item.get("type", ""),
+                            justification=item.get("justification", item.get("reason", "")),
+                        )
+                    )
+                else:
+                    study_type = doc.get("study_type", doc.get("type", "transversal"))
+                    enriched.append(
+                        self._enrich_with_grade(
+                            doc,
+                            classify_grade_original(study_type),
+                            "original",
+                            evidence_type=study_type,
+                        )
+                    )
+            return enriched
+        
+        if mode == "keywords":
+            for doc in documents:
+                study_type = doc.get("study_type", doc.get("type", "transversal"))
+                level = classify_grade(study_type)
+                enriched.append(self._enrich_with_grade(doc, level, "grade"))
+                
+        elif mode == "oxford":
+            for doc in documents:
+                study_type = doc.get("study_type", doc.get("type", "transversal"))
+                level = classify_grade_oxford(study_type)
+                enriched.append(self._enrich_with_grade(doc, level, "oxford"))
+                
+        elif mode in ["llm", "hybrid"]:
+            # For hybrid, pre-filter with keywords to save tokens
+            docs_to_llm = []
+            if mode == "hybrid":
+                for doc in documents:
+                    study_type = doc.get("study_type", doc.get("type", "transversal"))
+                    level = classify_grade(study_type)
+                    if level != "4":  # Confident classification
+                        enriched.append(self._enrich_with_grade(doc, level, "grade"))
+                    else:
+                        docs_to_llm.append(doc)
+            else:
+                docs_to_llm = documents
+                
+            if docs_to_llm:
+                # Prepare content for LLM (up to 30 docs to avoid context window issues)
+                limit = 30
+                content_to_grade = ""
+                for i, doc in enumerate(docs_to_llm[:limit]):
+                    authors_str = ", ".join(doc.get("authors", []))
+                    snippet = doc.get("snippet", doc.get("abstract", ""))
+                    content_to_grade += f"[{i+1}] ID: {doc.get('id', i)} | Autores: {authors_str} | Resumen: {snippet}\n\n"
+                
+                system = "Eres un experto en clasificación de evidencia científica y medicina basada en evidencia."
+                user = GRADE_PROMPT.format(documents_text=content_to_grade)
+                
+                try:
+                    response = await self._call_llm(system, user, temperature=0.1, role="synthesis")
+                    results = self._parse_json(response)
+                    if not isinstance(results, list):
+                        if isinstance(results, dict) and "classifications" in results:
+                            results = results["classifications"]
+                        else:
+                            results = [results]
+                            
+                    # Map results back to documents
+                    for i, doc in enumerate(docs_to_llm):
+                        if i < limit and i < len(results):
+                            res = results[i]
+                            # Handle different response structures
+                            level = res.get("level", "4")
+                            if not level: level = "4"
+                            enriched.append(self._enrich_with_grade(doc, level, "grade"))
+                        else:
+                            # Fallback for remaining docs
+                            enriched.append(self._enrich_with_grade(doc, "4", "grade"))
+                except Exception as e:
+                    print(f"[GRADE LLM] Error classifying docs: {e}. Falling back to keywords.")
+                    for doc in docs_to_llm:
+                        study_type = doc.get("study_type", doc.get("type", "transversal"))
+                        level = classify_grade(study_type)
+                        enriched.append(self._enrich_with_grade(doc, level, "grade"))
+        else:
+            # Fallback
+            for doc in documents:
+                study_type = doc.get("study_type", doc.get("type", "transversal"))
+                level = classify_grade(study_type)
+                enriched.append(self._enrich_with_grade(doc, level, "grade"))
+
+        return enriched
+
+    def classify_evidence(self, documents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Legacy synchronous wrapper. Use await classify_documents() instead."""
+        if any(def_document_has_grade(doc) for doc in documents):
+            return documents
+        import asyncio
+        try:
+            loop = asyncio.get_event_loop()
+            return loop.run_until_complete(self.classify_documents(documents, "keywords"))
+        except RuntimeError:
+            # If event loop is already running, we have to fall back to simple keyword matching
+            enriched = []
+            for doc in documents:
+                study_type = doc.get("study_type", doc.get("type", "transversal"))
+                level = classify_grade(study_type)
+                enriched.append(self._enrich_with_grade(doc, level, "grade"))
+            return enriched
+
+
+    def sort_by_evidence(self, documents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Sort documents by GRADE weight descending (strongest evidence first)."""
+        return sorted(documents, key=lambda d: d.get("grade_weight", 0), reverse=True)
+
+    def evidence_summary(self, documents: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Produce a GRADE distribution summary."""
+        counts: Dict[str, int] = {}
+        for doc in documents:
+            lvl = doc.get("grade_level", "4")
+            counts[lvl] = counts.get(lvl, 0) + 1
+
+        if any(
+            doc.get("grade_system") == "original" or doc.get("grade_level") in ORIGINAL_GRADE_LEVELS
+            for doc in documents
+        ):
+            return {
+                "distribution": [
+                    {"level": l, "label": ORIGINAL_GRADE_LEVELS[l]["label"], "count": counts.get(l, 0)}
+                    for l in ["ALTA", "MODERADA", "BAJA", "MUY BAJA"] if counts.get(l, 0) > 0
+                ],
+                "total": len(documents),
+            }
+
+        levels_desc = ["1a", "1b", "2a", "2b", "3a", "3b", "4", "5", "6"]
+        return {
+            "distribution": [
+                {"level": l, "label": GRADE_LEVELS[l]["label"], "count": counts.get(l, 0)}
+                for l in levels_desc if counts.get(l, 0) > 0
+            ],
+            "total": len(documents),
+        }
+
+    # ── Full-text retrieval helpers ─────────────────────────────────────
+
+    def extract_full_text(self, doc: Dict[str, Any]) -> str:
+        """Extract the best available full text from a document entry."""
+        for key in ("full_text", "text", "content", "body", "extracted_text"):
+            val = doc.get(key)
+            if val and isinstance(val, str) and len(val.strip()) > 50:
+                return val.strip()
+        abstract = doc.get("abstract", doc.get("summary", ""))
+        if abstract:
+            return f"[Solo disponible resumen/abstract]\n{abstract.strip()}"
+        return "[No se encontró texto completo ni abstract para este documento]"
+
+    def build_full_text_context(self, documents: List[Dict[str, Any]], max_chars: int = 120000) -> str:
+        """Build a concatenated full-text context from documents respecting char limit."""
+        sorted_docs = self.sort_by_evidence(documents)
+        parts: List[str] = []
+        total = 0
+        for i, doc in enumerate(sorted_docs, 1):
+            ref_id = doc.get("id", i)
+            title = doc.get("title", "Sin título")
+            authors = doc.get("authors", "Autor desconocido")
+            year = doc.get("year", "?")
+            grade = doc.get("evidenceLevel") or doc.get("grade_label", "")
+            text = self.extract_full_text(doc)
+            header = f"[{i}] (BIB:{ref_id}) {title} - {authors} ({year}) [{grade}]"
+            chunk = f"{header}\n{text}\n"
+            if total + len(chunk) > max_chars:
+                remaining = max_chars - total
+                if remaining > 200:
+                    parts.append(chunk[:remaining] + "\n... [truncado por límite de tokens]")
+                break
+            parts.append(chunk)
+            total += len(chunk)
+        return "\n---\n".join(parts)
+
+    # ── Hierarchical (Map-Reduce) synthesis ─────────────────────────────
+
+    async def _map_chunk(
+        self,
+        chunk_docs: List[Dict[str, Any]],
+        chunk_idx: int,
+        query: str,
+        profile: str,
+        geo_context: str = "Automático",
+    ) -> str:
+        """Map step: synthesize a single chunk of documents."""
+        profile_data = AGENT_PROFILES.get(profile, AGENT_PROFILES["general"])
+        context = self.build_full_text_context(chunk_docs, max_chars=40000)
+        system = f"Eres un {profile_data['title']}. Sintetiza este bloque de documentos."
+        user = f"""CONSULTA ORIGINAL: "{query}"
+DOCUMENTOS DEL BLOQUE {chunk_idx}:
+{context}
+
+TAREA: Sintetiza los hallazgos clave de este bloque.
+- Menciona autores, años y datos específicos.
+- Usa formato [[n]] {{BIB:ID}} para cada cita.
+- Sé conciso pero técnico.
+- SOLO texto, NO JSON."""
+        user += f"\n\nCONTEXTO GEOGRÁFICO A PRIORIZAR: {geo_context}"
+        return await self._call_llm(system, user, temperature=0.0)
+
+    async def _reduce_summaries(self, summaries: List[str], query: str, profile: str, geo_context: str = "Automático") -> dict:
+        """Reduce step: merge chunk summaries into a single master plan."""
+        profile_data = AGENT_PROFILES.get(profile, AGENT_PROFILES["general"])
+        combined = "\n\n---\n\n".join(summaries)
+        system = f"Eres un {profile_data['title']}. Fusiona múltiples síntesis parciales en un plan coherente."
+        user = MASTER_SYNTHESIS_PROMPT.format(
+            query=query,
+            agent_title=profile_data["title"],
+            agent_title_upper=profile_data["title"].upper(),
+            profile_instruction=profile_data["instruction"],
+            template_structure="Integra las secciones de las síntesis parciales en un plan maestro unificado.",
+        )
+        user += f"\n\nSÍNTESIS PARCIALES:\n{combined}"
+        user += f"\n\nCONTEXTO GEOGRÁFICO A PRIORIZAR: {geo_context}"
+        response = await self._call_llm(system, user, temperature=0.0)
+        return extract_research_plan(response)
+
+    async def hierarchical_synthesis(
+        self,
+        query: str,
+        documents: List[Dict[str, Any]],
+        profile: str = "general",
+        chunk_size: int = 10,
+        geo_context: str = "Automático",
+    ) -> dict:
+        """
+        Map-Reduce hierarchical synthesis.
+        1. Split docs into chunks.
+        2. Map: synthesize each chunk independently.
+        3. Reduce: merge all chunk summaries into a master plan.
+        4. Detect gaps and optionally rescue.
+        """
+        enriched = self.classify_evidence(documents)
+        sorted_docs = self.sort_by_evidence(enriched)
+
+        chunks = [
+            sorted_docs[i:i + chunk_size]
+            for i in range(0, len(sorted_docs), chunk_size)
+        ]
+
+        summaries: List[str] = []
+        for idx, chunk in enumerate(chunks, 1):
+            summary = await self._map_chunk(chunk, idx, query, profile, geo_context=geo_context)
+            summaries.append(summary)
+
+        master_plan = await self._reduce_summaries(summaries, query, profile, geo_context=geo_context)
+
+        plan_sections = master_plan.get("plan", [])
+        gap_result = await self.detect_gaps(query, plan_sections)
+        master_plan["gap_analysis"] = gap_result
+        master_plan["evidence_summary"] = self.evidence_summary(enriched)
+
+        if gap_result.get("requires_rescue"):
+            rescue_result = await self._rescue_search(query, gap_result.get("missing_aspects", []))
+            master_plan["rescue_results"] = rescue_result
+
+        return master_plan
+
+    # ── Linear synthesis (original approach, kept for compatibility) ────
+
+    async def linear_synthesis(
+        self,
+        query: str,
+        documents: List[Dict[str, Any]],
+        profile: str = "general",
+    ) -> dict:
+        """Original linear pipeline: orchestrate → plan → master plan → gap detection."""
+        enriched = self.classify_evidence(documents)
+        sorted_docs = self.sort_by_evidence(enriched)
+        docs_context = self.build_full_text_context(sorted_docs)
+
+        master_plan = await self.generate_master_plan(query, docs_context, profile)
+        plan_sections = master_plan.get("plan", [])
+        gap_result = await self.detect_gaps(query, plan_sections)
+
+        master_plan["gap_analysis"] = gap_result
+        master_plan["evidence_summary"] = self.evidence_summary(enriched)
+
+        if gap_result.get("requires_rescue"):
+            rescue_result = await self._rescue_search(query, gap_result.get("missing_aspects", []))
+            master_plan["rescue_results"] = rescue_result
+
+        return master_plan
+
+    # ── Gap detection + rescue search ───────────────────────────────────
+
+    async def _rescue_search(self, query: str, missing_aspects: List[str]) -> Dict[str, Any]:
+        """Generate supplementary search queries for detected gaps."""
+        system = "Eres un Estratega de Búsqueda de Rescate. Genera queries de búsqueda para cubrir faltas."
+        aspects_text = "\n".join(f"- {a}" for a in missing_aspects)
+        user = f"""CONSULTA ORIGINAL: "{query}"
+ASPECTOS FALTANTES:
+{aspects_text}
+
+Genera queries de búsqueda de rescate optimizados para cubrir cada aspecto faltante.
+RESPONDE EN JSON:
+{{
+    "rescue_queries": [
+        {{"aspect": "...", "english_query": "...", "spanish_query": "..."}}
+    ]
+}}"""
+        response = await self._call_llm(system, user, temperature=0.0)
+        return self._parse_json(response)
+
+    async def run_full_pipeline(
+        self,
+        query: str,
+        documents: List[Dict[str, Any]],
+        profile: str = "general",
+        mode: str = "linear",
+        chunk_size: int = 10,
+        geo_context: str = "Automático",
+    ) -> dict:
+        """
+        Unified entry point for the full synthesis pipeline.
+        mode: "linear" | "hierarchical"
+        """
+        if mode == "hierarchical":
+            return await self.hierarchical_synthesis(query, documents, profile, chunk_size, geo_context=geo_context)
+        return await self.linear_synthesis(query, documents, profile)
+
+    # ── Cleanup ─────────────────────────────────────────────────────────
+
+    async def close(self):
+        await self.client.aclose()

backend/tools/dme_extractor.py

@@ -0,0 +1,105 @@
+import httpx
+import re
+import json
+import asyncio
+
+async def solve_anubis_challenge(url: str, client: httpx.AsyncClient) -> str:
+    """Bypass Anubis (Techaro) challenge used by some LATAM repositories"""
+    # Simply rotating the User-Agent and setting an Accept-Language often bypasses basic Anubis
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        'Accept-Language': 'es-PE,es;q=0.9,en-US;q=0.8,en;q=0.7',
+        'Sec-Ch-Ua': '"Not A(Brand";v="99", "Google Chrome";v="121", "Chromium";v="121"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"Windows"'
+    }
+    res = await client.get(url, headers=headers, follow_redirects=True, timeout=15.0)
+    return res.text
+
+async def extract_dspace_metadata(url: str) -> dict:
+    """Detect DSpace 7 SPA and extract hidden API metadata"""
+    async with httpx.AsyncClient(verify=False) as client:
+        try:
+            html = await solve_anubis_challenge(url, client)
+            
+            # Detect if it's DSpace 7 Angular
+            if 'dspace-angular' in html or 'server/api' in html:
+                # Find the handle
+                handle_match = re.search(r'handle/(\d+/\d+)', url)
+                if handle_match:
+                    handle = handle_match.group(1)
+                    # Extract the base URL
+                    base_url = re.match(r'(https?://[^/]+)', url).group(1)
+                    api_url = f"{base_url}/server/api/core/items/search/findByHandle?handle={handle}"
+                    
+                    api_res = await client.get(api_url, timeout=10.0)
+                    if api_res.status_code == 200:
+                        data = api_res.json()
+                        metadata = data.get('_embedded', {}).get('metadata', {})
+                        
+                        abstract = ""
+                        if 'dc.description.abstract' in metadata:
+                            abstract = metadata['dc.description.abstract'][0]['value']
+                        
+                        # Try to find the bitstream (PDF)
+                        pdf_url = ""
+                        bundles_link = data.get('_links', {}).get('bundles', {}).get('href')
+                        if bundles_link:
+                            bundle_res = await client.get(bundles_link)
+                            if bundle_res.status_code == 200:
+                                bundles = bundle_res.json().get('_embedded', {}).get('bundles', [])
+                                for b in bundles:
+                                    if b.get('name') == 'ORIGINAL':
+                                        bitstreams_link = b.get('_links', {}).get('bitstreams', {}).get('href')
+                                        if bitstreams_link:
+                                            bits_res = await client.get(bitstreams_link)
+                                            if bits_res.status_code == 200:
+                                                bits = bits_res.json().get('_embedded', {}).get('bitstreams', [])
+                                                for bit in bits:
+                                                    if bit.get('bundleName') == 'ORIGINAL' and 'pdf' in bit.get('format', '').lower():
+                                                        pdf_url = bit.get('_links', {}).get('content', {}).get('href')
+                                                        break
+                                        break
+                        
+                        return {
+                            "abstract": abstract,
+                            "pdf_url": pdf_url,
+                            "enhanced": True
+                        }
+            
+            # Fallback to basic HTML meta tags for older DSpace (xmlui/jspui)
+            abstract_match = re.search(r'<meta\s+name="DC\.description\.abstract"\s+content="([^"]+)"', html)
+            pdf_match = re.search(r'<meta\s+name="citation_pdf_url"\s+content="([^"]+)"', html)
+            
+            return {
+                "abstract": abstract_match.group(1) if abstract_match else "",
+                "pdf_url": pdf_match.group(1) if pdf_match else "",
+                "enhanced": bool(abstract_match or pdf_match)
+            }
+            
+        except Exception as e:
+            print(f"[DME] Error extracting metadata from {url}: {e}")
+            return {"abstract": "", "pdf_url": "", "enhanced": False}
+
+async def enhance_results(results: list) -> list:
+    """Run DME on a list of results"""
+    tasks = []
+    
+    async def process_item(r):
+        if not r.get("abstract") or len(r["abstract"]) < 50 or "[...]" in r["abstract"] or not r.get("pdfUrl"):
+            if r.get("source") in ["ALICIA", "RENATI", "La Referencia", "Bases LATAM"]:
+                url = r.get("doi") or "" # Fallback URL is often stored in doi if it's a URI
+                if "http" in url:
+                    dme_data = await extract_dspace_metadata(url)
+                    if dme_data["enhanced"]:
+                        if dme_data["abstract"]:
+                            r["abstract"] = dme_data["abstract"]
+                        if dme_data["pdf_url"]:
+                            r["pdfUrl"] = dme_data["pdf_url"]
+        return r
+
+    for r in results:
+        tasks.append(process_item(r))
+        
+    return await asyncio.gather(*tasks)

backend/tools/export_utils.py

@@ -0,0 +1,370 @@
+"""
+Export utilities for research reports.
+Supports: DOCX, PDF, Markdown, BibTeX, ZIP (full workspace).
+Ported from the Next.js original.
+"""
+
+import os
+import json
+import zipfile
+import tempfile
+import re
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+import pandas as pd
+
+
+def _project_root() -> str:
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+def _sanitize_key(value: str, fallback: str) -> str:
+    key = re.sub(r'[^a-zA-Z0-9_]', '_', value or "")
+    key = re.sub(r'_+', '_', key).strip('_')
+    return key or fallback
+
+
+def _escape_bibtex(value: Any) -> str:
+    text = "" if value is None else str(value)
+    text = text.replace('\u2028', ' ').replace('\u2029', ' ')
+    return text.replace('&', r'\&').replace('%', r'\%').replace('_', r'\_')
+
+
+def _doc_authors(doc: Dict[str, Any]) -> str:
+    authors = doc.get("authors", [])
+    if isinstance(authors, list):
+        return " and ".join(str(a) for a in authors if a) or "Unknown"
+    return str(authors or "Unknown")
+
+
+def _markdown_to_latex_body(report_md: str) -> str:
+    body = report_md or ""
+    body = re.sub(r'^###\s+(.+)$', r'\\subsection{\1}', body, flags=re.MULTILINE)
+    body = re.sub(r'^##\s+(.+)$', r'\\section{\1}', body, flags=re.MULTILINE)
+    body = re.sub(r'^#\s+(.+)$', r'\\section{\1}', body, flags=re.MULTILINE)
+    body = body.replace('**', '')
+    return body
+
+
+def generate_bibtex_from_docs(docs: List[Dict[str, Any]]) -> str:
+    """Generate BibTeX entries from pipeline documents, preserving original GRADE evidence."""
+    entries = []
+    seen = set()
+
+    for idx, doc in enumerate(docs, 1):
+        title = doc.get("title") or "Untitled"
+        raw_id = doc.get("id") or doc.get("doi") or title
+        cite_key = _sanitize_key(str(raw_id), f"ref{idx}")
+        if cite_key in seen:
+            cite_key = f"{cite_key}_{idx}"
+        seen.add(cite_key)
+
+        authors = _doc_authors(doc)
+        year = doc.get("year") or "n.d."
+        doi = doc.get("doi") or doc.get("metadata", {}).get("doi") or ""
+        source = doc.get("source") or doc.get("metadata", {}).get("journal") or "Repository"
+        url = doc.get("url") or doc.get("pdfUrl") or doc.get("handleUrl") or ""
+        evidence = doc.get("evidenceLevel") or doc.get("grade_label") or doc.get("grade_level") or "PENDIENTE"
+
+        type_text = str(doc.get("type") or "").lower()
+        title_text = str(title).lower()
+        source_text = str(source).lower()
+        is_thesis = any(k in f"{type_text} {title_text}" for k in [
+            "tesis", "thesis", "dissertation", "grado", "maestria", "doctorado", "licenciatura",
+            "bachelor", "master", "phd",
+        ])
+        has_journal_hint = any(k in source_text for k in [
+            "journal", "revista", "review", "proceedings", "conference", "transactions",
+        ])
+
+        bib_type = "mastersthesis" if is_thesis and not has_journal_hint and not doi else "article"
+        venue_field = "school" if bib_type == "mastersthesis" else "journal"
+
+        url_field = f"  url = {{{url}}},\n" if url else ""
+        entry = (
+            f"@{bib_type}{{{cite_key},\n"
+            f"  author = {{{_escape_bibtex(authors)}}},\n"
+            f"  title = {{{_escape_bibtex(title)}}},\n"
+            f"  {venue_field} = {{{_escape_bibtex(source)}}},\n"
+            f"  year = {{{_escape_bibtex(year)}}},\n"
+            f"{url_field}"
+            f"  doi = {{{_escape_bibtex(doi)}}},\n"
+            f"  note = {{Calidad de evidencia GRADE: {_escape_bibtex(evidence)}}}\n"
+            f"}}"
+        )
+        entries.append(entry)
+
+    return "\n\n".join(entries)
+
+
+def persist_research_output(
+    report_md: str,
+    docs: List[Dict[str, Any]],
+    query: str,
+    agent_role: str = "general",
+    model: str = "unknown",
+    output_root: Optional[str] = None,
+) -> Dict[str, str]:
+    """Persist final pipeline artifacts following the original beta data-mining layout."""
+    root = output_root or os.path.join(_project_root(), "latex_output")
+    scraping_dir = os.path.join(root, "data", "json1_scraping")
+    outputs_dir = os.path.join(root, "data", "json2_outputs")
+    os.makedirs(scraping_dir, exist_ok=True)
+    os.makedirs(outputs_dir, exist_ok=True)
+    os.makedirs(root, exist_ok=True)
+
+    timestamp = datetime.utcnow().isoformat() + "Z"
+    role_name = _sanitize_key((agent_role or "consolidado_investigacion").lower(), "consolidado_investigacion")
+    tex_path = os.path.join(root, f"{role_name}.tex")
+    md_path = os.path.join(root, f"{role_name}.md")
+    bib_path = os.path.join(root, "referencias.bib")
+    scraping_path = os.path.join(scraping_dir, "scraping_data.json")
+    outputs_path = os.path.join(outputs_dir, "llm_outputs.json")
+
+    bib = generate_bibtex_from_docs(docs)
+    tex = _markdown_to_latex_body(report_md)
+
+    with open(tex_path, "w", encoding="utf-8") as f:
+        f.write(tex)
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(report_md or "")
+    with open(bib_path, "w", encoding="utf-8") as f:
+        f.write(bib)
+
+    scraping_data = {
+        "version": "1.0.0",
+        "createdAt": timestamp,
+        "lastModifiedAt": timestamp,
+        "projectId": "LETXIPU-GRADIO",
+        "totalRecords": len(docs),
+        "records": [
+            {
+                "id": doc.get("id") or f"doc_{i}",
+                "url": doc.get("url") or doc.get("pdfUrl") or doc.get("handleUrl") or "",
+                "title": doc.get("title") or "Sin titulo",
+                "snippet": doc.get("snippet") or doc.get("abstract") or "",
+                "source": doc.get("source") or "Desconocido",
+                "scrapedAt": timestamp,
+                "metadata": {
+                    "authors": doc.get("authors") or [],
+                    "year": int(doc["year"]) if str(doc.get("year", "")).isdigit() else None,
+                    "abstract": doc.get("abstract"),
+                    "doi": doc.get("doi"),
+                    "pdfUrl": doc.get("pdfUrl"),
+                    "university": doc.get("university") or doc.get("institution"),
+                    "queries": [query],
+                    "evidenceLevel": doc.get("evidenceLevel") or doc.get("grade_label") or doc.get("grade_level"),
+                },
+            }
+            for i, doc in enumerate(docs, 1)
+        ],
+        "changelog": [
+            {
+                "timestamp": timestamp,
+                "action": "added",
+                "recordCount": len(docs),
+                "description": "Generado automaticamente por el pipeline Python Gradio.",
+            }
+        ],
+        "metadata": {
+            "queryUsed": query,
+            "sourcesEnabled": [],
+            "iterationsCompleted": 1,
+            "totalIterationsPlanned": 1,
+        },
+    }
+
+    output_record = {
+        "id": f"out_{int(datetime.utcnow().timestamp())}",
+        "timestamp": timestamp,
+        "promptUsed": query,
+        "modelUsed": model or "unknown",
+        "agentRole": agent_role,
+        "inputRecordCount": len(docs),
+        "output": {"plainText": report_md or "", "latex": tex},
+        "sourceScrapingVersion": "1.0.0",
+    }
+    outputs_data = {
+        "version": "1.0.0",
+        "createdAt": timestamp,
+        "lastModifiedAt": timestamp,
+        "projectId": "LETXIPU-GRADIO",
+        "outputs": [output_record],
+    }
+
+    with open(scraping_path, "w", encoding="utf-8") as f:
+        json.dump(scraping_data, f, ensure_ascii=False, indent=2)
+    with open(outputs_path, "w", encoding="utf-8") as f:
+        json.dump(outputs_data, f, ensure_ascii=False, indent=2)
+
+    return {
+        "tex": tex_path,
+        "markdown": md_path,
+        "bib": bib_path,
+        "scraping_json": scraping_path,
+        "outputs_json": outputs_path,
+    }
+
+
+def export_markdown(report_md: str, query: str = "") -> str:
+    """Export report as clean Markdown file."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_name = re.sub(r'[^\w\s-]', '', query[:40]).strip().replace(' ', '_') or "research"
+    filename = f"{safe_name}_{timestamp}.md"
+    
+    path = os.path.join(tempfile.gettempdir(), filename)
+    
+    header = f"""---
+title: "{query}"
+date: "{datetime.now().isoformat()}"
+generator: "LETXIPU Research Platform"
+---
+
+"""
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(header + report_md)
+    
+    return path
+
+
+def export_bibtex(docs_df: pd.DataFrame, query: str = "") -> str:
+    """Export documents as BibTeX references."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_name = re.sub(r'[^\w\s-]', '', query[:40]).strip().replace(' ', '_') or "references"
+    filename = f"{safe_name}_{timestamp}.bib"
+    path = os.path.join(tempfile.gettempdir(), filename)
+    
+    entries = []
+    for idx, row in docs_df.iterrows():
+        title = row.get("Título", "N/A")
+        authors = row.get("Autores", "N/A")
+        year = str(row.get("Año", ""))
+        doi = row.get("DOI", "")
+        source = row.get("Fuente", "")
+        
+        # Generate citation key
+        first_author = authors.split(",")[0].strip().split()[-1] if authors else "unknown"
+        cite_key = re.sub(r'[^a-zA-Z0-9]', '', f"{first_author}{year}")
+        if not cite_key:
+            cite_key = f"ref{idx}"
+        
+        entry = f"""@article{{{cite_key},
+  title = {{{title}}},
+  author = {{{authors}}},
+  year = {{{year}}},
+  doi = {{{doi}}},
+  journal = {{{source}}},
+}}"""
+        entries.append(entry)
+    
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write("\n\n".join(entries))
+    
+    return path
+
+
+def export_zip(report_md: str, docs_df: pd.DataFrame, query: str = "",
+               settings: dict = None) -> str:
+    """Export full workspace as ZIP: report.md + references.bib + documents.csv + settings.json"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_name = re.sub(r'[^\w\s-]', '', query[:40]).strip().replace(' ', '_') or "research"
+    filename = f"{safe_name}_workspace_{timestamp}.zip"
+    path = os.path.join(tempfile.gettempdir(), filename)
+    
+    with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as zf:
+        # 1. Report markdown
+        header = f"---\ntitle: \"{query}\"\ndate: \"{datetime.now().isoformat()}\"\n---\n\n"
+        zf.writestr("report.md", header + report_md)
+        
+        # 2. BibTeX
+        bib_path = export_bibtex(docs_df, query)
+        zf.write(bib_path, "references.bib")
+        
+        # 3. Documents CSV
+        csv_content = docs_df.to_csv(index=False, encoding='utf-8')
+        zf.writestr("documents.csv", csv_content)
+        
+        # 4. Documents JSON (machine-readable)
+        docs_json = docs_df.to_json(orient='records', force_ascii=False, indent=2)
+        zf.writestr("documents.json", docs_json)
+        
+        # 5. Settings/metadata
+        meta = {
+            "query": query,
+            "timestamp": datetime.now().isoformat(),
+            "total_documents": len(docs_df),
+            "platform": "LETXIPU Research Platform",
+            "settings": settings or {},
+        }
+        zf.writestr("metadata.json", json.dumps(meta, indent=2, ensure_ascii=False))
+    
+    return path
+
+
+def export_docx(report_md: str, query: str = "") -> Optional[str]:
+    """Export report as DOCX using python-docx if available."""
+    try:
+        from docx import Document
+        from docx.shared import Pt, Inches
+        from docx.enum.text import WD_ALIGN_PARAGRAPH
+    except ImportError:
+        return None  # python-docx not installed
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_name = re.sub(r'[^\w\s-]', '', query[:40]).strip().replace(' ', '_') or "research"
+    filename = f"{safe_name}_{timestamp}.docx"
+    path = os.path.join(tempfile.gettempdir(), filename)
+    
+    doc = Document()
+    
+    # Title
+    title_para = doc.add_heading(query or "Informe de Investigación", level=0)
+    title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    doc.add_paragraph(
+        f"Generado: {datetime.now().strftime('%d/%m/%Y %H:%M')} | LETXIPU Research Platform",
+        style='Subtitle'
+    )
+    doc.add_paragraph("")  # spacer
+    
+    # Parse markdown sections
+    lines = report_md.split('\n')
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            doc.add_paragraph("")
+            continue
+        
+        if stripped.startswith('#### '):
+            doc.add_heading(stripped[5:], level=4)
+        elif stripped.startswith('### '):
+            doc.add_heading(stripped[4:], level=3)
+        elif stripped.startswith('## '):
+            doc.add_heading(stripped[3:], level=2)
+        elif stripped.startswith('# '):
+            doc.add_heading(stripped[2:], level=1)
+        elif stripped.startswith('- ') or stripped.startswith('* '):
+            doc.add_paragraph(stripped[2:], style='List Bullet')
+        elif re.match(r'^\d+\.\s', stripped):
+            text = re.sub(r'^\d+\.\s', '', stripped)
+            doc.add_paragraph(text, style='List Number')
+        elif stripped.startswith('> '):
+            p = doc.add_paragraph(stripped[2:])
+            p.style = 'Intense Quote'
+        else:
+            # Handle bold and italic in regular text
+            p = doc.add_paragraph()
+            # Simple bold/italic parsing
+            parts = re.split(r'(\*\*.*?\*\*|\*.*?\*)', stripped)
+            for part in parts:
+                if part.startswith('**') and part.endswith('**'):
+                    run = p.add_run(part[2:-2])
+                    run.bold = True
+                elif part.startswith('*') and part.endswith('*'):
+                    run = p.add_run(part[1:-1])
+                    run.italic = True
+                else:
+                    p.add_run(part)
+    
+    doc.save(path)
+    return path

backend/tools/graph_generator.py

@@ -0,0 +1,65 @@
+import networkx as nx
+from pyvis.network import Network
+import os
+import uuid
+
+# Directorio para guardar grafos temporales
+GRAPH_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "assets", "graphs")
+os.makedirs(GRAPH_DIR, exist_ok=True)
+
+class GraphGenerator:
+    def __init__(self):
+        pass
+
+    def generate_research_graph(self, docs: list) -> str:
+        """
+        Toma una lista de documentos y genera un grafo interactivo de relaciones.
+        Devuelve el código HTML del grafo (o la ruta al archivo generado).
+        """
+        if not docs:
+            return "<div style='padding:20px;'>No hay documentos suficientes para generar el grafo.</div>"
+
+        G = nx.Graph()
+
+        # Añadir un nodo central para la consulta (opcional, en este caso los agruparemos por autores y fuentes)
+        # Recorrer documentos
+        for doc in docs:
+            title = doc.get("title", "Desconocido")[:30] + "..."
+            doc_id = doc.get("doi") or doc.get("pdfUrl") or title
+            source = doc.get("source", "Fuente Desconocida")
+            
+            # Añadir nodo del documento principal
+            G.add_node(doc_id, label=title, title=doc.get("title", ""), color="#8b5cf6", shape="dot", size=20)
+            
+            # Nodo de la fuente
+            G.add_node(source, label=source, color="#10b981", shape="square", size=25)
+            G.add_edge(doc_id, source)
+            
+            # Nodos de autores
+            authors = doc.get("authors", [])
+            if isinstance(authors, list):
+                for author in authors[:3]: # Solo los primeros 3 autores para no saturar
+                    author_name = str(author).strip()
+                    if author_name:
+                        G.add_node(author_name, label=author_name, color="#f59e0b", shape="triangle", size=15)
+                        G.add_edge(doc_id, author_name)
+
+        # Generar con pyvis
+        net = Network(height="600px", width="100%", bgcolor="#0f172a", font_color="white", select_menu=True)
+        # Opciones físicas para un buen layout
+        net.force_atlas_2based(gravity=-50, central_gravity=0.01, spring_length=100, spring_strength=0.08, damping=0.4, overlap=0)
+        
+        net.from_nx(G)
+        
+        filename = f"graph_{uuid.uuid4().hex[:8]}.html"
+        filepath = os.path.join(GRAPH_DIR, filename)
+        
+        net.write_html(filepath)
+        
+        # Leer el contenido HTML generado
+        with open(filepath, "r", encoding="utf-8") as f:
+            html_content = f.read()
+            
+        return html_content
+
+generator = GraphGenerator()

backend/tools/latex_compiler.py

@@ -0,0 +1,74 @@
+import os
+import subprocess
+import tempfile
+import shutil
+
+class LatexCompiler:
+    def __init__(self, engine="pdflatex"):
+        self.engine = engine
+        self.output_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "latex_output")
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+    def compile(self, tex_content: str, filename: str = "document") -> dict:
+        """
+        Compila código LaTeX y devuelve la ruta del PDF generado o los errores.
+        """
+        if not tex_content.strip():
+            return {"success": False, "error": "El código fuente está vacío."}
+            
+        with tempfile.TemporaryDirectory() as temp_dir:
+            tex_file = os.path.join(temp_dir, f"{filename}.tex")
+            
+            # Escribir el código en el archivo .tex
+            with open(tex_file, "w", encoding="utf-8") as f:
+                f.write(tex_content)
+            
+            try:
+                # Ejecutar compilador en modo interactivo=false para que no se quede bloqueado si hay error
+                # Y compilar dos veces para asegurar referencias y tabla de contenidos
+                for _ in range(2):
+                    result = subprocess.run(
+                        [self.engine, "-interaction=nonstopmode", f"{filename}.tex"],
+                        cwd=temp_dir,
+                        capture_output=True,
+                        text=True,
+                        timeout=30  # Timeout de 30 segundos
+                    )
+                
+                pdf_file = os.path.join(temp_dir, f"{filename}.pdf")
+                
+                if os.path.exists(pdf_file):
+                    # Copiar el PDF resultante a nuestra carpeta de salida
+                    final_pdf_path = os.path.join(self.output_dir, f"{filename}.pdf")
+                    shutil.copy2(pdf_file, final_pdf_path)
+                    
+                    return {
+                        "success": True,
+                        "pdf_path": final_pdf_path,
+                        "logs": result.stdout
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": "Error de compilación LaTeX",
+                        "logs": result.stdout
+                    }
+                    
+            except subprocess.TimeoutExpired:
+                return {
+                    "success": False,
+                    "error": "Tiempo de compilación agotado (30s). Verifica si hay bucles o paquetes conflictivos."
+                }
+            except FileNotFoundError:
+                return {
+                    "success": False,
+                    "error": f"Compilador '{self.engine}' no encontrado. Verifica que TeX Live / MiKTeX esté instalado en el sistema y en el PATH."
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+# Instancia global para facilitar su uso
+compiler = LatexCompiler()

backend/tools/metadata.py

@@ -0,0 +1,69 @@
+import asyncio
+from typing import Optional
+from backend.providers.base import fetch_json, normalize_result
+
+async def fetch_metadata(doi: str = None, url: str = None, title: str = None) -> dict:
+    """Fetch metadata for a single paper."""
+    if doi:
+        # Try OpenAlex by DOI
+        data = await fetch_json(f"https://api.openalex.org/works/https://doi.org/{doi}")
+        if "error" not in data:
+            return normalize_result(
+                title=data.get("title"),
+                authors=[a.get("author", {}).get("display_name", "") for a in data.get("authorships", [])],
+                year=data.get("publication_year"),
+                abstract=None,  # Need to decode inverted index
+                doi=doi,
+                pdf_url=data.get("open_access", {}).get("oa_url"),
+                source="openalex",
+                university=data.get("authorships", [{}])[0].get("institutions", [{}])[0].get("display_name") if data.get("authorships") else None,
+                citation_count=data.get("cited_by_count"),
+            )
+    if title:
+        data = await fetch_json("https://api.openalex.org/works", params={"search": title, "per-page": 1})
+        if "error" not in data and data.get("results"):
+            work = data["results"][0]
+            return normalize_result(
+                title=work.get("title"),
+                authors=[a.get("author", {}).get("display_name", "") for a in work.get("authorships", [])],
+                year=work.get("publication_year"),
+                abstract=None,
+                doi=work.get("ids", {}).get("doi", "").replace("https://doi.org/", ""),
+                pdf_url=work.get("open_access", {}).get("oa_url"),
+                source="openalex",
+            )
+    return {"error": "No metadata found"}
+
+async def recover_metadata(doi: str = None, url: str = None, title: str = None) -> dict:
+    """Deep metadata recovery from multiple sources."""
+    result = {}
+    sources_tried = []
+    
+    # Try OpenAlex
+    if doi:
+        sources_tried.append("OpenAlex")
+        data = await fetch_json(f"https://api.openalex.org/works/https://doi.org/{doi}")
+        if "error" not in data:
+            result["title"] = data.get("title")
+            result["year"] = data.get("publication_year")
+            result["doi"] = doi
+            result["authors"] = [a.get("author", {}).get("display_name", "") for a in data.get("authorships", [])]
+    
+    # Try Crossref for abstract
+    if doi and not result.get("abstract"):
+        sources_tried.append("Crossref")
+        data = await fetch_json(f"https://api.crossref.org/works/{doi}")
+        if "error" not in data:
+            item = data.get("message", {})
+            if item.get("abstract"):
+                result["abstract"] = item["abstract"][:500]
+    
+    # Try Semantic Scholar for PDF
+    if doi and not result.get("pdfUrl"):
+        sources_tried.append("Semantic Scholar")
+        data = await fetch_json(f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}?fields=openAccessPdf")
+        if "error" not in data:
+            result["pdfUrl"] = data.get("openAccessPdf", {}).get("url")
+    
+    result["sourcesTried"] = sources_tried
+    return result