Konfigurieren und steuern von Websuchergebnissen

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

Die Aktivierung der Websuche erfordert nur eine Zeile; für zuverlässige Antworten sind jedoch drei Einstellungen erforderlich, die in dieser Lektion im Detail erläutert werden. Die erste Entscheidung bestimmt, wie viel Web-Inhalt in den Kontext eingespeist wird, und wirkt sich direkt auf Ihre Abrechnung aus. Die zweite steuert die Suchanfragen, die das Modell selbst formuliert – da es diese erstellt, nicht Sie. Die dritte betrifft Zitationen; ohne sie ist eine quellenbasierte Antwort lediglich eine bestätigende Aussage.

Der Parameter search_context_size

Der Parameter search_context_size steuert, wie viel Web-Inhalt in den Kontext des Modells eingespeist wird. Er ändert weder die Anzahl der Suchanfragen noch deren Qualität: Er bestimmt, wie viel Text, sobald Seiten gefunden wurden, tatsächlich in den Prompt eingeht. Dies ist ein Abwägungsprozess zwischen Ausführlichkeit und Kosten, den Sie je nach Aufgabentyp anpassen sollten, nicht einmal festlegen und vergessen.

from openai import OpenAI

client = OpenAI()

# Minimaler Kontext: schnelle, prägnante Antworten
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Was ist das BIP Frankreichs im Jahr 2025?",
    tools=[{
        "type": "web_search",
        "search_context_size": "low"
    }]
)

# Mittlerer Kontext: guter Kompromiss (Standard)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Zusammenfassung der Markttrends für KI in Europa",
    tools=[{
        "type": "web_search",
        "search_context_size": "medium"
    }]
)

# Großer Kontext: vertiefte Analyse
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vergleich der KI-Strategien in Frankreich, Deutschland und den Niederlanden",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Auswirkungen auf Kosten und Latenz

Die Faustregel ist einfach: Erhöhen Sie den Wert nur um eine Stufe, wenn die Antwort Sie konkret enttäuscht hat. Ein Datum, eine Zahl oder eine faktische Bestätigung benötigen nichts mehr als low; die Verwendung von high dafür ist wie das Bezahlen für ein vollständiges Dossier, um nur eine Zeile zu lesen.

Größe	Kontext-Token	Latenz	Kosten	Nutzung
`low`	Minimal	Schnell	Niedrig	Einfache Fakten, Zahlen
`medium`	Mäßig	Standard	Mittel	Zusammenfassungen, Vergleiche
`high`	Maximal	Langsamer	Hoch	Vertiefte Analyse

Suchanfragen über den Prompt leiten

Hier ist der Punkt, den die meisten Menschen zu spät entdecken: das Modell formuliert seine eigenen Suchanfragen. Sie schreiben „welche regulatorischen Änderungen gab es recently?” und das Modell übersetzt dies in Schlüsselwörter, die Sie nie sehen. Die Ergebnisqualität hängt daher von einer Umformulierung ab, über die Sie nur indirekt die Kontrolle haben – dem System-Prompt. Nennen Sie die autoritativen Quellen in Ihrem Fachgebiet und den Zeitraum, der Sie interessiert: Das bewegt den Zeiger am meisten.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "Sie sind ein Marktanalyst, der sich auf europäische Technologie spezialisiert hat. "
        "Wenn Sie Websuchen durchführen, priorisieren Sie institutionelle Quellen "
        "(Europäische Kommission, INSEE, Eurostat) und spezialisierte Medien "
        "(Les Echos, La Tribune, TechCrunch). "
        "Ignorieren Sie persönliche Blogs und Foren."
    ),
    input="Wie steht es um die Finanzierung von KI-Startups in Frankreich?",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Zitationen extrahieren und strukturieren

Zitationen kommen als Annotationen an, die der Antwort angehängt sind, nicht im Text selbst. Diese Trennung ist gute Nachricht: Sie können Quellen so anzeigen, wie Sie möchten, sie überprüfen oder eine Antwort ablehnen, die keine hat. In jeder Anwendung, bei der die Antwort Gewicht trägt – rechtlich, medizinisch, finanziell – ist es sicherer, fehlende Annotationen als Fehler zu betrachten, als dem Text zu vertrauen.

def extract_sources(response) -> list[dict]:
    """Extrahiert alle URL-Zitationen aus einer Websuch-Antwort."""
    sources = []
    for item in response.output:
        if item.type == "message":
            for block in item.content:
                if hasattr(block, "annotations"):
                    for ann in block.annotations:
                        if ann.type == "url_citation":
                            sources.append({
                                "url": ann.url,
                                "title": ann.title,
                                "excerpt_start": ann.start_index,
                                "excerpt_end": ann.end_index
                            })
    return sources

# Nutzung
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Welche neuen DSGVO-Regeln für KI gibt es im Jahr 2026?",
    tools=[{"type": "web_search"}]
)

sources = extract_sources(response)
for s in sources:
    print(f"  {s['title']}: {s['url']}")

Muster: Suche mit Kreuzvalidierung

Eine einzelne Quelle ist immer noch eine einzelne Quelle, auch wenn ein Modell sie gefunden hat. Für Informationen, die eine Entscheidung antreiben, bitten Sie explizit um Bestätigung aus mehreren unabhängigen Quellen und lassen Sie das Modell Diskrepanzen markieren, anstatt sie stillschweigend zu schlichten: Eine Diskrepanz zwischen zwei Quellen ist selbst Information und oft nützlicher als der Durchschnitt der beiden.

def validated_search(question: str, min_sources: int = 3) -> dict:
    """Websuche, die mehrere Quellen erfordert."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            f"Um diese Frage zu beantworten, müssen Sie mindestens "
            f"{min_sources} unabhängige Quellen finden, die die Informationen bestätigen. "
            "Wenn sich Quellen widersprechen, markieren Sie die Diskrepanzen. "
            "Zitieren Sie jede Quelle explizit."
        ),
        input=question,
        tools=[{
            "type": "web_search",
            "search_context_size": "high"
        }]
    )

    sources = extract_sources(response)
    return {
        "answer": response.output_text,
        "sources": sources,
        "reliability": "high" if len(sources) >= min_sources else "verify"
    }

Keine Ergebnisse behandeln

Es gibt einen Fall, den die meisten vergessen zu behandeln: Die Suche liefert nichts. Das Risiko ist nicht das Fehlen einer Antwort – es ist, dass das Modell bei fehlenden Ergebnissen aus seinem internen Wissen antwortet, ohne dies zu signalisieren, und Ihnen plausible, aber veraltete Informationen liefert. Bitten Sie es, dies explizit zu sagen, und planen Sie eine Neuformulierung vor.

def search_with_fallback(question: str) -> dict:
    """Websuche mit Fehlererkennung und Neuformulierung."""
    # Erster Versuch
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=question,
        tools=[{"type": "web_search"}]
    )

    sources = extract_sources(response)

    if len(sources) == 0:
        # Automatische Neuformulierung
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Formulieren Sie diese Frage für eine effektivere Websuche neu, "
                  f"dann suchen Sie: {question}",
            tools=[{"type": "web_search", "search_context_size": "high"}]
        )
        sources = extract_sources(response)

    return {
        "answer": response.output_text,
        "sources": sources
    }

Websuche mit Streaming

Eine Websuche dauert ein paar Sekunden, manchmal länger, wenn das Modell mehrere Anfragen verknüpft. Mit Streaming sieht der Nutzer, wie sich die Antwort aufbaut, anstatt auf einen Ladeindikator zu starren – und bei dieser Art von Latenz ist der Unterschied in der Wahrnehmung enorm bei nahezu null Implementierungskosten.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Welche Tech-News-Headlines gibt es diese Woche?",
    tools=[{"type": "web_search"}],
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        # Quellen am Ende extrahieren
        sources = extract_sources(event.response)
        print(f"\n\n--- {len(sources)} konsultierte Quellen ---")

Domänen filtern und Quellen auflisten

Das Tool web_search akzeptiert einen Parameter filters, der die Suche auf eine Liste erlaubter Domänen (bis zu 100) beschränkt oder eine Liste ausschließt (ebenfalls bis zu 100). Schreiben Sie Domänen ohne http:// oder https://. Das Filtern existiert nur mit web_search in der Responses API: Das veraltete Tool web_search_preview ignoriert es.

response = client.responses.create(
    model="gpt-5.6-terra",
    tools=[{
        "type": "web_search",
        "filters": {"allowed_domains": ["service-public.fr", "legifrance.gouv.fr"]},
    }],
    include=["web_search_call.action.sources"],
    input="Welche Preisangabenpflichten gelten für Einzelhandelsgeschäfte in Frankreich?",
)
print(response.output_text)

Die Option include=["web_search_call.action.sources"] gibt die vollständige Liste der konsultierten URLs zurück, die oft länger ist als die Liste der Zitationen. Die Zitationen selbst kommen als url_citation-Annotationen (URL, Titel, Position im Text): Die Dokumentation von OpenAI fordert, dass Sie diese in Ihrer Benutzeroberfläche sichtbar und klickbar anzeigen.

Kernaussagen

search_context_size steuert das Volumen der eingespeisten Webdaten
filters schränkt Domänen ein oder schließt sie aus (maximal 100); include listet alle konsultierten Quellen auf
Der System-Prompt leitet das Modell zu den richtigen Quellen
Extrahieren Sie url_citation-Annotationen, um Quellen zurückzuverfolgen
Implementieren Sie Kreuzvalidierung für kritische Informationen
Behandeln Sie fehlende Ergebnisse mit automatischer Neuformulierung