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

Web Search API: Wyszukiwanie w sieci programistyczne

Lekcja 5 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Web Search API: Wyszukiwanie w sieci programistyczne
  2. Włączanie wyszukiwania w sieci
  3. Struktura odpowiedzi
  4. Kontekst użytkownika dla trafności
  5. Łączenie wyszukiwania w sieci z własnymi funkcjami
  6. Przypadki użycia produkcyjnego
  7. Znane ograniczenia
  8. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru container (dodano 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 jest obecnie narzędziem przestarzałym bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Źródła: Code Interpreter · Wyszukiwanie w sieci.

Web Search API: Wyszukiwanie w sieci programistyczne

Narzędzie Web Search pozwala modelowi przeprowadzać wyszukiwanie w sieci w czasie rzeczywistym bezpośrednio z poziomu Responses API. Nie musisz już integrować zewnętrznych API wyszukiwarek: model sam formułuje zapytanie, wykonuje wyszukiwanie i syntezuje wyniki.

Włączanie wyszukiwania w sieci

Aktywacja wymaga tylko jednej linii kodu, co maskuje fundamentalną zmianę: Twoja aplikacja nie jest już ograniczona datą końcową wiedzy modelu. Pytania o wydarzenia z wczorajszego dnia, aktualne ceny czy niedawne przepisy stają się możliwe do odpowiedzi bez integrowania czy płacenia za zewnętrzny silnik wyszukiwania.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Jakie są najnowsze wyniki Ligue 1?",
    tools=[{"type": "web_search"}]
)

print(response.output_text)

Model sam decyduje, kiedy przeprowadzić wyszukiwanie i ten punkt zasługuje na uwagę: nie szuka on systematycznie. Na pytania, które – jego zdaniem – mieszczą się w jego istniejącej wiedzy, odpowiada bezpośrednio – szybciej i taniej, ale z ryzykiem przedstawienia nieaktualnych informacji z taką samą pewnością. Gdy świeżość danych jest kluczowa, zaznacz to wyraźnie w prompcie, zamiast liczyć, że model sam to odgadnie.

Struktura odpowiedzi

Źródła docierają jako adnotacje dołączone do odpowiedzi, oddzielnie od tekstu. Pozwala to wyświetlać je na własny sposób, weryfikować je lub flagować jako podejrzane każdą odpowiedź, która nie zawiera źródeł, gdy temat tego wymaga.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Jaka jest aktualna cena akcji LVMH?",
    tools=[{"type": "web_search"}]
)

# Syntetyczny tekst
print(response.output_text)

# Przeanalizuj źródła
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"Źródło: {annotation.url}")
                        print(f"Tytuł: {annotation.title}")

Kontekst użytkownika dla trafności

Lokalizacja wpływa na wyniki bardziej, niż mogłoby się wydawać, i nie tylko w przypadku wyraźnie lokalnych wyszukiwań. Pytania o opodatkowanie, ceny, dostępność czy obowiązki prawne dają różne odpowiedzi w zależności od kraju: bez parametru user_location model domyślnie przyjmuje kontekst, który często jest ukierunkowany na USA.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Która japońska restauracja jest dziś wieczorem otwarta?",
    tools=[{
        "type": "web_search",
        "user_location": {
            "type": "approximate",
            "city": "Paris",
            "country": "FR"
        }
    }]
)

Parametr user_location akceptuje kilka poziomów precyzji:

# Lokalizacja przybliżona
"user_location": {
    "type": "approximate",
    "city": "Lyon",
    "region": "Auvergne-Rhone-Alpes",
    "country": "FR"
}

Łączenie wyszukiwania w sieci z własnymi funkcjami

Najbardziej produktywne połączenie zawsze podlega temu samemu schematowi: sieć dostarcza informacji zewnętrznych, Twoje funkcje zapewniają kontekst wewnętrzny, a model łączy kropki. To właśnie w tym połączeniu tkwi wartość – ani samo wyszukiwanie, ani same Twoje dane nie odpowiedzą na pytanie „czy ta zmiana nas dotyczy?“.

tools = [
    {"type": "web_search"},
    {
        "type": "function",
        "name": "sauvegarder_veille",
        "description": "Zapisz wynik monitoringu w bazie danych",
        "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="Wyszukaj najnowsze wiadomości o regulacjach dotyczących AI w Europie "
          "i zapisz ważne wyniki",
    tools=tools
)

Przypadki użycia produkcyjnego

Zautomatyzowany wywiad konkurencyjny

def veille_quotidienne(entreprises: list[str]):
    """Uruchamia monitoring sieci dla każdego konkurenta."""
    resultats = []
    for entreprise in entreprises:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Jakie są najnowsze wiadomości o firmie {entreprise}? "
                  "Skup się na ogłoszeniach produktowych, rundach finansowania "
                  "i partnerstwach z ostatnich 7 dni.",
            tools=[{"type": "web_search"}]
        )
        resultats.append({
            "entreprise": entreprise,
            "synthese": response.output_text
        })
    return resultats

Weryfikacja faktów (Fact-Checking)

def verifier_affirmation(affirmation: str) -> dict:
    """Weryfikuje twierdzenie poprzez krzyżowe odniesienie do wielu źródeł w sieci."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Zweryfikuj to twierdzenie, wyszukując wiarygodne źródła: "
              f"'{affirmation}'. Określ, czy jest ono prawdziwe, fałszywe, czy niepewne, "
              f"dołączając źródła potwierdzające Twój wniosek.",
        tools=[{"type": "web_search"}]
    )

    # Wyodrębnij cytowania
    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
    }

Znane ograniczenia

  • Model może nie znaleźć istotnych wyników dla bardzo niszowych tematów
  • Wyniki zależą od indeksowania sieci w momencie żądania
  • Liczba wyszukiwań na wywołanie jest ograniczona: model optymalizuje, formułując precyzyjne zapytania
  • Treści za paywallami lub ekranami logowania są niedostępne

Kluczowe wnioski

  • Dodaj web_search w jednej linii wewnątrz tools
  • Model samodzielnie decyduje, kiedy przeszukać sieć
  • user_location poprawia trafność wyników lokalnych
  • Adnotacje url_citation dostarczają źródeł
  • Połącz Web Search ze swoimi funkcjami, aby zautomatyzować monitoring