Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Recherche hybride : combiner le web et les fichiers

9. lecke 20 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Recherche hybride : combiner le web et les fichiers
  2. Activer les deux outils
  3. Cas d’usage : veille réglementaire
  4. Cas d’usage : enrichissement de la base de connaissances
  5. Ajouter des fonctions personnalisées au mélange
  6. Gérer la priorité des sources
  7. Modèle complet : assistant de recherche hybride
  8. Főbb megállapítások

Leçon mise à jour le 2 novembre 2026 sur la base de la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre container (ajouté à tous les exemples), les parties de texte en entrée sont de type input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctions fichiers_generes et telecharger de la leçon 10. Sources : Code Interpreter · Recherche web.

Recherche hybride : combiner le web et les fichiers

Ces deux outils de recherche répondent à des questions différentes et, utilisés isolément, chacun reste incomplet. La recherche de fichiers sait ce que tu as écrit ; la recherche web sait ce que le monde a publié. De nombreuses questions utiles se situent exactement à l’intersection des deux : notre procédure est-elle toujours conforme ? Notre documentation est-elle à jour ? Où en sommes-nous par rapport au marché ?

Ces questions partagent une propriété commune qui explique leur valeur : 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 rend cette leçon précieuse.

Activer les deux outils

Déclare 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 our remote work policy with current market trends",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["vs_abc123"],
            "max_num_results": 10
        },
        {
            "type": "web_search",
            "search_context_size": "medium"
        }
    ]
)

print(response.output_text)

Le modèle décide seul quand utiliser chaque outil. Pour une question sur tes documents internes, il utilisera la recherche de fichiers. Pour des données publiques, il utilisera la recherche web. Pour une comparaison, il utilisera les deux.

Cas d’usage : veille réglementaire

La veille réglementaire est l’exemple type car l’écart entre les deux sources est précisément ce que nous recherchons. Demande explicitement les différences, et non un résumé de chaque côté : un modèle invité à résumer produira deux synthèses correctes et te laissera faire la comparaison, qui est la seule partie difficile du travail.

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=(
            "You are a compliance auditor. For each point, you must: "
            "1. Search internal documents for what is currently in place "
            "2. Search the web for current applicable regulations "
            "3. Identify gaps between the two "
            "4. Propose corrective actions"
        ),
        input=f"Audit the compliance of our processes on the topic: {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
    }

# Usage
rapport = audit_conformite(
    "personal data protection and GDPR",
    "vs_processus_internes"
)

Cas d’usage : enrichissement de la base de connaissances

Le même mécanisme, inversé, sert à vérifier l’obsolescence de tes propres documents : au lieu de vérifier la conformité, tu demandes ce qui a changé depuis leur rédaction. C’est l’utilisation la 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 what our internal documents say with the most recent "
                "information from the web. Identify factual gaps, outdated figures, "
                "and obsolete procedures."
            ),
            input=f"Check the currency of our documents on: {sujet}",
            tools=[
                {"type": "file_search", "vector_store_ids": [vs_id]},
                {"type": "web_search"}
            ]
        )

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

    return resultats

Ajouter des fonctions personnalisées au mélange

L’ajout de tes fonctions au mélange fait passer le flux de travail de l’analyse à l’action : le modèle repère un écart, puis ouvre un ticket. Cependant, garde une frontière claire — la recherche et l’analyse peuvent rester automatiques, mais les actions qui engagent des ressources (création, envoi, modification) méritent une validation humaine jusqu’à ce que tu aies mesuré la fiabilité du flux sur plusieurs semaines.

tools = [
    # Recherche dans tes documents
    {
        "type": "file_search",
        "vector_store_ids": ["vs_contrats"],
        "max_num_results": 10
    },
    # Recherche web
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Fonction métier : interroger le CRM
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Retrieve client information from the CRM",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "champs": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "List of fields to return"
                }
            },
            "required": ["client_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    # Fonction métier : créer une alerte
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Create a follow-up alert for a contract or 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. Rechercher un contrat dans la recherche de fichiers
# 2. Vérifier une clause sur le web
# 3. Récupérer les infos client depuis le CRM
# 4. Créer une alerte si un problème est détecté
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Check if client CLI-42567's contract complies with the new European "
          "standards. If not, create a high-priority alert.",
    tools=tools
)

Gérer la priorité des sources

Sans instructions, le modèle traite les deux sources de manière égale. C’est rarement ce que tu veux : pour les faits internes (chiffres, procédures, décisions), tes documents font autorité et le web n’est qu’un bruit plausible ; pour les actualités et les réglementations, c’est l’inverse. Inscris cette hiérarchie dans l’instruction système et exige que tout conflit entre les deux soit signalé plutôt que silencieusement arbitré.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Source priority rules: "
        "1. For internal facts (processes, policies, contracts) -> File Search "
        "2. For external facts (laws, market, trends) -> Web Search "
        "3. In case of conflict between internal and external sources, flag the gap "
        "4. NEVER answer based solely on your own knowledge "
    ),
    input="What is our standard payment term and is it compliant with the law?",
    tools=[
        {"type": "file_search", "vector_store_ids": [vs_id]},
        {"type": "web_search"}
    ]
)

Modèle 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",
                "search_context_size": "medium"
            })

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            instructions="Always cite your sources. Clearly distinguish "
                        "internal information from public information.",
            input=question,
            tools=tools
        )

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

# Usage
assistant = AssistantRecherche(["vs_contrats", "vs_procedures"])
r = assistant.rechercher("Are our GTCs up to date with European law?")
print(r["reponse"])

Főbb megállapítások

  • Combine file_search et web_search dans un seul appel
  • Le modèle choisit automatiquement le bon outil pour chaque besoin
  • L’instruction système guide la priorité entre les sources internes et externes
  • Ajoute des fonctions personnalisées pour des flux de travail complets
  • La recherche hybride est idéale pour les audits de conformité et la veille