""" 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)}")