Spaces:
Sleeping
Sleeping
Download modules/agent_orchestrator.py from Fercor95mx/mx-data-api: direct link, hf CLI and curl.
- Browser
- Download file 46 kB
-
https://huggingface.co/spaces/Fercor95mx/mx-data-api/resolve/main/modules/agent_orchestrator.py
- Command line
-
hf download hf://spaces/Fercor95mx/mx-data-api/modules/agent_orchestrator.py
-
curl -L -o agent_orchestrator.py https://huggingface.co/spaces/Fercor95mx/mx-data-api/resolve/main/modules/agent_orchestrator.py
46 kB
| """ | |
| 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)}") |