Recherche hybride : combiner web et fichiers

La puissance reelle apparait quand vous combinez File Search et Web Search dans un meme appel. Le modele peut alors croiser vos documents internes avec des informations publiques pour produire des analyses enrichies.

Activer les deux outils

Declarez les deux outils simultanement dans le tableau tools :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.3",
    input="Compare notre politique de teletravail 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 modele decide de lui-meme quand utiliser chaque outil. Pour une question sur vos documents internes, il utilisera File Search. Pour des donnees publiques, Web Search. Pour une comparaison, les deux.

Cas d’usage : veille reglementaire

Comparez vos processus internes avec les dernieres reglementations :

def audit_conformite(sujet: str, vs_processus: str) -> dict:
    """Compare les processus internes avec la reglementation en vigueur."""
    response = client.responses.create(
        model="gpt-5.3",
        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 reglementation actuelle applicable "
            "3. Identifier les ecarts 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 donnees personnelles et RGPD",
    "vs_processus_internes"
)

Cas d’usage : enrichissement de base de connaissances

Detectez les informations obsoletes dans vos documents :

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

    for sujet in sujets:
        response = client.responses.create(
            model="gpt-5.3",
            instructions=(
                "Compare ce que disent nos documents internes avec les informations "
                "les plus recentes du web. Identifie les ecarts factuels, "
                "les chiffres desactualises et les procedures perimees."
            ),
            input=f"Verifie 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 personnalisees au mix

La combinaison devient encore plus puissante avec des fonctions metier :

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 metier : interroger le CRM
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Recuperer 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 metier : creer une alerte
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Creer 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 modele peut maintenant :
# 1. Chercher un contrat dans File Search
# 2. Verifier une clause sur le web
# 3. Recuperer les infos client dans le CRM
# 4. Creer une alerte si un probleme est detecte
response = client.responses.create(
    model="gpt-5.3",
    input="Verifie 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
)

Gerer la priorite entre sources

Guidez le modele sur la priorite des sources avec le prompt systeme :

response = client.responses.create(
    model="gpt-5.3",
    instructions=(
        "Regles de priorite 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'ecart "
        "4. Ne reponds JAMAIS en te basant uniquement sur tes connaissances "
    ),
    input="Quel est notre delai 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.3",
            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 europeen ?")
print(r["reponse"])

Points cles a retenir

Combinez file_search et web_search_preview dans un meme appel
Le modele choisit automatiquement l’outil adapte a chaque besoin
Le prompt systeme guide la priorite entre sources internes et externes
Ajoutez des fonctions personnalisees pour des workflows complets
La recherche hybride est ideale pour l’audit de conformite et la veille