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

Konfiguracja Computer Use w API

Lekcja 3 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Wymagania wstępne
  2. Instalacja zależności
  3. Konfiguracja klucza API
  4. Deklarowanie narzędzia computer
  5. Konfiguracja przeglądarki
  6. Organizacja projektu
  7. Weryfikacja instalacji
  8. Kluczowe wnioski

Lekcja przepisana 3 listopada 2026 r. na podstawie przewodnika Computer use firmy OpenAI oraz przepisów integracyjnych Computer use: konfiguracja wykorzystuje obecnie SDK openai, zmienną środowiskową OPENAI_API_KEY oraz narzędzie {"type": "computer"} w API Responses. Nie opiera się już na SDK Anthropic ani na przestarzałym narzędziu computer_20241022. Narzędzie OpenAI nie wymaga podawania wymiarów ekranu; współrzędne odnoszą się do przesłanego zrzutu ekranu. Źródła: Computer use · Przepisy integracyjne.

Wymagania wstępne

Zanim napiszesz pierwszą linię kodu, Twoje stanowisko pracy musi spełniać cztery warunki: najnowszą wersję Pythona 3, konto OpenAI z aktywnym kluczem API i dostępem do modelu obsługującego narzędzie computer, przeglądarkę Chromium sterowaną przez Playwright do interakcji sieciowych oraz Dockera, jeśli planujesz izolować agenta. Docker jest opcjonalny podczas nauki, ale OpenAI zaleca izolowaną przeglądarkę lub maszynę wirtualną, gdy tylko agent zacznie wchodzić w interakcje z czymś więcej niż tylko stroną demonstracyjną.

Jeśli chodzi o model, dokumentacja OpenAI używa gpt-6.1-sol w przykładach dotyczących narzędzia computer. Sprawdź kartę modelu (w sekcji Tools), aby potwierdzić, że funkcja computer use jest wymieniona i że Twój projekt ma do niej dostęp.

Instalacja zależności

Pracuj w dedykowanym środowisku wirtualnym. Agent Computer Use przypina konkretne wersje Playwright i jego przeglądarek. Mieszanie ich z innymi projektami Pythona doprowadzi do konfliktów, których diagnozowanie będzie bolesne.

# Utwórz i aktywuj środowisko
python -m venv computer-use-env
source computer-use-env/bin/activate  # Linux/Mac
# computer-use-env\Scripts\activate   # Windows

# Zainstaluj zależności
pip install openai playwright pillow

# Zainstaluj przeglądarkę Playwright
playwright install chromium

Każdy pakiet odgrywa odrębną rolę: openai zapewnia klienta komunikującego się z modelem, playwright steruje przeglądarką i wykonuje działania, a pillow zajmuje się manipulacją obrazem w razie potrzeby. Ostatnie polecenie jest tym, o którym ludzie najczęściej zapominają. Bez playwright install chromium pakiet zostanie zainstalowany, ale żadna przeglądarka nie zostanie pobrana, co spowoduje niepowodzenie przy pierwszym uruchomieniu.

Konfiguracja klucza API

Przechowuj swój klucz w zmiennej środowiskowej, nigdy nie wpisuj go na sztywno w skrypcie. Sekret zapisany w kodzie prędzej czy później trafi do repozytorium Git.

export OPENAI_API_KEY="twój-klucz"

W środowisku produkcyjnym użyj menedżera sekretów. Klient odczytuje tę zmienną automatycznie:

from openai import OpenAI

client = OpenAI()  # odczytuje OPENAI_API_KEY

Deklarowanie narzędzia computer

Model domyślnie nie steruje ekranem. Musisz włączyć narzędzie computer w żądaniu i opisać oczekiwany wynik.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    tools=[{"type": "computer"}],
    input=(
        "Sprawdź, czy panel Filtry jest otwarty. Jeśli nie, "
        "kliknij Pokaż Filtry, a następnie wpisz penguin w polu "
        "wyszukiwania. Użyj narzędzia computer do interakcji z interfejsem."
    ),
)
print(response.output)

Deklaracja to po prostu {"type": "computer"}. W przeciwieństwie do wczesnej wersji zapoznawczej (computer_use_preview), nie wymaga ona ani wymiarów ekranu, ani typu środowiska, a automatyczne przycinanie nie jest już konieczne. Współrzędne zwracane przez model odnoszą się do przesłanego przez Ciebie zrzutu ekranu. Przechwyć dokładnie obszar, w który zamierzasz kliknąć, w tej samej skali. Jeśli zmienisz rozmiar zrzutu ekranu przed wysłaniem, przelicz współrzędne z powrotem przed podjęciem działania.

Konfiguracja przeglądarki

Po stronie Playwright opakuj logikę uruchamiania w funkcję, którą możesz wielokrotnie wykorzystywać w różnych zadaniach.

from playwright.sync_api import sync_playwright

def launch_browser(width=1280, height=720):
    """Uruchamia izolowaną przeglądarkę dla Computer Use."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)  # False, aby obserwować agenta
    context = browser.new_context(viewport={"width": width, "height": height})
    page = context.new_page()
    return pw, browser, page

page.screenshot() przechwytuje obszar widoku (viewport), więc współrzędne modelu odnoszą się bezpośrednio do page.mouse. Opcja headless=True uruchamia przeglądarkę bez interfejsu użytkownika, co jest niezbędne na serwerze. Podczas rozwoju ustaw tę wartość na False, aby obserwować pracę agenta. To najszybszy sposób, aby zrozumieć, dlaczego popełnia błędy.

Organizacja projektu

Od samego początku oddziel logikę przeglądarki, pętlę agenta i wykonywanie działań.

computer-use-project/
├── .env                  # OPENAI_API_KEY (nigdy nie commituj)
├── requirements.txt      # openai, playwright, pillow
├── src/
│   ├── __init__.py
│   ├── browser.py        # Uruchamianie i przechwytywanie
│   ├── agent.py          # Pętla Computer Use
│   └── actions.py        # Wykonywanie działań
└── tasks/
    └── example.py        # Skrypty zadań

Weryfikacja instalacji

Nie buduj złożonego przepływu pracy na niezweryfikowanej konfiguracji. Jeśli pierwsze uruchomienie się nie powiedzie, nie będziesz wiedzieć, czy problem leży po stronie klucza, przeglądarki, czy Twojego promptu. Ten minimalny skrypt testuje cały łańcuch: klient, przeglądarka, przechwytywanie i przesyłanie obrazu do modelu.

import base64

from openai import OpenAI
from playwright.sync_api import sync_playwright

def test_installation():
    """Weryfikuje, czy klucz, przeglądarka i przesyłanie obrazu działają."""
    client = OpenAI()

    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)
    page = browser.new_page(viewport={"width": 1280, "height": 720})
    page.goto("https://example.com")
    capture = base64.b64encode(page.screenshot()).decode("utf-8")

    response = client.responses.create(
        model="gpt-6.1-sol",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Opisz, co widzisz."},
                {"type": "input_image", "image_url": f"data:image/png;base64,{capture}"},
            ],
        }],
    )
    print("Odpowiedź:", response.output_text)

    browser.close()
    pw.stop()

if __name__ == "__main__":
    test_installation()

Jeśli konsola wyświetli opis strony example.com, Twoja konfiguracja jest gotowa i możesz przystąpić do budowania pełnego agenta.

Kluczowe wnioski

  • Zainstaluj openai, playwright i pillow w dedykowanym środowisku wirtualnym, a następnie uruchom playwright install chromium
  • Przechowuj OPENAI_API_KEY w zmiennej środowiskowej, nigdy w kodzie
  • Zadeklaruj narzędzie za pomocą tools=[{"type": "computer"}], używając obsługiwanego modelu (przykłady OpenAI używają gpt-6.1-sol)
  • Współrzędne modelu odnoszą się do wysłanego zrzutu ekranu: przechwyć obszar, na którym działasz, w tej samej skali
  • Zawsze testuj za pomocą minimalnego skryptu przed budowaniem złożonych przepływów pracy