Spaces:
Sleeping
Sleeping
File size: 45,996 Bytes
24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 25815f0 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 94a16c6 24431ef 65b4bb8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 | """
Capa 3 · Orquestador v4 -- Multi-Modelo Anti-Alucinacion
=========================================================
Modelos:
- LLaMA 3.1 8B -> Clasificador + Validador
- LLaMA 3.1 70B -> Analisis numerico, narrativo y sintesis
- Mixtral 8x7B -> Dashboard
v4.1: Integracion read_ift (telecomunicaciones Mexico)
v4.2: Fix bloque INEGI -- eliminada instruccion hardcodeada de poblacion,
ahora pasa datos reales (IGAE, PIB, INPC, etc.) sin sesgar al LLM.
"""
import json
import os
import asyncio
import requests
from modules.agent_tools import TOOLS, execute_tool
from modules.critic_loop import critic_loop, load_raw_data_for_validation
from modules.semantic_cache import get_cached, set_cached
from modules.observability import QueryTrace
NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "")
NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1"
# Groq -- Llama 3.3 70B numerico -- mas rapido
GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
GROQ_BASE_URL = "https://api.groq.com/openai/v1"
# Tavily -- busqueda web en tiempo real
TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
TAVILY_URL = "https://api.tavily.com/search"
# --- Modelos -------------------------------------------------------------------
MODEL_CLASSIFIER = "meta/llama-3.1-8b-instruct" # Clasificador SIMPLE/NUMERICA/NARRATIVA
MODEL_NUMERICAL = "llama-3.3-70b-versatile" # Analisis numerico via Groq LPU
MODEL_NARRATIVE = "meta/llama-3.1-70b-instruct" # Analisis narrativo y contexto complejo
MODEL_VALIDATOR = "meta/llama-3.1-8b-instruct" # Validador anti-alucinacion
MODEL_SYNTHESIS = "meta/llama-3.1-70b-instruct" # Sintesis final bilingue
# --- System prompts --------------------------------------------------------------
SYSTEM_STRICT = """Eres el Agente Económico de la plataforma MX Data Intelligence.
Tu objetivo es proveer datos macroeconómicos y de telecomunicaciones de México 100% verídicos.
Fuentes oficiales: Banxico, World Bank, INEGI, IFT.
REGLAS ESTRICTAS — sin excepciones:
1. NUNCA uses tu memoria interna para datos numéricos — solo tool results.
2. PROHIBIDO repetir el mismo decimal en años consecutivos sin que la fuente lo confirme.
3. Si el dato no existe o no fue publicado → responde exactamente: "El dato oficial para [período] aún no ha sido publicado por las instituciones correspondientes."
4. Cada número en tu respuesta DEBE tener su fuente explícita (Banxico/World Bank/INEGI/IFT) y fecha.
5. Si la herramienta retorna error → dilo explícitamente, no improvises.
6. Responde en el mismo idioma de la pregunta (español o inglés).
7. El campo inflacion_ipc de Banxico es el ÍNDICE INPC base 2018=100, NO es el porcentaje de inflación anual. NUNCA lo presentes como porcentaje.
8. Para inflación anual usa el dato de INEGI (inflacion_general, unidad % variación anual). Si no está en INEGI, usa inflacion_pct del World Bank. Nunca escribas "dato no disponible" si tienes inflacion_general de INEGI.
9. PIB siempre en billones: $1.856 billones USD (1 billón = 1,000,000 millones).
10. ESCALA WORLD BANK — CRÍTICO: SIEMPRE usa valor_fmt_es para presentar datos del World Bank. Exportaciones, importaciones y remesas son "miles de millones USD", NO "billones USD".
11. DATOS 5G MÉXICO — CRÍTICO: El IFT NO publica datos de penetración 5G desagregados en sus reportes de Datos Oportunos. Si preguntan por penetración 5G: indica que el IFT no publica ese dato desagregado, y que la estimación de cobertura poblacional GSMA 2024 es ~3.5% (no usuarios activos). NO cites porcentajes de penetración 5G del IFT porque ese dato no existe en el reporte oficial.
10. BÚSQUEDA WEB — search_web() disponible via Tavily API. Úsala cuando: (a) el dato no está en el bucket, (b) preguntan por regulatorio reciente (CRT/ATDT), (c) portabilidad más reciente que H1 2025, (d) noticias de operadores. Siempre cita la URL fuente.
11. Para datos de telecomunicaciones (Telcel, AT&T, Movistar, Telmex, 5G, etc.) usa SIEMPRE read_ift — nunca inventes participaciones de mercado.
12. OPERADORES 5G MÉXICO — CRÍTICO ANTI-ALUCINACIÓN:
5G REAL confirmado: Telcel (red propia) y AT&T (red propia). Movistar opera 5G vía acuerdo con AT&T.
OMVs: Bait/Diri/PilloFon usan Altán Redes = 4.5G LTE, NO 5G. NUNCA digas que Bait, Diri o PilloFon tienen 5G.
Megacable y Virgin Mobile: depende de zona — NO afirmes que tienen 5G si no está en el dato oficial.
Si no hay dato oficial confirmado → di exactamente: "El IFT Q1 2025 no certifica el acceso 5G de este OMV."
13. REGULADOR TELECOMUNICACIONES — CRÍTICO: El IFT sigue siendo el regulador oficial de telecomunicaciones en México. En 2025 quedó reorganizado y adscrito a la ATDT pero NO fue extinto — sigue operando. NUNCA digas que el IFT fue extinto o que la CRT lo reemplazó. Los datos de nuestro bucket son del IFT Q1 2025. SIEMPRE que respondas preguntas de telecomunicaciones agrega: "Fuente: IFT Q1 2025."
14. PORTABILIDAD — CRÍTICO ANTI-ALUCINACIÓN:
DATOS REALES disponibles (fuente: consolidado semestral IFT, reportado julio 2025 — NO es Q1 2025):
- Movistar H1 2025 (ene-jun 2025): +32,667 líneas netas
- AT&T H1 2025 (ene-jun 2025): -752,664 líneas netas
- Telcel H1 2025: desaceleración 42% vs año anterior
- Bait (OMV) H1 2025: +244,024 líneas netas
CRÍTICO: Estos datos son del CONSOLIDADO SEMESTRAL (H1 = primer semestre ene-jun 2025), NO del reporte Q1 (enero-marzo).
NUNCA atribuyas datos semestrales a un reporte Q1. Son períodos diferentes.
Si preguntan por Q1 específico: "El reporte IFT Q1 2025 no desglosa saldos numéricos de portabilidad. El dato disponible es el consolidado H1 2025."
Si preguntan por período no disponible: "No tengo ese dato. Consulta ift.org.mx/portabilidad"
15. INEGI — CRÍTICO: Los datos de INEGI (población, IGAE, PIB trimestral, INPC, tasa de desocupación,
inflación general y subyacente) provienen del Dataset HF Fercor95mx/mx-data-truth-inegi, alimentado
diariamente por extracción directa del Banco de Información Económica (BIE-BISE) del INEGI.
Usa el valor, fecha y unidad EXACTOS que vengan en los datos — nunca inventes ni asumas un valor
de tu conocimiento general, aunque te parezca plausible. Si el campo solicitado no aparece en los
datos, dilo explícitamente y sugiere consultar inegi.org.mx — no rellenes con otro indicador distinto.
16. REGLA GENERAL ANTI-ALUCINACIÓN: Si no tienes el dato exacto en el bucket, responde: "No cuento con ese dato en mi fuente actual. Te recomiendo consultar [fuente oficial]." NUNCA inventes justificaciones de por qué no tienes el dato.
"""
PROMPT_CLASSIFIER = """Clasifica esta pregunta económica en UNA de estas 3 categorías:
SIMPLE - pregunta sobre dato ACTUAL o RECIENTE sin fecha específica pasada
Ejemplos: "¿Cuál es el tipo de cambio hoy?", "¿Cómo está la tasa TIIE?", "¿Cuál es el PIB?"
NUMERICA - pregunta sobre histórico, año específico (2024/2025/2026), promedio, estadísticas, tendencia, máximo, mínimo, evolución
Ejemplos: "¿Cuál fue el promedio en 2025?", "tipo de cambio durante 2024", "estadísticas SF43718", "mínimo histórico"
NARRATIVA - análisis complejo, comparaciones entre fuentes, impactos, escenarios, explicaciones
Ejemplos: "¿Cómo afecta la inflación al PIB?", "compara Banxico con World Bank", "análisis económico completo"
REGLA IMPORTANTE: Si la pregunta menciona un año (2024, 2025, 2026) o palabras como promedio/histórico/estadísticas/tendencia/mínimo/máximo → siempre es NUMERICA.
Responde SOLO con una palabra: SIMPLE, NUMERICA o NARRATIVA."""
PROMPT_VALIDATOR = """Eres un validador silencioso de datos económicos.
Tu tarea: revisar y corregir la respuesta. Devuelve SOLO la respuesta corregida — sin explicaciones, sin comentarios, sin mencionar qué corregiste.
Reglas de corrección:
1. Agrega fuente explícita (Banxico/World Bank/INEGI/IFT) a cada número que no la tenga
2. Si un decimal parece inventado, márcalo como [dato no verificado]
3. No agregues datos nuevos — solo corrige formato y fuentes
4. Devuelve la respuesta lista para mostrar al usuario final"""
MULTI_KEYWORDS = [
"cruzando", "cruza", "todas las fuentes", "salud económica",
"resumen económico", "análisis completo", "los tres", "las tres",
"multi", "completo", "integral", "compara", "vs", "versus"
]
# -- Keywords telecomunicaciones --------------------------------------------------
TELCO_KEYWORDS = [
"telcel", "att", "at&t", "movistar", "telmex", "telnorte",
"telecomunicaciones", "telco", "telefonia movil", "telefonía móvil",
"5g", "4g", "lte", "cobertura celular", "cobertura movil",
"portabilidad numerica", "portabilidad numérica",
"banda ancha", "internet movil", "internet móvil",
"operador movil", "operador móvil", "lineas moviles", "líneas móviles",
"ift", "instituto federal de telecomunicaciones",
"participacion mercado movil", "participación mercado móvil",
"tv restringida", "television restringida", "televisión restringida",
"megacable", "izzi", "sky", "total play", "totalplay",
"agente economico preponderante", "aep telecom",
]
# -- Keywords INEGI -- v4.2: ampliado con los 9 indicadores reales ---------------
INEGI_KEYWORDS = [
"poblacion", "población", "personas hay", "cuantas personas",
"cuántas personas", "habitantes", "igae", "ocupacion", "ocupados",
"inegi", "inpc", "desocupacion", "desocupación", "actividad economica",
"actividad económica", "pib trimestral", "producto interno bruto trimestral",
"tasa de desocupacion", "tasa de desocupación", "inflacion general",
"inflación general", "inflacion subyacente", "inflación subyacente",
"indice de precios", "índice de precios", "indice nacional de precios",
]
# --- Helpers -----------------------------------------------------------------------
def needs_multi_source(question: str) -> bool:
q = question.lower()
has_banxico = any(k in q for k in ["banxico", "tipo de cambio", "tasa", "tiie", "inflacion", "inflación"])
has_wb = any(k in q for k in ["world bank", "pib", "exportaciones", "deuda", "worldbank"])
has_inegi = any(k in q for k in ["inegi", "poblacion", "población", "ocupacion", "igae"])
has_multi = any(k in q for k in MULTI_KEYWORDS)
return sum([has_banxico, has_wb, has_inegi]) >= 2 or has_multi
# Global trace reference for token tracking
_current_trace = None
def call_model(model: str, messages: list, max_tokens: int = 700) -> tuple:
"""Llamada generica a cualquier modelo via NVIDIA API."""
headers = {
"Authorization": f"Bearer {NVIDIA_API_KEY}",
"Content-Type": "application/json",
}
payload = {
"model": model,
"messages": messages,
"temperature": 0.1,
"max_tokens": max_tokens,
"stream": False,
}
for attempt in range(3):
try:
r = requests.post(
f"{NVIDIA_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=180,
)
r.raise_for_status()
data = r.json()
result = data["choices"][0]["message"].get("content", "")
if _current_trace:
usage = data.get("usage", {})
input_tokens = usage.get("prompt_tokens", sum(len(m.get("content","")) for m in messages) // 4)
output_tokens = usage.get("completion_tokens", len(result) // 4)
_current_trace.record_tokens(model, input_tokens, output_tokens)
return result, None
except requests.exceptions.Timeout:
if attempt < 2:
continue
return None, "timeout"
except Exception as e:
return None, str(e)
return None, "timeout"
def call_model_groq(model: str, messages: list, max_tokens: int = 700) -> tuple:
"""Llamada a Groq API -- mas rapido para analisis numerico."""
if not GROQ_API_KEY:
return call_model("meta/llama-3.1-70b-instruct", messages, max_tokens)
headers = {
"Authorization": f"Bearer {GROQ_API_KEY}",
"Content-Type": "application/json",
}
payload = {
"model": "llama-3.3-70b-versatile",
"messages": messages,
"temperature": 0.1,
"max_tokens": max_tokens,
"stream": False,
}
for attempt in range(3):
try:
r = requests.post(
f"{GROQ_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=30,
)
r.raise_for_status()
data = r.json()
result = data["choices"][0]["message"].get("content", "")
if _current_trace:
usage = data.get("usage", {})
input_tokens = usage.get("prompt_tokens", sum(len(m.get("content","")) for m in messages) // 4)
output_tokens = usage.get("completion_tokens", len(result) // 4)
_current_trace.record_tokens("groq/llama-3.3-70b-versatile", input_tokens, output_tokens)
return result, None
except requests.exceptions.Timeout:
if attempt < 2:
continue
return call_model("meta/llama-3.1-70b-instruct", messages, max_tokens)
except Exception as e:
if attempt < 2:
continue
return call_model("meta/llama-3.1-70b-instruct", messages, max_tokens)
return call_model("meta/llama-3.1-70b-instruct", messages, max_tokens)
def search_web(query: str, max_results: int = 3) -> dict:
"""Busqueda web en tiempo real via Tavily API."""
if not TAVILY_API_KEY:
return {"error": "TAVILY_API_KEY no configurada", "results": []}
try:
payload = {
"api_key": TAVILY_API_KEY,
"query": query,
"max_results": max_results,
"search_depth": "basic",
"include_answer": True,
"include_domains": [
"ift.org.mx", "crt.gob.mx", "atdt.gob.mx",
"banxico.org.mx", "inegi.org.mx",
"eleconomista.com.mx", "expansion.mx",
"milenio.com", "elfinanciero.com.mx"
]
}
r = requests.post(TAVILY_URL, json=payload, timeout=15)
r.raise_for_status()
data = r.json()
results = []
for item in data.get("results", [])[:max_results]:
results.append({
"titulo": item.get("title", ""),
"url": item.get("url", ""),
"snippet": item.get("content", "")[:400],
"fecha": item.get("published_date", "")
})
return {
"answer": data.get("answer", ""),
"results": results,
"query": query
}
except Exception as e:
return {"error": str(e), "results": []}
def classify_question(question: str) -> str:
"""LLaMA 8B clasifica la pregunta: SIMPLE / NUMERICA / NARRATIVA."""
msgs = [
{"role": "system", "content": PROMPT_CLASSIFIER},
{"role": "user", "content": question}
]
result, error = call_model(MODEL_CLASSIFIER, msgs, max_tokens=10)
if error or not result:
return "NARRATIVA"
result = result.strip().upper()
if "SIMPLE" in result:
return "SIMPLE"
elif "NUMERICA" in result or "NUMÉRICA" in result:
return "NUMERICA"
else:
return "NARRATIVA"
async def fetch_tool_async(tool_name: str, args: dict) -> tuple:
"""Ejecuta una tool de forma asincrona."""
loop = asyncio.get_event_loop()
result = await loop.run_in_executor(None, execute_tool, tool_name, args)
return tool_name, result
async def prefetch_all_parallel(placeholder=None) -> str:
"""Ejecuta las tools en paralelo con asyncio.gather().
INEGI: llama indicadores especificos en vez de todos para evitar
enviar 399 registros historicos al LLM."""
if placeholder:
placeholder.markdown("*Consultando Banxico + World Bank + INEGI en paralelo...*")
# Indicadores INEGI especificos - NO usar todos (399 registros)
INEGI_INDS = ["igae", "inflacion_general", "tasa_desocupacion",
"precios", "pib_trimestral", "ocupacion"]
tasks = (
[fetch_tool_async("read_banxico", {"indicador": "todos"}),
fetch_tool_async("read_worldbank", {"categoria": "economia"})]
+ [fetch_tool_async("read_inegi", {"indicador": ind}) for ind in INEGI_INDS]
)
results = await asyncio.gather(*tasks, return_exceptions=True)
parts = []
labels = {"read_banxico": "BANXICO", "read_worldbank": "WORLD BANK", "read_inegi": "INEGI"}
BILLONES_KEYS = ["pib_usd", "exportaciones_usd", "importaciones_usd", "remesas_usd", "cuenta_corriente_usd"]
PCT_KEYS = ["inflacion_pct", "desempleo_pct", "deuda_pct_pib", "crecimiento_pib_pct", "pobreza_pct",
"alfabetizacion_pct", "acceso_electricidad_pct", "area_forestal_pct"]
def fmt_valor(k, v, meta=None):
if isinstance(meta, dict) and "valor_fmt_es" in meta:
return meta["valor_fmt_es"]
try:
n = float(str(v).replace(",", ""))
if k in BILLONES_KEYS:
if abs(n) > 1_000_000_000_000:
return f"{n/1_000_000_000_000:,.3f} billones USD"
elif abs(n) > 1_000_000_000:
return f"{n/1_000_000_000:,.1f} miles de millones USD"
elif k in PCT_KEYS:
return f"{n:.2f}%"
elif k in ["inflacion_ipc", "SP1"]:
return f"{n:.3f} (índice INPC base 2018=100 — NO es % de inflación)"
elif k in ["tipo_cambio_usd_mxn", "SF43718"]:
return f"{n:.4f} MXN/USD"
elif k in ["tiie_28_dias", "tasa_objetivo", "SF43783", "SF61745"]:
return f"{n:.4f}%"
elif n > 1_000_000:
return f"{n:,.0f}"
return v
except (TypeError, ValueError):
return v
inegi_parts = [] # acumular resultados INEGI individuales
for tool_name, result in results:
label = labels.get(tool_name, tool_name)
if isinstance(result, Exception):
if tool_name != "read_inegi":
parts.append(f"[{label}]: Error - {result}")
continue
try:
data = json.loads(result)
# INEGI: cada resultado es un indicador especifico {ok, nombre, valor, fecha, unidad}
if tool_name == "read_inegi":
if data.get("ok") and data.get("valor") is not None:
nombre = data.get("nombre", data.get("indicador", ""))
valor = data.get("valor")
fecha = data.get("fecha", "")
unidad = data.get("unidad", "")
var = data.get("variacion_pct")
v_fmt = fmt_valor(nombre, valor)
var_str = f" ({var:+.2f}% var.anual)" if var is not None else ""
inegi_parts.append(f"{nombre}={v_fmt}{var_str} [{fecha}]")
continue
# Banxico y World Bank: procesamiento normal
datos = data.get("datos", data.get("datos_disponibles", data))
if isinstance(datos, dict):
resumen = {}
for k, v in datos.items():
if k in ["fuente", "timestamp", "archivo", "pais", "nota_inflacion"]:
continue
if isinstance(v, dict):
val = v.get("valor_formateado", v.get("valor", str(v)))
resumen[k] = fmt_valor(k, val)
elif not isinstance(v, (list, dict)):
resumen[k] = fmt_valor(k, v)
parts.append(f"[{label}]: " + ", ".join(f"{k}={v}" for k, v in list(resumen.items())[:10]))
else:
parts.append(f"[{label}]: {str(datos)[:300]}")
except Exception as e:
if tool_name != "read_inegi":
parts.append(f"[{label}]: Error procesando - {e}")
# Agregar INEGI consolidado
if inegi_parts:
parts.append("[INEGI]: " + " | ".join(inegi_parts))
return "\n".join(parts)
def validate_response(response: str, data_context: str, question: str = "") -> str:
"""
Validacion en 2 pasos:
1. Critic-Loop Python -- verificacion matematica deterministica (~1ms)
2. LLaMA 8B -- validacion semantica y de fuentes
"""
raw_data = load_raw_data_for_validation()
final, iterations, n_errors = critic_loop(
draft=response,
question=question,
raw_data=raw_data,
call_model_fn=call_model,
model=MODEL_VALIDATOR,
system_prompt=SYSTEM_STRICT,
)
response = final
msgs = [
{"role": "system", "content": PROMPT_VALIDATOR},
{"role": "user", "content": f"DATOS REALES:\n{data_context}\n\nRESPUESTA A VALIDAR:\n{response}"}
]
validated, error = call_model(MODEL_VALIDATOR, msgs, max_tokens=800)
if error or not validated:
return response
return validated
def synthesize_response(data_context: str, question: str, placeholder=None) -> str:
"""LLaMA 70B redacta la respuesta final bilingue."""
if placeholder:
placeholder.markdown("*Redactando respuesta final...*")
lang_hint = "en inglés" if any(
w in question.lower() for w in ["what","how","when","where","why","which","is","are","the"]
) else "en español"
msgs = [
{"role": "system", "content": SYSTEM_STRICT},
{"role": "user", "content":
f"Con estos datos reales, responde la pregunta {lang_hint}. "
f"Menciona la fuente y fecha de cada dato. "
f"Formato profesional y claro.\n\n"
f"DATOS:\n{data_context}\n\n"
f"PREGUNTA: {question}"
}
]
answer, error = call_model(MODEL_SYNTHESIS, msgs, max_tokens=700)
if error or not answer:
return f"⚠️ Error en síntesis: {error}"
return answer
# --- Orquestador principal --------------------------------------------------------
def call_llm_with_tools(messages: list, stream_placeholder=None) -> str:
if not NVIDIA_API_KEY:
return "⚠️ Configura NVIDIA_API_KEY en Settings → Secrets."
user_question = messages[-1].get("content", "") if messages else ""
# -- CACHE SEMANTICO -- antes de cualquier procesamiento ----------------------
cached = get_cached(user_question)
if cached:
if stream_placeholder:
stream_placeholder.markdown(cached)
return cached
# -- TRAZA DE OBSERVABILIDAD --------------------------------------------------
global _current_trace
trace = QueryTrace(user_question)
_current_trace = trace
# -- PASO 0: Pre-clasificacion Python (sin LLM) --------------------------------
import re as _re_orch
q_lower = user_question.lower()
# -- INEGI: detectar keywords -> responder directo con read_inegi -------------
# v4.2 FIX: se elimino la instruccion hardcodeada que forzaba al LLM a buscar
# "128,455,567" -- esa instruccion sesgaba la respuesta sin importar el dato
# real devuelto por read_inegi(). Ahora se pasan los datos reales (poblacion,
# IGAE, PIB trimestral, INPC, tasa de desocupacion, inflacion, etc.) sin
# ninguna instruccion que prejuzgue el contenido.
is_inegi = any(k in q_lower for k in INEGI_KEYWORDS)
if is_inegi:
if stream_placeholder:
stream_placeholder.markdown("*Consulta INEGI → Dataset HF en tiempo real...*")
trace.set_route("INEGI")
trace.add_tool("read_inegi")
# Detectar indicador específico para llamar read_inegi con precisión
# en vez de cargar el JSON completo con "todos" (399 registros = demasiado para el LLM)
# ORDEN IMPORTANTE: específicos primero, genéricos después
if any(k in q_lower for k in ["igae", "actividad economica", "actividad económica"]):
indicador_inegi = "igae"
elif any(k in q_lower for k in ["pib trimestral", "producto interno bruto trimestral"]):
indicador_inegi = "pib_trimestral"
elif any(k in q_lower for k in ["tasa de desocupacion", "tasa de desocupación", "desocupacion", "desocupación"]):
indicador_inegi = "tasa_desocupacion"
elif any(k in q_lower for k in ["inflacion general", "inflación general"]):
indicador_inegi = "inflacion_general"
elif any(k in q_lower for k in ["inflacion subyacente", "inflación subyacente"]):
indicador_inegi = "inflacion_subyacente"
elif any(k in q_lower for k in ["inpc subyacente", "índice nacional de precios subyacente"]):
indicador_inegi = "inpc_subyacente"
elif any(k in q_lower for k in ["inpc", "precios al consumidor", "indice de precios", "índice de precios"]):
# INPC genérico va después de INPC subyacente para evitar captura prematura
indicador_inegi = "precios"
elif any(k in q_lower for k in ["ocupacion", "ocupados", "ocupada", "empleo", "trabajan", "personas trabajan", "personas ocupadas"]):
# ocupacion va antes de poblacion para que "personas trabajan" no active poblacion
indicador_inegi = "ocupacion"
elif any(k in q_lower for k in ["poblacion", "población", "habitantes", "personas hay", "cuantas personas", "cuántas personas"]):
indicador_inegi = "poblacion"
else:
indicador_inegi = "todos"
raw_inegi = execute_tool("read_inegi", {"indicador": indicador_inegi})
# v4.3 FIX: si read_inegi() falla, el error NUNCA se manda al LLM de
# síntesis -- antes el LLM "suavizaba" errores técnicos (401, descarga
# fallida, etc.) convirtiéndolos en disculpas genéricas tipo "no tengo
# información", ocultando el fallo real. Ahora se corta el pipeline
# y se muestra el error técnico exacto (stage + tipo + mensaje) para
# poder diagnosticarlo de inmediato.
try:
inegi_check = json.loads(raw_inegi)
except Exception:
inegi_check = {"error": "respuesta de read_inegi no es JSON válido", "raw": raw_inegi[:300]}
if isinstance(inegi_check, dict) and inegi_check.get("error"):
stage_info = inegi_check.get("stage", "desconocida")
error_type = inegi_check.get("error_type", "")
error_msg = inegi_check.get("error", "error desconocido")
result_inegi = (
f"⚠️ No fue posible consultar INEGI en este momento.\n\n"
f"**Detalle técnico:** `{error_type}` en etapa `{stage_info}`\n\n"
f"`{error_msg}`\n\n"
f"Este es un error de la integración técnica, no significa que el dato no exista. "
f"Reintenta en unos segundos o revisa Administración → Debug INEGI."
)
if stream_placeholder:
stream_placeholder.markdown(result_inegi)
trace.finish()
_current_trace = None
# No cachear errores -- para que el próximo intento sí re-ejecute
return result_inegi
# Formatear dato INEGI en lenguaje natural para que el LLM no confunda
# el JSON tecnico con "dato no publicado"
try:
inegi_parsed = json.loads(raw_inegi)
if inegi_parsed.get("ok") and inegi_parsed.get("valor") is not None:
nombre = inegi_parsed.get("nombre", inegi_parsed.get("indicador", "indicador"))
valor = inegi_parsed.get("valor")
fecha = inegi_parsed.get("fecha", "N/A")
unidad = inegi_parsed.get("unidad", "")
fuente = inegi_parsed.get("fuente", "INEGI BIE-BISE")
var_pct = inegi_parsed.get("variacion_pct")
var_str = f", variacion anual: {var_pct:+.4f}%" if var_pct is not None else ""
inegi_context = (
f"DATO OFICIAL INEGI DISPONIBLE:\n"
f"Indicador: {nombre}\n"
f"Valor: {valor}\n"
f"Fecha: {fecha}\n"
f"Unidad: {unidad}\n"
f"Fuente: {fuente}{var_str}\n"
f"Dataset: Fercor95mx/mx-data-truth-inegi (verificado)\n\n"
f"INSTRUCCION: El dato EXISTE y esta disponible arriba. "
f"Usalo EXACTAMENTE como aparece — valor={valor}, fecha={fecha}."
)
else:
inegi_context = f"DATO INEGI:\n{raw_inegi[:1000]}"
except Exception:
inegi_context = f"DATO INEGI:\n{raw_inegi[:1000]}"
msgs_inegi = [
{"role": "system", "content": SYSTEM_STRICT},
{"role": "user", "content":
f"{inegi_context}\n\n"
f"Responde la siguiente pregunta usando EXCLUSIVAMENTE el dato mostrado arriba. "
f"Menciona el valor exacto, la fecha y la fuente. Responde en espanol.\n\n"
f"PREGUNTA: {user_question}"
}
]
answer_inegi, _ = call_model(MODEL_SYNTHESIS, msgs_inegi, max_tokens=500)
result_inegi = answer_inegi or raw_inegi[:500]
if stream_placeholder:
stream_placeholder.markdown(result_inegi)
trace.finish()
_current_trace = None
set_cached(user_question, result_inegi)
return result_inegi
# -- WORLD BANK: detectar keywords -> responder directo con read_worldbank ----
WB_KEYWORDS = [
"exportaciones", "exportacion", "importaciones", "importacion",
"world bank", "banco mundial", "worldbank", "remesas",
"deuda publica", "deuda pública", "pobreza", "desigualdad",
"co2", "emisiones", "area forestal", "electricidad acceso",
"control corrupcion", "efectividad gobierno",
"sp.pop.totl", "indicadores world bank", "indicadores banco mundial",
"resumen world bank", "resumen banco mundial",
]
is_worldbank = any(k in q_lower for k in WB_KEYWORDS)
if is_worldbank:
if stream_placeholder:
stream_placeholder.markdown("*Consulta World Bank → bucket directo...*")
if any(k in q_lower for k in ["exportacion", "importacion", "remesa", "cuenta corriente", "comercio"]):
cat_wb = "comercio"
elif any(k in q_lower for k in ["pobreza", "poblacion", "desempleo", "alfabetizacion", "social"]):
cat_wb = "social"
elif any(k in q_lower for k in ["co2", "emision", "forestal", "energia", "electricidad"]):
cat_wb = "medio_ambiente"
elif any(k in q_lower for k in ["corrupcion", "gobierno", "gobernanza"]):
cat_wb = "gobernanza"
elif any(k in q_lower for k in ["energia", "petroleo"]):
cat_wb = "energia"
else:
cat_wb = "todos"
raw = execute_tool("read_worldbank", {"categoria": cat_wb})
if any(k in q_lower for k in ["poblacion", "población", "personas", "habitantes"]):
raw_social = execute_tool("read_worldbank", {"categoria": "social"})
raw = raw + "\n[SOCIAL WB]:\n" + raw_social
trace.set_route("WORLDBANK")
trace.add_tool("read_worldbank")
result_wb = synthesize_response(raw[:3000], user_question, stream_placeholder)
trace.finish()
set_cached(user_question, result_wb)
return result_wb
# -- TELCO: detectar keywords IFT -> responder directo con read_ift -----------
is_telco = any(k in q_lower for k in TELCO_KEYWORDS)
if is_telco:
if stream_placeholder:
stream_placeholder.markdown("*Consulta telco → IFT datos abiertos...*")
is_cross = any(k in q_lower for k in [
"relacion", "relación", "entre", "compara", "vs", "versus",
"y el", "e ingreso", "e ingresos", "analisis", "análisis", "resumen"
])
if is_cross:
categoria_ift = "todo"
elif any(k in q_lower for k in ["5g", "4g", "lte", "cobertura"]):
categoria_ift = "cobertura_5g"
elif any(k in q_lower for k in ["participacion", "participación", "mercado", "lineas", "líneas"]):
categoria_ift = "participacion_mercado_movil"
elif any(k in q_lower for k in ["ingres", "revenue", "factur"]):
categoria_ift = "ingresos"
elif any(k in q_lower for k in ["portabilidad"]):
result_port = (
"**Portabilidad Numérica México — Datos verificados H1 2025**\n\n"
"| Operador | Saldo H1 2025 | Resultado |\n"
"|---|---|---|\n"
"| Movistar | **+32,667 líneas** | Positivo — mejor operador red propia |\n"
"| Bait (OMV) | **+244,024 líneas** | Positivo — líder captación total |\n"
"| Telcel | Desaceleración 42% vs 2024 | Disputado |\n"
"| AT&T | **-752,664 líneas** | Negativo severo |\n\n"
"**Fuente:** Consolidado semestral IFT, reportado julio 2025 "
"(H1 = enero-junio 2025 — distinto al reporte Q1 enero-marzo)\n\n"
"Para datos por trimestre o más recientes consulta: "
"https://www.ift.org.mx/usuarios-y-audiencias/portabilidad-numerica"
)
if stream_placeholder:
stream_placeholder.markdown(result_port)
trace.set_route("TELCO_PORTABILIDAD")
trace.finish()
_current_trace = None
set_cached(user_question, result_port)
return result_port
elif any(k in q_lower for k in ["tv", "television", "televisión", "restringida"]):
categoria_ift = "television"
elif any(k in q_lower for k in ["regulacion", "regulación", "aep", "preponderante"]):
categoria_ift = "regulacion"
elif any(k in q_lower for k in ["banda ancha", "internet fijo"]):
categoria_ift = "internet_fijo"
else:
categoria_ift = "todo"
raw = execute_tool("read_ift", {"categoria": categoria_ift})
trace.set_route("TELCO")
trace.add_tool("read_ift")
result_telco = synthesize_response(raw[:2000], user_question, stream_placeholder)
trace.finish()
set_cached(user_question, result_telco)
return result_telco
# -- HISTORICO: detectar año o keywords estadisticos -> forzar NUMERICA -------
years_found = _re_orch.findall(r"\b(202[0-9])\b", user_question)
is_historical = bool(years_found) or any(k in q_lower for k in [
"promedio", "histórico", "historico", "average", "mínimo", "minimo",
"máximo", "maximo", "tendencia", "trend", "durante", "evolución",
"evolucion", "estadísticas", "estadisticas", "statistics",
"sf43718", "sf43783", "sf61745", "sp1", "serie", "2024", "2025"
])
# -- PASO 1: Clasificador LLaMA 8B ---------------------------------------------
if stream_placeholder:
stream_placeholder.markdown("*Clasificando pregunta...*")
if is_historical:
complexity = "NUMERICA"
else:
complexity = classify_question(user_question)
# -- PASO 2A: SIMPLE -> bucket directo -----------------------------------------
if complexity == "SIMPLE":
if stream_placeholder:
stream_placeholder.markdown("*Consulta simple → bucket directo...*")
trace.set_route("SIMPLE")
q = user_question.lower()
if any(k in q for k in ["poblacion", "población", "personas hay", "habitantes",
"igae", "ocupacion", "ocupados", "inegi", "inpc",
"desocupacion", "desocupación"]):
raw = execute_tool("read_inegi", {"indicador": "todos"})
elif any(k in q for k in ["tipo de cambio", "exchange", "usd", "mxn", "tasa", "tiie", "inflacion", "inflación"]):
raw = execute_tool("read_banxico", {"indicador": "todos"})
elif any(k in q for k in ["pib", "gdp", "exportaciones", "exportacion", "importaciones",
"importacion", "deuda", "desempleo", "remesas", "world bank",
"banco mundial", "crecimiento", "pobreza"]):
raw = execute_tool("read_worldbank", {"categoria": "todos"})
else:
raw = execute_tool("read_banxico", {"indicador": "todos"})
context = raw[:1500]
result = synthesize_response(context, user_question, stream_placeholder)
trace.add_tool("read_banxico" if "banxico" in q else "read_worldbank" if "pib" in q else "read_inegi")
trace.finish()
_current_trace = None
set_cached(user_question, result)
return result
# -- PASO 2B: NUMERICA -> LLaMA 70B + historico --------------------------------
if complexity == "NUMERICA":
if stream_placeholder:
stream_placeholder.markdown("*Pregunta numérica → histórico...*")
trace.set_route("NUMERICA")
trace.start_stage("historico")
q = user_question.lower()
if any(k in q for k in ["tiie", "interbancaria", "sf43783"]):
serie_hist = "SF43783"
elif any(k in q for k in ["tasa objetivo", "objetivo", "sf61745"]):
serie_hist = "SF61745"
elif any(k in q for k in ["inflacion", "inflación", "ipc", "sp1"]):
serie_hist = "SP1"
else:
serie_hist = "SF43718"
if stream_placeholder:
stream_placeholder.markdown("*🔍 Búsqueda semántica ChromaDB · NVIDIA NIM H100...*")
historico_raw = execute_tool("search_historico", {"serie": serie_hist, "query": user_question})
try:
import json as _json
import re as _re2
hist_data = _json.loads(historico_raw)
registros = hist_data.get("resultados", [])
valores = []
for r in registros:
try:
v = str(r.get("valor", "")).split(" ")[0].replace(",", "")
valores.append(float(v))
except Exception:
pass
if valores:
stats_calc = {
"promedio": round(sum(valores)/len(valores), 4),
"minimo": round(min(valores), 4),
"maximo": round(max(valores), 4),
"primero": valores[0],
"ultimo": valores[-1],
"total": len(valores),
}
else:
stats_calc = hist_data.get("estadisticas", {})
años = hist_data.get("años", _re2.findall(r"\b(202[0-9])\b", user_question))
historico = (
f"Serie: {hist_data.get('nombre', serie_hist)}\n"
f"Período consultado: {años}\n"
f"Total registros: {stats_calc.get('total', len(registros))}\n"
f"Promedio: {stats_calc.get('promedio')}\n"
f"Mínimo: {stats_calc.get('minimo')}\n"
f"Máximo: {stats_calc.get('maximo')}\n"
f"Primer valor: {stats_calc.get('primero')}\n"
f"Último valor: {stats_calc.get('ultimo')}\n"
f"Fuente: {hist_data.get('fuente', 'Banxico SIE API · Histórico')}"
)
except Exception:
historico = historico_raw[:1500]
msgs = [
{"role": "system", "content": SYSTEM_STRICT},
{"role": "user", "content":
f"DATOS HISTÓRICOS EXACTOS:\n{historico}\n\n"
f"USA ESTOS DATOS para responder.\n"
f"PREGUNTA: {user_question}"
}
]
answer, error = call_model_groq(MODEL_NUMERICAL, msgs, max_tokens=700)
if error:
return f"⚠️ Error numérico: {error}"
if stream_placeholder:
stream_placeholder.markdown("*Validando datos...*")
validated = validate_response(answer, historico[:500], user_question)
if stream_placeholder:
stream_placeholder.markdown(validated)
return validated
# -- PASO 2C: NARRATIVA multi-fuente -> paralelo + LLaMA 70B -------------------
if needs_multi_source(user_question):
try:
loop = asyncio.get_event_loop()
if loop.is_closed():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
context = loop.run_until_complete(prefetch_all_parallel(stream_placeholder))
except Exception:
parts = []
for tool, args in [("read_banxico", {"indicador": "todos"}),
("read_worldbank", {"categoria": "economia"}),
("read_inegi", {"indicador": "todos"})]:
parts.append(execute_tool(tool, args)[:500])
context = "\n".join(parts)
trace.set_route("NARRATIVA")
if stream_placeholder:
stream_placeholder.markdown("*Analizando con LLaMA 70B...*")
msgs = [
{"role": "system", "content": SYSTEM_STRICT},
{"role": "user", "content":
f"DATOS REALES DE LAS 3 FUENTES:\n{context}\n\n"
f"PREGUNTA: {user_question}"
}
]
narrative, error = call_model(MODEL_NARRATIVE, msgs, max_tokens=700)
if error:
narrative = context
final = synthesize_response(context, user_question, stream_placeholder)
if stream_placeholder:
stream_placeholder.markdown("*Validando respuesta...*")
validated = validate_response(final, context[:500], user_question)
if stream_placeholder:
stream_placeholder.markdown(validated)
return validated
# -- PASO 2D: NARRATIVA mono-fuente -> tool calling con LLaMA 70B --------------
headers = {
"Authorization": f"Bearer {NVIDIA_API_KEY}",
"Content-Type": "application/json",
}
msgs_trimmed = messages[-4:] if len(messages) > 4 else messages
current_messages = [{"role": "system", "content": SYSTEM_STRICT}] + msgs_trimmed
tool_results = []
for iteration in range(5):
payload = {
"model": MODEL_NARRATIVE,
"messages": current_messages,
"tools": TOOLS,
"tool_choice": "auto",
"temperature": 0.1,
"max_tokens": 700,
"stream": False,
}
if stream_placeholder:
stream_placeholder.markdown(f"*LLaMA 70B consultando... (iter {iteration+1})*")
try:
r = requests.post(
f"{NVIDIA_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=180,
)
r.raise_for_status()
response = r.json()
except requests.exceptions.HTTPError as e:
if "400" in str(e) and tool_results:
fallback = synthesize_response("\n".join(tool_results), user_question, stream_placeholder)
return validate_response(fallback, "\n".join(tool_results[:2]))
return f"⚠️ Error HTTP: {e}"
except Exception as e:
return f"⚠️ Error: {e}"
choice = response["choices"][0]
finish_reason = choice.get("finish_reason", "")
message = choice["message"]
if finish_reason == "stop" or not message.get("tool_calls"):
answer = message.get("content", "Sin respuesta.")
validated = validate_response(answer, "\n".join(tool_results[:2]) if tool_results else "", user_question)
if stream_placeholder:
stream_placeholder.markdown(validated)
return validated
tool_calls = message.get("tool_calls", [])
current_messages.append({
"role": "assistant",
"content": message.get("content", ""),
"tool_calls": tool_calls,
})
for tc in tool_calls:
tool_name = tc["function"]["name"]
try:
tool_args = json.loads(tc["function"]["arguments"])
except Exception:
tool_args = {}
if stream_placeholder:
stream_placeholder.markdown(f"*Ejecutando: {tool_name}...*")
if tool_name == "search_historico" and "query" not in tool_args:
tool_args["query"] = user_question
result = execute_tool(tool_name, tool_args)
if len(result) > 1500:
result = result[:1500] + " [truncado]"
tool_results.append(f"[{tool_name}]: {result[:500]}")
current_messages.append({
"role": "tool",
"tool_call_id": tc["id"],
"name": tool_name,
"content": result,
})
return "⚠️ Se alcanzó el límite de iteraciones."
def run_agent(user_question: str, history: list = None, stream_placeholder=None) -> str:
if history is None:
history = []
messages = history + [{"role": "user", "content": user_question}]
return call_llm_with_tools(messages, stream_placeholder)
if __name__ == "__main__":
preguntas = [
"¿Cuál es el tipo de cambio hoy?",
"¿Cuál fue el tipo de cambio en enero 2025?",
"¿Cuál es la participación de mercado de Telcel?",
"Dame un análisis económico completo de México cruzando Banxico, World Bank e INEGI",
]
for p in preguntas:
print(f"\nP: {p}")
print(f"R: {run_agent(p)}") |