Ir al contenido principal
Español— Elegir un idioma
Menú

Configurar y controlar los resultados web

Lección 6 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Configurar y controlar los resultados web
  2. El parámetro search_context_size
  3. Orientar las consultas de búsqueda mediante el prompt
  4. Extraer y estructurar citas
  5. Patrón: búsqueda con validación cruzada
  6. Gestionar la ausencia de resultados
  7. Búsqueda web con streaming
  8. Filtrar dominios y listar fuentes
  9. Puntos clave

Lección actualizada el 2 de noviembre de 2026 según la documentación de OpenAI: la herramienta Code Interpreter requiere un parámetro container (añadido a todos los ejemplos), las partes de texto de entrada son de tipo input_text, y la búsqueda web utiliza la herramienta web_search (web_search_preview es ahora una herramienta heredada sin filtros de dominio). Los archivos generados se recuperan mediante las funciones fichiers_generes y telecharger de la Lección 10. Fuentes: Code Interpreter · Búsqueda web.

Configurar y controlar los resultados web

Activar la búsqueda web requiere una sola línea; obtener respuestas fiables exige tres ajustes que esta lección detalla. El primero decide cuánta información web se inyecta en el contexto y afecta directamente a tu factura. El segundo orienta las consultas que el modelo formula por sí mismo —porque las escribe él, no tú—. El tercero concierne a las citas; sin ellas, una respuesta con fuentes no es más que una afirmación.

El parámetro search_context_size

El parámetro search_context_size controla la cantidad de contenido web que se inyecta en el contexto del modelo. No modifica ni el número de búsquedas ni su calidad: determina cuánto texto, una vez localizadas las páginas, entra realmente en el prompt. Se trata de un equilibrio entre exhaustividad y coste, que debes ajustar según el tipo de tarea, no configurar una vez y olvidar.

from openai import OpenAI

client = OpenAI()

# Contexto mínimo: respuestas rápidas y concisas
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is France's GDP in 2025?",
    tools=[{
        "type": "web_search",
        "search_context_size": "low"
    }]
)

# Contexto medio: buen compromiso (predeterminado)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Summarize AI market trends in Europe",
    tools=[{
        "type": "web_search",
        "search_context_size": "medium"
    }]
)

# Contexto amplio: análisis en profundidad
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare AI strategies in France, Germany, and the Netherlands",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Impacto en costes y latencia

La regla es sencilla: sube un nivel solo cuando la respuesta obtenida te haya decepcionado concretamente. Una fecha, una cifra o una confirmación factual no necesitan más que low; usar high para eso es como pagar un dosier completo para leer una línea.

TamañoTokens de contextoLatenciaCosteUso
lowMínimoRápidaBajoDatos simples, cifras
mediumModeradoEstándarMedioResúmenes, comparativas
highMáximoLentaAltoAnálisis en profundidad

Orientar las consultas de búsqueda mediante el prompt

He aquí el punto que la mayoría descubre demasiado tarde: el modelo formula sus propias consultas de búsqueda. Tú escribes «¿cuáles son los cambios regulatorios recientes?» y él lo traduce a palabras clave que nunca ves. Por tanto, la calidad del resultado depende de una reformulación sobre la que solo tienes control indirecto: el prompt del sistema. Nombra las fuentes autorizadas de tu sector y el periodo que te interesa: eso es lo que más influye.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Eres un analista de mercado especializado en tecnología europea. "
        "Cuando realices búsquedas web, prioriza fuentes institucionales "
        "(Comisión Europea, INSEE, Eurostat) y medios especializados "
        "(Les Echos, La Tribune, TechCrunch). "
        "Ignora blogs personales y foros."
    ),
    input="What is the state of AI startup funding in France?",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Extraer y estructurar citas

Las citas llegan como anotaciones adjuntas a la respuesta, no dentro del texto mismo. Esta separación es una buena noticia: te permite mostrar las fuentes como prefieras, verificarlas o rechazar una respuesta que carezca de ellas. En cualquier aplicación donde la respuesta tenga peso —legal, médico, financiero—, tratar la ausencia de anotaciones como un error es más seguro que confiar en el texto.

def extract_sources(response) -> list[dict]:
    """Extrae todas las citas de URL de una respuesta de Búsqueda Web."""
    sources = []
    for item in response.output:
        if item.type == "message":
            for block in item.content:
                if hasattr(block, "annotations"):
                    for ann in block.annotations:
                        if ann.type == "url_citation":
                            sources.append({
                                "url": ann.url,
                                "title": ann.title,
                                "excerpt_start": ann.start_index,
                                "excerpt_end": ann.end_index
                            })
    return sources

# Uso
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What are the new GDPR rules for AI in 2026?",
    tools=[{"type": "web_search"}]
)

sources = extract_sources(response)
for s in sources:
    print(f"  {s['title']}: {s['url']}")

Patrón: búsqueda con validación cruzada

Una única fuente sigue siendo una única fuente, aunque la haya encontrado un modelo. Para información que impulse una decisión, pide explícitamente confirmación desde múltiples fuentes independientes y haz que el modelo señale las discrepancias en lugar de arbitrarlas en silencio: un desacuerdo entre dos fuentes es en sí mismo información, a menudo más útil que promediar ambas.

def validated_search(question: str, min_sources: int = 3) -> dict:
    """Búsqueda web que requiere múltiples fuentes."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            f"Para responder a esta pregunta, debes encontrar al menos "
            f"{min_sources} fuentes independientes que confirmen la información. "
            "Si las fuentes se contradicen, señala las discrepancias. "
            "Cita cada fuente explícitamente."
        ),
        input=question,
        tools=[{
            "type": "web_search",
            "search_context_size": "high"
        }]
    )

    sources = extract_sources(response)
    return {
        "answer": response.output_text,
        "sources": sources,
        "reliability": "high" if len(sources) >= min_sources else "verify"
    }

Gestionar la ausencia de resultados

Hay un caso que se olvida manejar: la búsqueda no devuelve nada. El riesgo no es la falta de respuesta, sino que, al carecer de resultados, el modelo responda desde su conocimiento interno sin indicarlo, ofreciéndote información plausible pero desactualizada. Pídele que lo diga explícitamente y prevé una reformulación.

def search_with_fallback(question: str) -> dict:
    """Búsqueda web con detección de fallos y reformulación."""
    # Primer intento
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=question,
        tools=[{"type": "web_search"}]
    )

    sources = extract_sources(response)

    if len(sources) == 0:
        # Reformulación automática
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Reformula esta pregunta para una búsqueda web más efectiva, "
                  f"luego busca: {question}",
            tools=[{"type": "web_search", "search_context_size": "high"}]
        )
        sources = extract_sources(response)

    return {
        "answer": response.output_text,
        "sources": sources
    }

Búsqueda web con streaming

Una búsqueda web tarda unos segundos, a veces más si el modelo encadena varias consultas. Con el streaming, el usuario ve cómo se construye la respuesta en lugar de mirar un indicador de carga; para este tipo de latencia, la diferencia de percepción es enorme con un coste de implementación casi nulo.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What are this week's tech news headlines?",
    tools=[{"type": "web_search"}],
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        # Extraer fuentes al final
        sources = extract_sources(event.response)
        print(f"\n\n--- {len(sources)} sources consulted ---")

Filtrar dominios y listar fuentes

La herramienta web_search acepta un parámetro filters que restringe la búsqueda a una lista de dominios permitidos (hasta 100) o excluye una lista (también hasta 100). Escribe los dominios sin http:// ni https://. El filtrado solo existe con web_search en la API de Responses: la herramienta heredada web_search_preview lo ignora.

response = client.responses.create(
    model="gpt-5.6-terra",
    tools=[{
        "type": "web_search",
        "filters": {"allowed_domains": ["service-public.fr", "legifrance.gouv.fr"]},
    }],
    include=["web_search_call.action.sources"],
    input="What are the price display requirements for retail stores in France?",
)
print(response.output_text)

La opción include=["web_search_call.action.sources"] devuelve la lista completa de URL consultadas, a menudo más larga que la lista de citas. Las citas en sí llegan como anotaciones url_citation (URL, título, posición en el texto): la documentación de OpenAI solicita que las muestres de forma visible y clicable en tu interfaz.

Puntos clave

  • search_context_size controla el volumen de datos web inyectados
  • filters restringe o excluye dominios (máx. 100); include lista todas las fuentes consultadas
  • El prompt del sistema guía al modelo hacia las fuentes adecuadas
  • Extrae las anotaciones url_citation para rastrear las fuentes
  • Implementa validación cruzada para información crítica
  • Gestiona la ausencia de resultados con reformulación automática