Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Ricerca ibrida: combinare web e file

Lezione 9 di 20 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Ricerca ibrida: combinare web e file
  2. Abilitare entrambi gli strumenti
  3. Caso d’uso: monitoraggio normativo
  4. Caso d’uso: arricchimento della base di conoscenza
  5. Aggiungere funzioni personalizzate al mix
  6. Gestire la priorità delle fonti
  7. Schema completo: assistente di ricerca ibrida
  8. Punti chiave

Lezione aggiornata il 2 novembre 2026 sulla base della documentazione OpenAI: lo strumento Code Interpreter richiede ora un parametro container (aggiunto a tutti gli esempi), le parti di testo in input sono di tipo input_text e la ricerca web utilizza lo strumento web_search (web_search_preview è ora uno strumento legacy senza filtri di dominio). I file generati vengono recuperati utilizzando le funzioni fichiers_generes e telecharger della Lezione 10. Fonti: Code Interpreter · Web search.

Ricerca ibrida: combinare web e file

I due strumenti di ricerca rispondono a domande diverse e, se usati isolatamente, ciascuno rimane incompleto. La File Search sa cosa hai scritto tu; la Web Search sa cosa ha pubblicato il mondo. Molte domande utili si trovano esattamente all’intersezione delle due: la nostra procedura è ancora conforme? La nostra documentazione è aggiornata? Qual è la nostra posizione rispetto al mercato?

Queste domande condividono una proprietà comune che ne spiega il valore: nessuno può rispondervi senza leggere entrambi i lati. È questo incrocio, non la ricerca in sé, a rendere preziosa questa lezione.

Abilitare entrambi gli strumenti

Dichiara entrambi gli strumenti simultaneamente nell’array tools:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Confronta la nostra politica di lavoro da remoto con le attuali tendenze di mercato",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["vs_abc123"],
            "max_num_results": 10
        },
        {
            "type": "web_search",
            "search_context_size": "medium"
        }
    ]
)

print(response.output_text)

Il modello decide autonomamente quando utilizzare ciascuno strumento. Per una domanda sui tuoi documenti interni, userà la File Search. Per dati pubblici, userà la Web Search. Per un confronto, userà entrambi.

Caso d’uso: monitoraggio normativo

Il monitoraggio normativo è l’esempio da manuale perché il divario tra le due fonti è proprio ciò che stiamo cercando. Chiedi esplicitamente le differenze, non un riassunto di ciascuna parte: un modello invitato a riassumere produrrà due sintesi corrette e lascerà a te il compito di fare il confronto, che è l’unica parte difficile del lavoro.

def audit_conformite(sujet: str, vs_processus: str) -> dict:
    """Confronta i processi interni con le normative vigenti."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            "Sei un auditor di conformità. Per ogni punto, devi: "
            "1. Cercare nei documenti interni cosa è attualmente in atto "
            "2. Cercare sul web le normative applicabili attuali "
            "3. Identificare le lacune tra i due "
            "4. Proporre azioni correttive"
        ),
        input=f"Audita la conformità dei nostri processi sull'argomento: {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
    }

# Utilizzo
rapport = audit_conformite(
    "protezione dei dati personali e GDPR",
    "vs_processus_internes"
)

Caso d’uso: arricchimento della base di conoscenza

Lo stesso meccanismo, invertito, serve a verificare l’obsolescenza dei tuoi documenti: invece di verificare la conformità, chiedi cosa è cambiato da quando sono stati scritti. Questo è l’uso più efficiente in termini di costi della ricerca ibrida su una base documentale datata: nessuno ha tempo di rileggere cento pagine per trovare le tre che sono invecchiate.

def detecter_obsolescence(vs_id: str, sujets: list[str]) -> list[dict]:
    """Identifica informazioni potenzialmente obsolete."""
    resultats = []

    for sujet in sujets:
        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions=(
                "Confronta ciò che dicono i nostri documenti interni con le informazioni "
                "più recenti dal web. Identifica lacune fattuali, cifre datate "
                "e procedure obsolete."
            ),
            input=f"Verifica l'attualità dei nostri documenti su: {sujet}",
            tools=[
                {"type": "file_search", "vector_store_ids": [vs_id]},
                {"type": "web_search"}
            ]
        )

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

    return resultats

Aggiungere funzioni personalizzate al mix

Aggiungere le tue funzioni al mix sposta il flusso di lavoro dall’analisi all’azione: il modello individua una lacuna, poi apre un ticket. Tuttavia, mantieni un confine chiaro: ricerca e analisi possono rimanere automatiche, ma le azioni che impegnano risorse (creare, inviare, modificare) meritano una validazione umana finché non hai misurato l’affidabilità del flusso per diverse settimane.

tools = [
    # Cerca nei tuoi documenti
    {
        "type": "file_search",
        "vector_store_ids": ["vs_contrats"],
        "max_num_results": 10
    },
    # Ricerca web
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Funzione aziendale: interrogare il CRM
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Recupera le informazioni sul cliente dal CRM",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "champs": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "Elenco dei campi da restituire"
                }
            },
            "required": ["client_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    # Funzione aziendale: creare un avviso
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Crea un avviso di follow-up per un contratto o un 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
    }
]

# Il modello può ora:
# 1. Cercare un contratto nella File Search
# 2. Verificare una clausola sul web
# 3. Recuperare le informazioni sul cliente dal CRM
# 4. Creare un avviso se viene rilevato un problema
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Verifica se il contratto del cliente CLI-42567 è conforme ai nuovi standard "
          "europei. In caso contrario, crea un avviso ad alta priorità.",
    tools=tools
)

Gestire la priorità delle fonti

Senza istruzioni, il modello tratta entrambe le fonti allo stesso modo. Questo è raramente ciò che desideri: per i fatti interni (cifre, procedure, decisioni), i tuoi documenti fanno fede e il web è solo rumore plausibile; per notizie e normative, vale il contrario. Scrivi questa gerarchia nel prompt di sistema e richiedi che qualsiasi conflitto tra le due venga segnalato invece di essere arbitrato silenziosamente.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Regole di priorità delle fonti: "
        "1. Per fatti interni (processi, politiche, contratti) -> File Search "
        "2. Per fatti esterni (leggi, mercato, trend) -> Web Search "
        "3. In caso di conflitto tra fonti interne ed esterne, segnala la lacuna "
        "4. NON rispondere MAI basandoti solo sulla tua conoscenza "
    ),
    input="Qual è il nostro termine di pagamento standard ed è conforme alla legge?",
    tools=[
        {"type": "file_search", "vector_store_ids": [vs_id]},
        {"type": "web_search"}
    ]
)

Schema completo: assistente di ricerca ibrida

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 sempre le tue fonti. Distingui chiaramente "
                        "le informazioni interne da quelle pubbliche.",
            input=question,
            tools=tools
        )

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

# Utilizzo
assistant = AssistantRecherche(["vs_contrats", "vs_procedures"])
r = assistant.rechercher("Le nostre CGV sono aggiornate rispetto alla legge europea?")
print(r["reponse"])

Punti chiave

  • Combina file_search e web_search in un’unica chiamata
  • Il modello sceglie automaticamente lo strumento giusto per ogni necessità
  • Il prompt di sistema guida la priorità tra fonti interne ed esterne
  • Aggiungi funzioni personalizzate per flussi di lavoro completi
  • La ricerca ibrida è ideale per audit di conformità e monitoraggio