Qué cambia cuando un modelo busca antes de responder

Son las 7:40 de la mañana en Guadalajara. Lucía Ortega, analista de medios de Faro Comunicación, tiene veinte minutos para mandar a Mieles del Mayab el resumen del día: qué se publicó sobre el precio de la miel, si hubo cambios en requisitos de exportación, si algún medio mencionó a la empresa. Hace meses probó pedirle ese resumen a un chatbot y recibió un texto impecable con dos problemas: una noticia era de hace un año y otra no existía. Desde entonces desconfía, con razón.

En esta lección no escribes todavía una llamada real (eso es la lección 1.2). Primero entiendes por qué un modelo que busca se comporta distinto, qué puede salir mal incluso cuando busca, y qué ofrece hoy la API de Perplexity para construir este tipo de sistemas.

Al terminar podrás:

• explicar por qué un modelo de lenguaje sin búsqueda no sirve para preguntas sobre hechos recientes;
• describir el ciclo buscar, leer y redactar, y en qué punto puede fallar cada paso;
• distinguir las cuatro APIs de Perplexity y saber cuál usar para cada problema;
• reconocer código antiguo de Sonar y saber que hoy se traduce a la Agent API.

Un modelo que solo recuerda

Un modelo de lenguaje aprende de una enorme cantidad de texto reunido hasta una fecha de corte. Después de entrenarse, sus parámetros quedan fijos. Cuando le preguntas algo, no consulta ninguna base de datos: genera texto que se parece al que vio durante el entrenamiento.

De ahí salen tres limitaciones que importan mucho para el trabajo de Lucía:

1. No sabe lo que pasó después de su corte. Una noticia de esta mañana simplemente no existe para él.
2. No distingue bien entre recordar e inventar. Si la pregunta suena a algo que "debería" saber, puede producir una respuesta plausible sin base. Los nombres de medios, fechas y cifras son terreno fértil para estos errores.
3. No puede decirte de dónde sacó algo. Aunque acierte, no hay un documento que puedas abrir para comprobarlo.

Para escribir un correo o explicar un concepto general eso no es grave. Para un resumen de prensa que un cliente va a leer y quizá reenviar a su consejo, es inaceptable.

Un modelo que busca

La idea de la búsqueda con IA es sencilla: antes de redactar, el sistema consulta un buscador web, recupera fragmentos de páginas relevantes y se los entrega al modelo junto con la pregunta. El modelo ya no responde "de memoria", sino a partir de textos que tiene enfrente. A esto se le llama anclar la respuesta en fuentes (en inglés, grounding).

El ciclo completo tiene tres pasos:

pregunta de Lucía
   -> BUSCAR: el sistema genera consultas cortas y las manda a un buscador
   -> LEER: recupera resultados (título, URL, fecha, fragmento de texto)
   -> REDACTAR: el modelo escribe la respuesta usando esos fragmentos
      y marca qué oración viene de qué resultado

En los sistemas más simples el ciclo se ejecuta una vez. En los más elaborados, el modelo decide buscar otra vez si lo que encontró no alcanza, abre una página completa para leerla a fondo o combina resultados de varias rondas. A esos sistemas se les suele llamar agentes de investigación, y la Agent API de Perplexity está pensada para ellos.

Cada paso puede fallar por su cuenta

Que un modelo busque no garantiza que acierte. Conviene saber dónde están los puntos débiles desde el primer día:

• Buscar mal. Si las consultas que genera el sistema son vagas, los resultados también. "Miel noticias" trae cualquier cosa; "exportación miel Yucatán 2026" trae algo mucho más útil.
• Leer fuentes pobres. El buscador puede devolver un blog sin autor, una nota copiada de otra o una página vieja con fecha reciente. El modelo no sabe distinguir siempre la calidad.
• Redactar más allá de las fuentes. El modelo puede mezclar lo que leyó con lo que "recuerda", o atribuir a una fuente algo que esa fuente no dice. Una cita con número no prueba que el dato esté en la página.

Por eso este curso dedica tanto espacio a filtros (lección 2.2) y a verificación (lección 4.1). La búsqueda reduce el problema de las respuestas inventadas, pero no lo elimina.

Ver el patrón sin gastar ni un centavo

Antes de tocar la API, arma a mano lo que un sistema de búsqueda le entrega al modelo. Este script no llama a ningún servicio: solo construye el texto que recibiría el modelo con tres resultados inventados para el ejemplo.

# armar_contexto.py
from datetime import date

resultados = [
    {
        "id": 1,
        "titulo": "Productores de Yucatán reportan baja en la cosecha de miel",
        "url": "https://ejemplo-diario.mx/campo/miel-cosecha",
        "fecha": "2026-10-10",
        "fragmento": "La cosecha de la temporada se redujo por la sequía, según la asociación local de apicultores.",
    },
    {
        "id": 2,
        "titulo": "Nuevos requisitos de etiquetado para exportar miel a Europa",
        "url": "https://ejemplo-gobierno.mx/comunicados/etiquetado-miel",
        "fecha": "2026-10-08",
        "fragmento": "Las empresas exportadoras deberán indicar el país de origen de cada lote mezclado.",
    },
    {
        "id": 3,
        "titulo": "Receta de galletas con miel para el fin de semana",
        "url": "https://ejemplo-recetas.mx/galletas-miel",
        "fecha": "2025-03-02",
        "fragmento": "Mezcla dos tazas de harina con media taza de miel.",
    },
]


def armar_contexto(pregunta: str, resultados: list[dict]) -> str:
    bloques = []
    for r in resultados:
        bloques.append(
            f"[{r['id']}] {r['titulo']} ({r['fecha']})\n{r['url']}\n{r['fragmento']}"
        )
    fuentes = "\n\n".join(bloques)
    return (
        f"Fecha de hoy: {date.today().isoformat()}\n\n"
        f"Fuentes encontradas:\n\n{fuentes}\n\n"
        f"Pregunta: {pregunta}\n"
        "Responde solo con lo que dicen las fuentes y marca cada dato con [n]."
    )


if __name__ == "__main__":
    print(armar_contexto("¿Qué pasó esta semana con la miel de Yucatán?", resultados))

Ejecútalo con uv run armar_contexto.py (o python armar_contexto.py) y lee la salida como si fueras el modelo. Observa tres cosas:

• La fecha de hoy aparece en el contexto. Sin ella, el modelo no puede saber si "esta semana" incluye un texto del 8 de octubre.
• Cada fuente tiene un número. Eso es lo que permite que la respuesta diga "[2]" y que tu código sepa a qué URL apunta.
• La tercera fuente no sirve. Es de otro año y de otro tema. Un buen sistema la descarta; uno ingenuo podría mencionarla. En la vida real verás resultados así con frecuencia.

La API de Perplexity hace todo esto por ti, con un buscador real y un modelo que decide qué consultas lanzar. Pero tener este esquema en la cabeza te ayuda a depurar: cuando una respuesta salga mal, la primera pregunta será si el problema estuvo al buscar, al leer o al redactar.

Qué ofrece hoy la API de Perplexity

La plataforma de Perplexity tiene varias APIs que comparten la misma cuenta y la misma clave. Según su documentación (consultada en octubre de 2026), las principales son:

En este curso nos concentramos en las dos primeras, que son las que resuelven la búsqueda con fuentes. La Agent API, además, deja elegir entre modelos de varios proveedores (OpenAI, Anthropic, Google, xAI y el propio modelo Sonar de Perplexity, entre otros) y agregar herramientas como web_search o fetch_url.

Qué pasó con Sonar

Si buscas tutoriales de Perplexity, la mayoría te mostrará algo así:

# Estilo antiguo (Sonar Chat Completions): solo para reconocerlo
completion = client.chat.completions.create(
    model="sonar-pro",
    messages=[{"role": "user", "content": "Noticias de exportación de miel"}],
)
print(completion.choices[0].message.content)

Ese era el formato de Sonar: un endpoint compatible con Chat Completions, con modelos llamados sonar, sonar-pro, sonar-reasoning-pro y sonar-deep-research, y parámetros de búsqueda en el primer nivel de la petición. La documentación oficial indica que el soporte de Sonar Chat Completions terminó el 27 de septiembre de 2026: las peticiones síncronas y en streaming se siguen atendiendo mientras se reformulan como peticiones de la Agent API, y las asíncronas ya no se admiten.

Para ti eso significa dos cosas. Primera: escribe código nuevo para la Agent API, que es lo que hacemos desde la lección 1.2. Segunda: cuando heredes código con chat.completions.create y modelos sonar-*, no lo tires; en la lección 1.3 tienes la tabla para traducirlo.

Lo que la búsqueda con IA hace bien y lo que no

La última fila sorprende a mucha gente: dos llamadas idénticas pueden traer resultados distintos, porque la web cambia y porque el sistema puede lanzar consultas distintas. Si necesitas reproducibilidad (por ejemplo, para un reporte que se audita), guarda las fuentes y la respuesta en el momento en que las obtienes. Lo haremos con una caché en la lección 4.1.

Práctica

Dedica 25 minutos. No necesitas clave todavía.

1. Ejecuta armar_contexto.py. Agrega un cuarto resultado que contradiga al primero (por ejemplo, otra fuente que diga que la cosecha subió) y piensa cómo debería responder un buen sistema.
2. Escribe tres preguntas que Lucía haría a diario para Mieles del Mayab. Para cada una, anota dos consultas cortas de búsqueda (de dos a cinco palabras) que tú lanzarías.
3. Para esas mismas preguntas, decide qué tipos de fuente aceptarías (medios nacionales, sitios de gobierno, asociaciones del sector) y cuáles descartarías. Guarda la lista: la usarás como filtro de dominios en la lección 2.2.
4. Busca en internet un tutorial antiguo de Perplexity. Identifica el modelo sonar-* que usa y anota qué parámetros de búsqueda aparecen en el primer nivel de la petición.

Resumen

• Un modelo sin búsqueda solo conoce lo que vio hasta su fecha de corte y no puede señalar fuentes.
• La búsqueda con IA sigue el ciclo buscar, leer y redactar; cada paso puede fallar por separado.
• Una cita numerada indica qué resultado usó el modelo, pero no prueba que el dato esté en esa página.
• Perplexity ofrece la Agent API (respuestas redactadas con búsqueda), la Search API (resultados crudos), Embeddings y la Orchestrator API.
• El soporte de Sonar Chat Completions terminó el 27 de septiembre de 2026; el código nuevo va a la Agent API.

Quiz