Recherche hybride : combiner web et fichiers

Les deux outils de recherche répondent à des questions différentes et, prises séparément, chacune reste incomplète. File Search sait ce que vous avez écrit ; Web Search sait ce que le monde a publié. Beaucoup de questions utiles se situent exactement à l’intersection des deux : notre procédure est-elle encore conforme, notre documentation est-elle à jour, où en sommes-nous par rapport au marché.

Ces questions ont une propriété commune qui explique leur intérêt : personne ne peut y répondre sans lire les deux côtés. C’est ce croisement, et non la recherche elle-même, qui fait la valeur de cette leçon.

Activer les deux outils

Déclarez les deux outils simultanément dans le tableau tools :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare notre politique de télétravail avec les tendances actuelles du marche",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["vs_abc123"],
            "max_num_results": 10
        },
        {
            "type": "web_search_preview",
            "search_context_size": "medium"
        }
    ]
)

print(response.output_text)

Le modèle décide de lui-même quand utiliser chaque outil. Pour une question sur vos documents internes, il utilisera File Search. Pour des données publiques, Web Search. Pour une comparaison, les deux.

Cas d’usage : veille réglementaire

La veille réglementaire est le cas d’école, parce que l’écart entre les deux sources est précisément ce qu’on cherche. Demandez explicitement les différences, pas un résumé de chaque côté : un modèle à qui l’on demande de résumer produira deux synthèses correctes et vous laissera faire la comparaison, c’est-à-dire le seul travail difficile.

def audit_conformite(sujet: str, vs_processus: str) -> dict:
    """Compare les processus internes avec la réglementation en vigueur."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            "Tu es un auditeur de conformite. Pour chaque point, tu dois : "
            "1. Chercher dans les documents internes ce qui est en place "
            "2. Chercher sur le web la réglementation actuelle applicable "
            "3. Identifier les écarts entre les deux "
            "4. Proposer des actions correctives"
        ),
        input=f"Audite la conformite de nos processus sur le sujet : {sujet}",
        tools=[
            {
                "type": "file_search",
                "vector_store_ids": [vs_processus],
                "max_num_results": 15
            },
            {
                "type": "web_search_preview",
                "search_context_size": "high"
            }
        ]
    )

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

# Utilisation
rapport = audit_conformite(
    "protection des données personnelles et RGPD",
    "vs_processus_internes"
)

Cas d’usage : enrichissement de base de connaissances

Le même mécanisme, retourné, sert à faire vieillir vos propres documents : au lieu de vérifier que vous êtes conforme, vous demandez ce qui a changé depuis leur rédaction. C’est l’usage le plus rentable de la recherche hybride sur une base documentaire ancienne — personne n’a le temps de relire cent pages pour trouver les trois qui ont vieilli.

def detecter_obsolescence(vs_id: str, sujets: list[str]) -> list[dict]:
    """Identifie les informations potentiellement obsolètes."""
    resultats = []

    for sujet in sujets:
        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions=(
                "Compare ce que disent nos documents internes avec les informations "
                "les plus récentes du web. Identifie les écarts factuels, "
                "les chiffres desactualises et les procédures périmées."
            ),
            input=f"Vérifie l'actualite de nos documents sur : {sujet}",
            tools=[
                {"type": "file_search", "vector_store_ids": [vs_id]},
                {"type": "web_search_preview"}
            ]
        )

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

    return resultats

Ajouter des fonctions personnalisées au mix

Ajouter vos fonctions au mélange fait passer de l’analyse à l’action : le modèle constate un écart, puis ouvre le ticket. Gardez cependant une frontière nette — la recherche et l’analyse peuvent rester automatiques, l’action qui engage (créer, envoyer, modifier) mérite une validation humaine tant que vous n’avez pas mesuré la fiabilité du flux sur plusieurs semaines.

tools = [
    # Recherche dans vos documents
    {
        "type": "file_search",
        "vector_store_ids": ["vs_contrats"],
        "max_num_results": 10
    },
    # Recherche web
    {
        "type": "web_search_preview",
        "search_context_size": "medium"
    },
    # Fonction métier : interroger le CRM
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Récupérer les informations d'un client depuis le CRM",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "champs": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "Liste des champs a retourner"
                }
            },
            "required": ["client_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    # Fonction métier : créer une alerte
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Créer une alerte de suivi pour un contrat ou un client",
        "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
    }
]

# Le modèle peut maintenant :
# 1. Chercher un contrat dans File Search
# 2. Vérifier une clause sur le web
# 3. Récupérer les infos client dans le CRM
# 4. Creer une alerte si un probleme est detecte
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vérifie si le contrat du client CLI-42567 est conforme aux nouvelles "
          "normes europeennes. Si ce n'est pas le cas, cree une alerte haute priorite.",
    tools=tools
)

Gérer la priorité entre sources

Sans consigne, le modèle traite les deux sources à égalité. C’est rarement ce que vous voulez : sur les faits internes — chiffres, procédures, décisions — vos documents font autorité et le web n’est qu’un bruit plausible ; sur l’actualité et la réglementation, c’est l’inverse. Écrivez cette hiérarchie dans le prompt système, et demandez qu’un conflit entre les deux soit signalé plutôt qu’arbitré silencieusement.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Règles de priorité des sources : "
        "1. Pour les faits internes (processus, politiques, contrats) -> File Search "
        "2. Pour les faits externes (lois, marche, tendances) -> Web Search "
        "3. En cas de conflit entre source interne et externe, signale l'écart "
        "4. Ne réponds JAMAIS en te basant uniquement sur tes connaissances "
    ),
    input="Quel est notre délai de paiement standard et est-il conforme a la loi ?",
    tools=[
        {"type": "file_search", "vector_store_ids": [vs_id]},
        {"type": "web_search_preview"}
    ]
)

Pattern complet : assistant de recherche hybride

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_preview",
                "search_context_size": "medium"
            })

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            instructions="Cite toujours tes sources. Distingue clairement "
                        "les informations internes des informations publiques.",
            input=question,
            tools=tools
        )

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

# Utilisation
assistant = AssistantRecherche(["vs_contrats", "vs_procedures"])
r = assistant.rechercher("Nos CGV sont-elles a jour par rapport au droit européen ?")
print(r["reponse"])

Points clés à retenir

Combinez file_search et web_search_preview dans un même appel
Le modèle choisit automatiquement l’outil adapté à chaque besoin
Le prompt système guide la priorité entre sources internes et externes
Ajoutez des fonctions personnalisées pour des workflows complets
La recherche hybride est idéale pour l’audit de conformité et la veille