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

Búsqueda híbrida: combinación de web y archivos

Lección 9 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Búsqueda híbrida: combinación de web y archivos
  2. Activar ambas herramientas
  3. Caso de uso: vigilancia normativa
  4. Caso de uso: enriquecimiento de la base de conocimientos
  5. Añadir funciones personalizadas a la mezcla
  6. Gestionar la prioridad de las fuentes
  7. Patrón completo: asistente de búsqueda híbrida
  8. Puntos clave

Lección actualizada el 2 de noviembre de 2026 según la documentación de OpenAI: la herramienta Code Interpreter requiere ahora 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.

Búsqueda híbrida: combinación de web y archivos

Las dos herramientas de búsqueda responden a preguntas distintas y, si se usan por separado, cada una resulta incompleta. File Search conoce lo que tú has escrito; Web Search conoce lo que el mundo ha publicado. Muchas preguntas útiles se sitúan exactamente en la intersección de ambas: ¿Sigue siendo conforme nuestro procedimiento? ¿Está nuestra documentación actualizada? ¿Cuál es nuestra posición respecto al mercado?

Estas preguntas comparten una propiedad común que explica su valor: nadie puede responderlas sin leer ambas partes. Es este cruce, y no la búsqueda en sí misma, lo que hace valiosa esta lección.

Activar ambas herramientas

Declara ambas herramientas simultáneamente en el array tools:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compara nuestra política de teletrabajo con las tendencias actuales del mercado",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["vs_abc123"],
            "max_num_results": 10
        },
        {
            "type": "web_search",
            "search_context_size": "medium"
        }
    ]
)

print(response.output_text)

El modelo decide por sí mismo cuándo usar cada herramienta. Para una pregunta sobre tus documentos internos, utilizará File Search. Para datos públicos, usará Web Search. Para una comparación, empleará ambas.

Caso de uso: vigilancia normativa

La vigilancia normativa es el ejemplo de libro de texto porque la brecha entre las dos fuentes es precisamente lo que buscamos. Pide explícitamente diferencias, no un resumen de cada parte: si pides al modelo que haga un resumen, producirá dos síntesis correctas y te dejará a ti la comparación, que es la única parte difícil del trabajo.

def audit_conformite(sujet: str, vs_processus: str) -> dict:
    """Compara los procesos internos con la normativa vigente."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            "Eres un auditor de cumplimiento. Para cada punto, debes: "
            "1. Buscar en los documentos internos qué hay actualmente establecido "
            "2. Buscar en la web la normativa aplicable vigente "
            "3. Identificar las brechas entre ambos "
            "4. Proponer acciones correctoras"
        ),
        input=f"Audita el cumplimiento de nuestros procesos sobre el tema: {sujet}",
        tools=[
            {
                "type": "file_search",
                "vector_store_ids": [vs_processus],
                "max_num_results": 15
            },
            {
                "type": "web_search",
                "search_context_size": "high"
            }
        ]
    )

    return {
        "rapport": response.output_text,
        "tokens_utilises": response.usage.total_tokens
    }

# Uso
rapport = audit_conformite(
    "protección de datos personales y RGPD",
    "vs_processus_internes"
)

Caso de uso: enriquecimiento de la base de conocimientos

El mismo mecanismo, invertido, sirve para verificar la antigüedad de tus propios documentos: en lugar de verificar el cumplimiento, preguntas qué ha cambiado desde que se redactaron. Este es el uso más rentable de la búsqueda híbrida sobre una base documental antigua; nadie tiene tiempo de releer cien páginas para encontrar las tres que han envejecido.

def detecter_obsolescence(vs_id: str, sujets: list[str]) -> list[dict]:
    """Identifica información potencialmente obsoleta."""
    resultats = []

    for sujet in sujets:
        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions=(
                "Compara lo que dicen nuestros documentos internos con la información "
                "más reciente de la web. Identifica lagunas factuales, cifras desactualizadas "
                "y procedimientos obsoletos."
            ),
            input=f"Verifica la vigencia de nuestros documentos sobre: {sujet}",
            tools=[
                {"type": "file_search", "vector_store_ids": [vs_id]},
                {"type": "web_search"}
            ]
        )

        resultats.append({
            "sujet": sujet,
            "analyse": response.output_text
        })

    return resultats

Añadir funciones personalizadas a la mezcla

Añadir tus funciones a la mezcla traslada el flujo de trabajo del análisis a la acción: el modelo detecta una brecha y luego abre un ticket. Sin embargo, mantén un límite claro: la búsqueda y el análisis pueden permanecer automáticos, pero las acciones que comprometen recursos (crear, enviar, modificar) merecen validación humana hasta que hayas medido la fiabilidad del flujo durante varias semanas.

tools = [
    # Buscar en tus documentos
    {
        "type": "file_search",
        "vector_store_ids": ["vs_contrats"],
        "max_num_results": 10
    },
    # Búsqueda web
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Función de negocio: consultar el CRM
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Recuperar información del cliente desde el CRM",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "champs": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "Lista de campos a devolver"
                }
            },
            "required": ["client_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    # Función de negocio: crear una alerta
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Crear una alerta de seguimiento para un contrato o cliente",
        "parameters": {
            "type": "object",
            "properties": {
                "titre": {"type": "string"},
                "priorite": {"type": "string", "enum": ["basse", "moyenne", "haute", "critique"]},
                "description": {"type": "string"},
                "assignee": {"type": "string"}
            },
            "required": ["titre", "priorite", "description", "assignee"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# El modelo ahora puede:
# 1. Buscar un contrato en File Search
# 2. Verificar una cláusula en la web
# 3. Recuperar información del cliente desde el CRM
# 4. Crear una alerta si se detecta un problema
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Comprueba si el contrato del cliente CLI-42567 cumple con las nuevas "
          "normas europeas. Si no es así, crea una alerta de alta prioridad.",
    tools=tools
)

Gestionar la prioridad de las fuentes

Sin instrucciones, el modelo trata ambas fuentes por igual. Rara vez es esto lo que deseas: para hechos internos (cifras, procedimientos, decisiones), tus documentos son autoritativos y la web es solo ruido plausible; para noticias y normativas, ocurre lo contrario. Escribe esta jerarquía en el prompt del sistema y exige que cualquier conflicto entre ambas se señale explícitamente en lugar de arbitrarse en silencio.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Reglas de prioridad de fuentes: "
        "1. Para hechos internos (procesos, políticas, contratos) -> File Search "
        "2. Para hechos externos (leyes, mercado, tendencias) -> Web Search "
        "3. En caso de conflicto entre fuentes internas y externas, señala la brecha "
        "4. NUNCA respondas basándote únicamente en tu propio conocimiento "
    ),
    input="¿Cuál es nuestro plazo de pago estándar y es conforme a la ley?",
    tools=[
        {"type": "file_search", "vector_store_ids": [vs_id]},
        {"type": "web_search"}
    ]
)

Patrón completo: asistente de búsqueda híbrida

class AssistantRecherche:
    def __init__(self, vector_store_ids: list[str]):
        self.client = OpenAI()
        self.vs_ids = vector_store_ids
        self.historique = []

    def rechercher(self, question: str, mode: str = "hybride") -> dict:
        tools = []

        if mode in ("hybride", "interne"):
            tools.append({
                "type": "file_search",
                "vector_store_ids": self.vs_ids,
                "max_num_results": 10
            })

        if mode in ("hybride", "web"):
            tools.append({
                "type": "web_search",
                "search_context_size": "medium"
            })

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            instructions="Cita siempre tus fuentes. Distingue claramente "
                        "la información interna de la pública.",
            input=question,
            tools=tools
        )

        resultat = {
            "question": question,
            "reponse": response.output_text,
            "mode": mode,
            "tokens": response.usage.total_tokens
        }
        self.historique.append(resultat)
        return resultat

# Uso
assistant = AssistantRecherche(["vs_contrats", "vs_procedures"])
r = assistant.rechercher("¿Están nuestras CGV actualizadas con la legislación europea?")
print(r["reponse"])

Puntos clave

  • Combina file_search y web_search en una única llamada
  • El modelo elige automáticamente la herramienta adecuada para cada necesidad
  • El prompt del sistema guía la prioridad entre fuentes internas y externas
  • Añade funciones personalizadas para flujos de trabajo completos
  • La búsqueda híbrida es ideal para auditorías de cumplimiento y vigilancia