Hybride Suche: Kombination von Web und Dateien

Lektion aktualisiert am 2. November 2026 basierend auf der OpenAI-Dokumentation: Das Tool Code Interpreter erfordert nun einen container-Parameter (in allen Beispielen hinzugefügt), Eingabetextteile sind vom Typ input_text, und die Websuche verwendet das Tool web_search (web_search_preview ist jetzt ein veraltetes Tool ohne Domänenfilter). Generierte Dateien werden mit den Funktionen fichiers_generes und telecharger aus Lektion 10 abgerufen. Quellen: Code Interpreter · Websuche.

Die beiden Suchtools beantworten unterschiedliche Fragen, und wenn sie isoliert verwendet werden, bleibt jede unvollständig. Die Dateisuche weiß, was Sie geschrieben haben; die Websuche weiß, was die Welt veröffentlicht hat. Viele nützliche Fragen liegen genau an der Schnittstelle beider: Ist unser Verfahren noch konform? Ist unsere Dokumentation aktuell? Wo stehen wir im Vergleich zum Markt?

Diese Fragen teilen eine gemeinsame Eigenschaft, die ihren Wert erklärt: Niemand kann sie beantworten, ohne beide Seiten zu lesen. Es ist genau dieser Übergang, nicht die Suche selbst, der diese Lektion wertvoll macht.

Beide Tools aktivieren

Geben Sie beide Tools gleichzeitig im tools-Array an:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vergleichen Sie unsere Remote-Arbeitsrichtlinie mit aktuellen Markttrends",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["vs_abc123"],
            "max_num_results": 10
        },
        {
            "type": "web_search",
            "search_context_size": "medium"
        }
    ]
)

print(response.output_text)

Das Modell entscheidet selbstständig, wann es welches Tool verwendet. Bei Fragen zu Ihren internen Dokumenten nutzt es die Dateisuche. Bei öffentlichen Daten nutzt es die Websuche. Bei einem Vergleich nutzt es beide.

Anwendungsfall: Regulierungsüberwachung

Die Regulierungsüberwachung ist das Lehrbuchbeispiel, da die Lücke zwischen den beiden Quellen genau das ist, wonach wir suchen. Fordern Sie explizit Unterschiede an, nicht eine Zusammenfassung jeder Seite: Ein Modell, das aufgefordert wird, zusammenzufassen, erzeugt zwei korrekte Synthesen und lässt Sie den Vergleich vornehmen, was der schwierigste Teil der Arbeit ist.

def audit_conformite(sujet: str, vs_processus: str) -> dict:
    """Vergleicht interne Prozesse mit aktuellen Vorschriften."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            "Sie sind ein Compliance-Auditor. Für jeden Punkt müssen Sie: "
            "1. Interne Dokumente durchsuchen, um festzustellen, was derzeit in Kraft ist "
            "2. Das Web durchsuchen, um aktuelle anwendbare Vorschriften zu finden "
            "3. Lücken zwischen beiden identifizieren "
            "4. Korrekturmaßnahmen vorschlagen"
        ),
        input=f"Auditieren Sie die Konformität unserer Prozesse zum Thema: {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
    }

# Nutzung
rapport = audit_conformite(
    "Datenschutz und DSGVO",
    "vs_processus_internes"
)

Anwendungsfall: Anreicherung des Wissensbestands

Der gleiche Mechanismus, umgekehrt, dient dazu, Ihre eigenen Dokumente auf Aktualität zu prüfen: Anstatt die Konformität zu überprüfen, fragen Sie, was sich seit ihrer Erstellung geändert hat. Dies ist die kosteneffektivste Nutzung der hybriden Suche bei einem alten Dokumentenbestand – niemand hat Zeit, hundert Seiten erneut zu lesen, um die drei zu finden, die veraltet sind.

def detecter_obsolescence(vs_id: str, sujets: list[str]) -> list[dict]:
    """Identifiziert potenziell veraltete Informationen."""
    resultats = []

    for sujet in sujets:
        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions=(
                "Vergleichen Sie, was unsere internen Dokumente sagen, mit den neuesten "
                "Informationen aus dem Web. Identifizieren Sie faktische Lücken, veraltete Zahlen "
                "und veraltete Verfahren."
            ),
            input=f"Prüfen Sie die Aktualität unserer Dokumente zu: {sujet}",
            tools=[
                {"type": "file_search", "vector_store_ids": [vs_id]},
                {"type": "web_search"}
            ]
        )

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

    return resultats

Benutzerdefinierte Funktionen hinzufügen

Das Hinzufügen Ihrer Funktionen verschiebt den Workflow von der Analyse zur Aktion: Das Modell erkennt eine Lücke und erstellt dann einen Ticket. Behalten Sie jedoch eine klare Grenze bei: Suche und Analyse können automatisiert bleiben, aber Aktionen, die Ressourcen binden (Erstellen, Senden, Ändern), verdienen eine menschliche Validierung, bis Sie die Zuverlässigkeit des Workflows über mehrere Wochen gemessen haben.

tools = [
    # Durchsuchen Sie Ihre Dokumente
    {
        "type": "file_search",
        "vector_store_ids": ["vs_contrats"],
        "max_num_results": 10
    },
    # Websuche
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Geschäftsfunktion: CRM abfragen
    {
        "type": "function",
        "name": "get_client_info",
        "description": "Rufen Sie Kundeninformationen aus dem CRM ab",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "champs": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "Liste der zurückzugebenden Felder"
                }
            },
            "required": ["client_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    # Geschäftsfunktion: Warnung erstellen
    {
        "type": "function",
        "name": "creer_alerte",
        "description": "Erstellen Sie eine Nachverfolgungswarnung für einen Vertrag oder Kunden",
        "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
    }
]

# Das Modell kann nun:
# 1. Einen Vertrag in der Dateisuche durchsuchen
# 2. Eine Klausel im Web überprüfen
# 3. Kundeninformationen aus dem CRM abrufen
# 4. Eine Warnung erstellen, wenn ein Problem erkannt wird
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Prüfen Sie, ob der Vertrag des Kunden CLI-42567 den neuen europäischen "
          "Standards entspricht. Wenn nicht, erstellen Sie eine Warnung mit hoher Priorität.",
    tools=tools
)

Quellenpriorität verwalten

Ohne Anweisungen behandelt das Modell beide Quellen gleich. Das ist selten das, was Sie wollen: Bei internen Fakten – Zahlen, Verfahren, Entscheidungen – sind Ihre Dokumente autoritativ, und das Web ist nur plausible Rauschen; bei Nachrichten und Vorschriften ist das Gegenteil der Fall. Schreiben Sie diese Hierarchie in den Systemprompt und verlangen Sie, dass jeder Konflikt zwischen beiden markiert wird, anstatt stillschweigend entschieden zu werden.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Regeln zur Quellenpriorität: "
        "1. Für interne Fakten (Verfahren, Richtlinien, Verträge) -> Dateisuche "
        "2. Für externe Fakten (Gesetze, Markt, Trends) -> Websuche "
        "3. Im Falle eines Konflikts zwischen internen und externen Quellen die Lücke markieren "
        "4. NIEMALS allein auf eigenes Wissen antworten "
    ),
    input="Was sind unsere Standardzahlungsbedingungen und entsprechen sie dem Gesetz?",
    tools=[
        {"type": "file_search", "vector_store_ids": [vs_id]},
        {"type": "web_search"}
    ]
)

Komplettes Muster: Hybride Such-Assistent

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="Zitieren Sie immer Ihre Quellen. Unterscheiden Sie klar "
                        "zwischen interner und öffentlicher 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

# Nutzung
assistant = AssistantRecherche(["vs_contrats", "vs_procedures"])
r = assistant.rechercher("Sind unsere AGB mit dem europäischen Recht aktuell?")
print(r["reponse"])

Kernaussagen

Kombinieren Sie file_search und web_search in einem einzigen Aufruf
Das Modell wählt automatisch das richtige Tool für jeden Bedarf
Der Systemprompt leitet die Priorität zwischen internen und externen Quellen
Fügen Sie benutzerdefinierte Funktionen für vollständige Workflows hinzu
Hybride Suche ist ideal für Compliance-Audits und Überwachung