0%

Kapitel 5 · Übung

Den OpenAI-Client verwenden

Den Client installieren und auf das Kursmodell ausrichten

Vier Kapitel lang hast du von Hand mit dem Kursmodell gesprochen. Jeder Aufruf hat die Adresse mit f"{BASE_URL}/chat/completions" gebaut, den Body mit json= gesendet, timeout=TIMEOUT übergeben, raise_for_status() aufgerufen, die Antwort mit .json() dekodiert und den Antworttext über eine Kette von Schlüsseln herausgeholt. Kapitel 3 hat noch einen Stream-Leser obendrauf gesetzt. Das alles kannst du jetzt selbst schreiben, und genau deshalb übergibt dieses Kapitel es einer Bibliothek.

Das Paket openai ist ein Client für Dienste, die dieselbe API sprechen wie llm-api. Du sagst ihm einmal, wo der Dienst ist, und danach ist jeder Aufruf eine Zeile. In diesem Kapitel ziehst du den Lernassistenten auf diesen Client um.

Dein Projekt für dieses Kapitel

Öffne client_calls.py im Projekteditor. Die Datei beginnt mit diesen Imports:

import openai
import requests
from openai import OpenAI
from pydantic import ValidationError

from conversation import add_turn, note_message, prepare_messages
from errors import StreamBroken
from prompts import INVALID_PREFIX, QUIZ_PROMPT, QUIZ_SYSTEM
from quiz_models import QuizSet
from structured import error_lines

structured.py und quiz_models.py sind der fertige Code aus Kapitel 4, conversation.py und llm_basics.py stammen aus Kapitel 2 und 1; alle liegen daneben bereit. Du musst sie nicht ändern. Wie bisher verwendet die Prüfung deiner Arbeit eigene Kopien. Eine Änderung dort kann also keine Bewertung beeinflussen, aber sie kann die Demonstration lahmlegen. errors.py enthält weiterhin StreamBroken und prompts.py die festen Prompt-Texte.

import openai gibt dir die Fehlerklassen des Pakets, etwa openai.APIConnectionError. from openai import OpenAI holt die Client-Klasse selbst, sodass du OpenAI(...) schreiben kannst.

Unter den Konstanten stehen sieben unfertige Funktionen, eine oder zwei pro Lektion, danach drei fertige Funktionen, die die Demonstration in späteren Lektionen verwendet. Führe jetzt in der Shell python client_calls.py aus. Das Programm hält sofort bei der ersten Funktion an, die du bauen sollst:

Run stopped at the next function to build: make_client is built in Lesson 1.

Was der Client für dich erledigt

Ein Aufruf über den Client erledigt dieselbe Arbeit wie dein send_body:

  • er baut die URL aus einer Basisadresse und dem Pfad des Endpunkts;

  • er sendet den Body der Anfrage als JSON;

  • er prüft den Statuscode und löst bei einer fehlgeschlagenen Anfrage seinen eigenen Fehler aus statt requests.HTTPError;

  • er dekodiert die Antwort und gibt sie als Objekt zurück, dessen Werte du mit Punkten liest.

Das Paket ist in dieser Sandbox bereits installiert, in der Version, für die der Kurs geschrieben ist. Um es auf deinem eigenen Computer zu verwenden, installiere es mit pip install openai==3.37.0 in eine virtuelle Umgebung. requirements.txt in diesem Projekt führt es zusammen mit pydantic und requests auf.

Baue make_client

make_client() gibt einen Client für das Kursmodell zurück:

def make_client():
    return OpenAI(base_url=BASE_URL, api_key=API_KEY, timeout=CLIENT_TIMEOUT, max_retries=0)

Die drei Konstanten, die die Funktion verwendet, stehen oben in client_calls.py. Jedes Argument ersetzt etwas, das du früher von Hand geschrieben hast.

base_url=BASE_URL ist die Adresse des Kursmodells, http://llm-api:8080/v1. Der Client hängt den Pfad jedes Endpunkts selbst an, etwa /chat/completions oder /models, sodass du nie wieder eine URL bauen musst. Er speichert die Adresse mit einem Schrägstrich am Ende.

api_key=API_KEY ist ein Schlüssel, den der Client bei jeder Anfrage mitsendet. Ohne Schlüssel startet der Client nicht, es sei denn, die Umgebungsvariable OPENAI_API_KEY enthält einen. Wenn du api_key= selbst übergibst, übernimmt der Client nie versehentlich einen echten Schlüssel von deinem Computer. llm-api prüft keinen Schlüssel, deshalb ist API_KEY der Platzhalter "sandbox". Er ist kein Geheimnis. Ein echter Anbieter braucht hier einen echten Schlüssel, und Kapitel 12 verwendet einen.

timeout=CLIENT_TIMEOUT ist 10.0, eine einzelne Zahl in Sekunden. In Kapitel 1 hast du ein Paar übergeben, (3.05, 10): eine Grenze für den Verbindungsaufbau und eine für jedes Warten auf Daten. Der Client nimmt eine einzige Zahl und verwendet sie für jedes Warten: beim Verbindungsaufbau, beim Senden der Anfrage und bei jedem Lesen vom Server. Sie ist keine Grenze für den ganzen Aufruf. Eine lange gestreamte Antwort, die laufend Textstücke sendet, erreicht sie nie, weil jedes Textstück ein neues Warten beginnt, genau wie bei STREAM_TIMEOUT aus Kapitel 3. Ein Warten, das sie erreicht, löst openai.APITimeoutError aus.

max_retries=0 schaltet etwas ab, das der Client standardmäßig tut: Wenn eine Anfrage auf bestimmte Weise fehlschlägt, sendet er sie stillschweigend erneut, bis zu zwei weitere Male. Lektion 5 zeigt, wie das aussieht und warum dieser Kurs es bis Kapitel 9 ausgeschaltet lässt.

Zwei Regeln für die Prüfung. Verwende die Konstanten, nicht ihre noch einmal abgetippten Werte, damit die Einstellungen an einer Stelle stehen. Und baue den Client innerhalb der Funktion, damit jeder Aufruf von make_client() einen neuen Client zurückgibt und der Import von client_calls.py nichts baut.

Ausführen

Führe python client_calls.py aus. Die Demonstration baut einen Client, gibt drei seiner Einstellungen aus und fragt den Dienst, welche Modelle er hat:

A client for http://llm-api:8080/v1/ with timeout=10.0 and max_retries=0
The models it can reach:
  pl-scripted
  pl-live
One question through the client:
Run stopped at the next function to build: ask is built in Lesson 2.

client.base_url, client.timeout und client.max_retries sind Attribute des Clients, die du mit einem Punkt liest. Die Modellliste stammt aus dieser Schleife in der Demonstration:

for model in client.models.list():
    print(f"  {model.id}")

client.models.list() sendet GET /v1/models und gibt pro Modell ein Objekt zurück. list_models aus Kapitel 1 hat dieselbe Antwort als Dictionary gelesen, mit model["id"]; hier hat der Client sie schon dekodiert, also ist die ID das Attribut model.id.

Das Bauen eines Clients sendet nichts. Erst ein Aufruf wie client.models.list() erreicht den Dienst. Deshalb kann die Prüfung deiner Arbeit einen echten Client bauen und seine Einstellungen lesen, ganz ohne Netzwerk.

Eine gestreamte Antwort eines Live-Modells dauert insgesamt 25 Sekunden, und jede halbe Sekunde kommt ein neues Textstück an. Der Client wurde mit timeout=10.0 gebaut. Was passiert?

Warum übergibt make_client api_key="sandbox", obwohl llm-api keinen Schlüssel prüft?

Aufgabe

Ersetze in client_calls.py den unfertigen Rumpf von make_client().

  • Gib OpenAI(base_url=BASE_URL, api_key=API_KEY, timeout=CLIENT_TIMEOUT, max_retries=0) zurück.

  • Verwende die Konstanten BASE_URL, API_KEY und CLIENT_TIMEOUT, nicht ihre noch einmal abgetippten Werte.

  • Baue den Client innerhalb der Funktion, damit jeder Aufruf einen neuen Client zurückgibt.

Führe python client_calls.py aus, um die Einstellungen des Clients und die erreichbaren Modelle zu sehen, und prüfe dann deine Arbeit.