Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Web Search API : Recherche web programmatique

Lezione 5 di 20 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Web Search API : Recherche web programmatique
  2. Activer la recherche web
  3. Structure de la réponse
  4. Contexte utilisateur pour la pertinence
  5. Combiner la recherche web avec des fonctions personnalisées
  6. Cas d’usage en production
  7. Limites connues
  8. Punti chiave

Leçon mise à jour le 2 novembre 2026 selon la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre container (ajouté à tous les exemples), les parties de texte d’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.

Web Search API : Recherche web programmatique

L’outil Web Search permet au modèle d’effectuer des recherches web en temps réel directement depuis l’API Responses. Tu n’as plus besoin d’intégrer une API de recherche tierce : le modèle formule la requête, exécute la recherche et synthétise les résultats.

Activer la recherche web

L’activation ne prend qu’une ligne, ce qui masque un changement fondamental : ton application n’est plus limitée par la date de coupure des connaissances du modèle. Les questions sur les événements d’hier, les prix actuels ou les réglementations récentes deviennent répondables sans intégrer ni payer un moteur de recherche tiers.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Quels sont les derniers résultats de la Ligue 1 ?",
    tools=[{"type": "web_search"}]
)

print(response.output_text)

Le modèle décide seul quand effectuer une recherche, et ce point mérite attention : il ne cherche pas systématiquement. Pour les questions qu’il estime relever de ses connaissances existantes, il répond directement — plus vite et moins cher, mais avec le risque de présenter des informations obsolètes avec la même assurance. Lorsque la fraîcheur est critique, indique-le explicitement dans ton prompt plutôt que d’espérer que le modèle devine correctement.

Structure de la réponse

Les sources arrivent sous forme d’annotations attachées à la réponse, séparées du texte. Cela te permet de les afficher à ta guise, de les vérifier ou de signaler comme suspecte toute réponse dépourvue de sources lorsque le sujet l’exige.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Quel est le cours actuel de l'action LVMH ?",
    tools=[{"type": "web_search"}]
)

# Texte synthétisé
print(response.output_text)

# Examiner les sources
for item in response.output:
    if hasattr(item, "content"):
        for block in item.content:
            if hasattr(block, "annotations"):
                for annotation in block.annotations:
                    if annotation.type == "url_citation":
                        print(f"Source : {annotation.url}")
                        print(f"Titre : {annotation.title}")

Contexte utilisateur pour la pertinence

La localisation influence les résultats plus que tu ne le penses, et pas seulement pour les recherches évidemment locales. Les questions sur la fiscalité, les prix, la disponibilité ou les obligations légales produisent des réponses différentes selon le pays : sans user_location, le modèle se rabat sur un contexte souvent centré sur les États-Unis.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Quel restaurant japonais est ouvert ce soir ?",
    tools=[{
        "type": "web_search",
        "user_location": {
            "type": "approximate",
            "city": "Paris",
            "country": "FR"
        }
    }]
)

Le paramètre user_location accepte plusieurs niveaux de précision :

# Localisation approximative
"user_location": {
    "type": "approximate",
    "city": "Lyon",
    "region": "Auvergne-Rhone-Alpes",
    "country": "FR"
}

Combiner la recherche web avec des fonctions personnalisées

La combinaison la plus productive suit toujours le même schéma : le web apporte des informations externes, tes fonctions fournissent le contexte interne, et le modèle fait le lien. C’est dans cette connexion que réside la valeur : ni la recherche ni tes données seules ne répondent à « cela nous affecte-t-il ? ».

tools = [
    {"type": "web_search"},
    {
        "type": "function",
        "name": "sauvegarder_veille",
        "description": "Enregistrer un résultat de veille dans la base de données",
        "parameters": {
            "type": "object",
            "properties": {
                "titre": {"type": "string"},
                "resume": {"type": "string"},
                "url_source": {"type": "string"},
                "categorie": {
                    "type": "string",
                    "enum": ["concurrent", "marche", "reglementation", "technologie"]
                }
            },
            "required": ["titre", "resume", "categorie"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Recherche les dernières actualités sur la réglementation de l'IA en Europe "
          "et enregistre les résultats importants",
    tools=tools
)

Cas d’usage en production

Veille concurrentielle automatisée

def veille_quotidienne(entreprises: list[str]):
    """Lance une veille web pour chaque concurrent."""
    resultats = []
    for entreprise in entreprises:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Quelles sont les dernières actualités concernant {entreprise} ? "
                  "Concentre-toi sur les annonces de produits, les tours de financement "
                  "et les partenariats des 7 derniers jours.",
            tools=[{"type": "web_search"}]
        )
        resultats.append({
            "entreprise": entreprise,
            "synthese": response.output_text
        })
    return resultats

Vérification des faits

def verifier_affirmation(affirmation: str) -> dict:
    """Vérifie une affirmation en recoupant plusieurs sources web."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Vérifie cette affirmation en recherchant des sources fiables : "
              f"'{affirmation}'. Indique si elle est vraie, fausse ou incertaine, "
              f"en incluant les sources qui étayent ta conclusion.",
        tools=[{"type": "web_search"}]
    )

    # Extraire les citations
    sources = []
    for item in response.output:
        if hasattr(item, "content"):
            for block in item.content:
                if hasattr(block, "annotations"):
                    for ann in block.annotations:
                        if ann.type == "url_citation":
                            sources.append(ann.url)

    return {
        "analyse": response.output_text,
        "nombre_sources": len(sources),
        "sources": sources
    }

Limites connues

  • Le modèle peut ne pas trouver de résultats pertinents pour des sujets très de niche
  • Les résultats dépendent de l’indexation web au moment de la requête
  • Le nombre de recherches par appel est limité : le modèle optimise en formulant des requêtes précises
  • Le contenu derrière des paywalls ou des écrans de connexion est inaccessible

Punti chiave

  • Ajoute web_search en une ligne dans tools
  • Le modèle décide seul quand effectuer une recherche web
  • user_location améliore la pertinence des résultats locaux
  • Les annotations url_citation fournissent les sources
  • Combine Web Search avec tes fonctions pour automatiser la veille