0%

Den OpenAI-Client verwenden · Übung

Derselbe Aufruf über den Client

In Kapitel 1 brauchte eine Frage zwei Funktionen. ask_model hat den Body gebaut und gesendet, und answer_text hat den Antworttext aus der dekodierten Antwort geholt. Mit dem Client ist es ein Aufruf und eine Zeile, um den Antworttext zu lesen. Der Body, der bei llm-api ankommt, ist derselbe.

Dieselbe Anfrage, auf zwei Arten geschrieben

So sah es in Kapitel 1 aus, mit allem ausgeschrieben, was send_body und answer_text getan haben:

body = {"model": MODEL, "messages": [{"role": "user", "content": question}]}
response = requests.post(f"{BASE_URL}/chat/completions", json=body, timeout=TIMEOUT)
response.raise_for_status()
document = response.json()
answer = document["choices"][0]["message"]["content"]

Und das ist dieselbe Anfrage über den Client:

response = client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}])
answer = response.choices[0].message.content

client.chat.completions.create folgt dem Pfad des Endpunkts, /chat/completions. Jedes Schlüsselwortargument wird zu einem Feld des Anfrage-Bodys, also senden model=MODEL und messages=[...] genau den Body, den Kapitel 1 gebaut hat. Der Client ergänzt die Basis-URL, den Timeout und die Statusprüfung.

Attribute statt Schlüssel

Der Client dekodiert die Antwort für dich und gibt sie als Objekt zurück. Die Werte sind dieselben wie im JSON-Dokument; du erreichst sie mit Punkten statt mit eckigen Klammern:

Kapitel 1, ein dekodiertes DictionaryKapitel 5, das Objekt des Clients
document["choices"][0]["message"]["content"]response.choices[0].message.content
document["choices"][0]["finish_reason"]response.choices[0].finish_reason
document["usage"]["total_tokens"]response.usage.total_tokens

choices ist weiterhin eine Liste, also bleibt [0]. Jeder Schlüssel dazwischen wird zu einem Attribut, so wie du in Python in der Praxis error.response bei einer Ausnahme und in Kapitel 4 question.choices bei einem Pydantic-Modell gelesen hast. Die Objekte, die der Client zurückgibt, sind tatsächlich Pydantic-Modelle, also gibt dir response.model_dump() die ganze Antwort als Dictionary zurück, falls du sie einmal ausgeben oder speichern willst.

Das Lesen eines Schlüssels, den es nicht gibt, hat KeyError ausgelöst. Das Lesen eines Attributs, das es nicht gibt, löst AttributeError aus. Und wenn du aus Gewohnheit response["choices"] schreibst, löst das TypeError aus, weil sich das Objekt nicht mit einem String indizieren lässt.

Fehler kommen vom Client

Weil der Client den Status selbst prüft, erreicht eine fehlgeschlagene Anfrage deinen Code nie als Antwort. Sie löst einen der eigenen Fehler des Clients aus, alle im Paket openai:

  • ein 500 vom Dienst löst openai.InternalServerError aus;

  • ein Dienst, der nicht erreichbar ist, löst openai.APIConnectionError aus;

  • ein Warten, das länger als der Timeout dauert, löst openai.APITimeoutError aus, eine Art von APIConnectionError.

ask fängt keinen davon ab. Wie bei send_body entscheidet der Aufrufer, was ein Fehlschlag bedeutet, und Kapitel 9 baut den Code dafür.

Baue ask

ask(question, *, client) in client_calls.py:

  1. Mache einen Aufruf: client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}]). Übergib sonst nichts.

  2. Lies response.choices[0].message.content.

  3. Gib den Wert zurück, oder "", wenn er None ist, so wie answer_text es getan hat.

Der Parameter client steht nach dem *, also müssen Aufrufer ihn benennen: ask("What is a list?", client=client). Er hat keinen Standardwert. Das ist die Test-Nahtstelle aus den Kapiteln 1 bis 4, mit einer Änderung: Dort bedeutete session=None „verwende requests“; hier übergibt jeder Aufrufer einen Client. Die Demonstration übergibt make_client(). Die Prüfung deiner Arbeit übergibt einen Fake-Client, der jeden Aufruf aufzeichnet und eine vorbereitete Antwort zurückgibt. ask muss also den Client verwenden, den es bekommt, und darf nie einen eigenen bauen.

Ausführen

Führe python client_calls.py aus. Die Demonstration stellt eine Frage:

print(ask("What is a Python list?", client=client))
One question through the client:
A list is an ordered, changeable collection of values. You write one with square brackets, like [1, 2, 3], and you can add, remove and change items after creating it.
A streamed reply:
Run stopped at the next function to build: stream_chat is built in Lesson 3.

Das ist die Antwort des geskripteten Modells auf diese Frage, dieselbe, die ask_model in Kapitel 1 bekommen hat.

Live ausprobieren (optional)

Wenn dein Konto Live-Zugang hat, sende dieselbe Frage an das Live-Modell. Füge dies in show_progress direkt unter der Zeile print(ask("What is a Python list?", client=client)) ein und führe python client_calls.py aus:

response = client.chat.completions.create(model="pl-live", messages=[{"role": "user", "content": "What is a Python list?"}])
print(response.choices[0].message.content)
print(response.usage.total_tokens, "tokens")

Text, den du an pl-live sendest, verlässt Python Land, also sende nichts Privates. Wenn dein Konto keinen Live-Zugang hat, bekommst du openai.PermissionDeniedError, den Fehler des Clients für ein 403. openai.RateLimitError ist ein 429: Du hast das Limit vorerst erreicht. openai.APITimeoutError ist bei einem Live-Modell ein normales Ergebnis, denn es kann länger nachdenken, als der Timeout des Kurses erlaubt. Entferne die Zeilen wieder, wenn du fertig bist.

Kapitel 1 hat den Finish-Reason als document["choices"][0]["finish_reason"] gelesen. Wie liest du ihn aus der Antwort des Clients?

Der Dienst beantwortet die Anfrage von ask mit dem Status 500. Was erreicht den Code, der ask aufgerufen hat?

Aufgabe

Ersetze in client_calls.py den unfertigen Rumpf von ask(question, *, client).

  • Mache einen Aufruf: client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}]), und übergib sonst nichts.

  • Gib response.choices[0].message.content zurück, oder "", wenn es None ist.

  • Fange nichts ab: Fehler vom Client erreichen den Aufrufer.

Verwende den client, den du bekommst; baue keinen innerhalb von ask. Führe python client_calls.py aus, um den Antworttext zu sehen, und prüfe dann deine Arbeit.