Przejdź do głównej treści
Polski— Wybierz język
Menu

Konfiguruj i kontroluj wyniki wyszukiwania w sieci

Lekcja 6 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Konfiguruj i kontroluj wyniki wyszukiwania w sieci
  2. Parametr search_context_size
  3. Kieruj zapytaniami wyszukiwania poprzez prompt
  4. Wyodrębnij i strukturyzuj cytowania
  5. Wzorzec: wyszukiwanie z krzyżową walidacją
  6. Obsługa braku wyników
  7. Wyszukiwanie w sieci ze strumieniowaniem
  8. Filtruj domeny i listuj źródła
  9. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga parametru container (dodanego do wszystkich przykładów), części tekstowe wejścia mają typ input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview to obecnie przestarzałe narzędzie bez filtrów domen). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Źródła: Code Interpreter · Wyszukiwanie w sieci.

Konfiguruj i kontroluj wyniki wyszukiwania w sieci

Włączenie Wyszukiwania w sieci zajmuje jedną linię kodu, ale uzyskanie rzetelnych odpowiedzi wymaga trzech ustawień, które szczegółowo omawiamy w tej lekcji. Pierwsze decyduje, ile treści z sieci zostanie wstrzykniętych do kontekstu, co bezpośrednio wpływa na Twój rachunek. Drugie steruje zapytaniami formułowanymi samodzielnie przez model – ponieważ to on je pisze, a nie Ty. Trzecie dotyczy cytowań; bez nich odpowiedź oparta na źródłach jest jedynie twierdzeniem.

Parametr search_context_size

Parametr search_context_size kontroluje ilość treści z sieci wstrzykiwanej do kontekstu modelu. Nie zmienia ani liczby wyszukiwań, ani ich jakości: określa, ile tekstu – po znalezieniu stron – faktycznie trafi do promptu. To kompromis między wyczerpującą analizą a kosztem, dlatego powinieneś go dostosowywać do typu zadania, a nie ustawiać raz i zapomnieć.

from openai import OpenAI

client = OpenAI()

# Minimalny kontekst: szybkie, zwięzłe odpowiedzi
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is France's GDP in 2025?",
    tools=[{
        "type": "web_search",
        "search_context_size": "low"
    }]
)

# Średni kontekst: dobry kompromis (domyślny)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Summarize AI market trends in Europe",
    tools=[{
        "type": "web_search",
        "search_context_size": "medium"
    }]
)

# Duży kontekst: dogłębna analiza
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare AI strategies in France, Germany, and the Netherlands",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Wpływ na koszty i opóźnienia

Zasada jest prosta: zwiększaj wartość o jeden stopień tylko wtedy, gdy otrzymana odpowiedź konkretnie Cię rozczarowała. Data, liczba lub potwierdzenie faktu nie wymagają niczego więcej niż low; użycie w tym celu high to jak płacenie za całe dossier, by przeczytać jedną linijkę.

RozmiarTokeny kontekstuOpóźnienieKosztZastosowanie
lowMinimalneSzybkieNiskiProste fakty, liczby
mediumUmiarkowaneStandardoweŚredniPodsumowania, porównania
highMaksymalneWolniejszeWysokiDogłębna analiza

Kieruj zapytaniami wyszukiwania poprzez prompt

Oto punkt, który większość odkrywa zbyt późno: model sam formułuje swoje zapytania wyszukiwania. Piszesz „jakie są ostatnie zmiany regulacyjne?“, a on tłumaczy to na słowa kluczowe, których nigdy nie widzisz. Jakość wyników zależy zatem od przeformułowania, nad którym masz jedynie pośrednią kontrolę – jest nim systemowy prompt. Wymień autorytatywne źródła w swojej dziedzinie oraz okres, który Cię interesuje: to najbardziej przesunie szalę na Twoją korzyść.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=(
        "You are a market analyst specializing in European technology. "
        "When you perform web searches, prioritize institutional sources "
        "(European Commission, INSEE, Eurostat) and specialized media "
        "(Les Echos, La Tribune, TechCrunch). "
        "Ignore personal blogs and forums."
    ),
    input="What is the state of AI startup funding in France?",
    tools=[{
        "type": "web_search",
        "search_context_size": "high"
    }]
)

Wyodrębnij i strukturyzuj cytowania

Cytowania przychodzą jako adnotacje dołączone do odpowiedzi, a nie w samym tekście. To dobra wiadomość: pozwala Ci wyświetlać źródła w dowolny sposób, weryfikować je lub odrzucać odpowiedź, która ich nie posiada. W każdej aplikacji, gdzie odpowiedź ma wagę – prawnej, medycznej, finansowej – traktowanie brakujących adnotacji jako błędu jest bezpieczniejsze niż ufanie samemu tekstowi.

def extract_sources(response) -> list[dict]:
    """Extract all URL citations from a Web Search response."""
    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

# Usage
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What are the new GDPR rules for AI in 2026?",
    tools=[{"type": "web_search"}]
)

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

Wzorzec: wyszukiwanie z krzyżową walidacją

Pojedyncze źródło pozostaje pojedynczym źródłem, nawet jeśli znalazł je model. W przypadku informacji wpływających na decyzję, wyraźnie zażądaj potwierdzenia z wielu niezależnych źródeł i każ modelowi flagować rozbieżności, zamiast cicho je arbitrować: niezgodność między dwoma źródłami jest sama w sobie informacją, często bardziej użyteczną niż uśrednianie obu.

def validated_search(question: str, min_sources: int = 3) -> dict:
    """Web search requiring multiple sources."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=(
            f"To answer this question, you must find at least "
            f"{min_sources} independent sources that confirm the information. "
            "If sources contradict each other, flag the discrepancies. "
            "Cite each source explicitly."
        ),
        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"
    }

Obsługa braku wyników

Jest jeden przypadek, o którym ludzie zapominają: wyszukiwanie nie zwraca niczego. Ryzyko nie polega na braku odpowiedzi, lecz na tym, że w obliczu braku wyników model odpowiada ze swojej wewnętrznej wiedzy, nie sygnalizując tego, dostarczając wiarygodnie brzmiących, ale nieaktualnych informacji. Każ mu to wyraźnie zaznaczyć i zaplanuj mechanizm przeformułowania.

def search_with_fallback(question: str) -> dict:
    """Web search with failure detection and reformulation."""
    # First attempt
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=question,
        tools=[{"type": "web_search"}]
    )

    sources = extract_sources(response)

    if len(sources) == 0:
        # Automatic reformulation
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Rephrase this question for a more effective web search, "
                  f"then search: {question}",
            tools=[{"type": "web_search", "search_context_size": "high"}]
        )
        sources = extract_sources(response)

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

Wyszukiwanie w sieci ze strumieniowaniem

Wyszukiwanie w sieci trwa kilka sekund, czasem dłużej, jeśli model łańcuchuje kilka zapytań. Dzięki strumieniowaniu użytkownik widzi, jak odpowiedź się buduje, zamiast wpatrywać się w wskaźnik ładowania – przy tego rodzaju opóźnieniach różnica w odbiorze jest ogromna, a koszt implementacji bliski zeru.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What are this week's tech news headlines?",
    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":
        # Extract sources at the end
        sources = extract_sources(event.response)
        print(f"\n\n--- {len(sources)} sources consulted ---")

Filtruj domeny i listuj źródła

Narzędzie web_search akceptuje parametr filters, który ogranicza wyszukiwanie do listy dozwolonych domen (do 100) lub wyklucza listę domen (również do 100). Wpisuj domeny bez http:// lub https://. Filtrowanie istnieje tylko w przypadku web_search w API Responses: przestarzałe narzędzie web_search_preview ignoruje ten parametr.

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="What are the price display requirements for retail stores in France?",
)
print(response.output_text)

Opcja include=["web_search_call.action.sources"] zwraca pełną listę consulted URL-i, często dłuższą niż lista cytowań. Same cytowania przychodzą jako adnotacje url_citation (URL, tytuł, pozycja w tekście): dokumentacja OpenAI wymaga, abyś wyświetlał je w swoim interfejsie w sposób widoczny i klikalny.

Kluczowe wnioski

  • search_context_size kontroluje objętość danych z sieci wstrzykiwanych do kontekstu
  • filters ograniczają lub wykluczają domeny (maks. 100); include listuje wszystkie consulted źródła
  • Prompt systemowy kieruje model ku właściwym źródłom
  • Wyodrębnij adnotacje url_citation, aby śledzić źródła
  • Wdróż krzyżową walidację dla informacji krytycznych
  • Obsłuż brak wyników za pomocą automatycznego przeformułowania