Hoofdstuk 5 · oefening
De OpenAI-client gebruiken
Installeer de client en richt hem op het cursusmodel
Vier hoofdstukken lang heb je met de hand met het cursusmodel gepraat. Elke aanroep bouwde het adres met f"{BASE_URL}/chat/completions", verstuurde de body met json=, gaf timeout=TIMEOUT mee, riep raise_for_status() aan, decodeerde het antwoord met .json() en viste de antwoordtekst eruit met een reeks sleutels. Hoofdstuk 3 voegde daar nog een streamlezer aan toe. Dat kun je nu allemaal zelf schrijven, en juist daarom geeft dit hoofdstuk het uit handen aan een bibliotheek.
Het pakket openai is een client voor diensten die dezelfde API spreken als llm-api. Je vertelt hem één keer waar de dienst is, en daarna is elke aanroep één regel. In dit hoofdstuk zet je de studieassistent erop over.
Je project voor dit hoofdstuk
Open client_calls.py in de projecteditor. Het bestand begint met deze 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 en quiz_models.py zijn de afgeronde code van hoofdstuk 4, en conversation.py en llm_basics.py die van hoofdstuk 2 en 1. Ze staan er allemaal naast. Je hoeft ze niet te veranderen. Net als eerder gebruikt de controle van je werk eigen kopieën, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen. errors.py bevat nog steeds StreamBroken, en prompts.py de vaste prompteksten.
import openai geeft je de foutklassen van het pakket, zoals openai.APIConnectionError. from openai import OpenAI haalt de clientklasse zelf binnen, zodat je OpenAI(...) kunt schrijven.
Onder de constanten staan zeven onafgemaakte functies, één of twee per les, en daarna drie afgeronde functies die de demonstratie in latere lessen gebruikt. Voer nu in de Shell python client_calls.py uit. Het programma stopt meteen bij de eerste functie die je moet bouwen:
Run stopped at the next function to build: make_client is built in Lesson 1.
Wat de client voor je doet
Een aanroep via de client doet hetzelfde werk als je send_body:
hij bouwt de URL uit een basisadres en het pad van het endpoint;
hij verstuurt de requestbody als JSON;
hij controleert de statuscode en werpt bij een mislukt request zijn eigen fout op in plaats van
requests.HTTPError;hij decodeert het antwoord en geeft het terug als object waarvan je de waarden met punten leest.
Het pakket is al geïnstalleerd in deze sandbox, in de versie waarvoor de cursus is geschreven. Wil je het op je eigen computer gebruiken, installeer het dan in een virtuele omgeving met pip install openai==3.37.0. requirements.txt in dit project noemt het samen met pydantic en requests.
Bouw make_client
make_client() geeft een client voor het cursusmodel terug:
def make_client():
return OpenAI(base_url=BASE_URL, api_key=API_KEY, timeout=CLIENT_TIMEOUT, max_retries=0)
De drie constanten die de functie gebruikt, staan bovenaan client_calls.py. Elk argument vervangt iets wat je vroeger met de hand schreef.
base_url=BASE_URL is het adres van het cursusmodel, http://llm-api:8080/v1. De client voegt zelf het pad van elk endpoint toe, zoals /chat/completions of /models, dus je bouwt nooit meer een URL. Hij slaat het adres op met een slash aan het eind.
api_key=API_KEY is een sleutel die de client met elk request meestuurt. De client weigert te starten zonder sleutel, tenzij de omgevingsvariabele OPENAI_API_KEY er een bevat. Doordat je zelf api_key= meegeeft, pakt de client nooit per ongeluk een echte sleutel van je computer op. llm-api controleert geen sleutel, dus API_KEY is de plaatsvervangende waarde "sandbox". Die is niet geheim. Een echte aanbieder heeft hier een echte sleutel nodig, en hoofdstuk 12 gebruikt er een.
timeout=CLIENT_TIMEOUT is 10.0, één getal in seconden. In hoofdstuk 1 gaf je een paar mee, (3.05, 10): één grens voor het openen van de verbinding, één voor elke keer dat je op gegevens wacht. De client neemt één getal en gebruikt dat voor elke wachtperiode: het openen van de verbinding, het versturen van het request en elke keer dat hij van de server leest. Het is geen limiet op de hele aanroep. Een lang gestreamd antwoord dat stukjes blijft sturen, bereikt die grens nooit, omdat elk stukje een nieuwe wachtperiode start, net als bij STREAM_TIMEOUT uit hoofdstuk 3. Een wachtperiode die de grens wel bereikt, werpt openai.APITimeoutError op.
max_retries=0 zet iets uit wat de client standaard doet: als een request op bepaalde manieren mislukt, stuurt hij het stilletjes opnieuw, tot twee keer extra. Les 5 laat zien hoe dat eruitziet en waarom deze cursus het uit laat tot hoofdstuk 9.
Twee regels voor de controles. Gebruik de constanten, niet opnieuw uitgetypte waarden, zodat de instellingen op één plek staan. En bouw de client binnen de functie, zodat elke aanroep van make_client() een nieuwe client teruggeeft en het importeren van client_calls.py niets bouwt.
Voer het uit
Voer python client_calls.py uit. De demonstratie bouwt een client, drukt drie van zijn instellingen af en vraagt de dienst welke modellen die heeft:
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 en client.max_retries zijn attributen van de client, die je met een punt leest. De lijst met modellen kwam uit deze lus in de demonstratie:
for model in client.models.list():
print(f" {model.id}")
client.models.list() verstuurt GET /v1/models en geeft één object per model terug. list_models uit hoofdstuk 1 las hetzelfde antwoord als dictionary, met model["id"]; hier heeft de client het al gedecodeerd, dus de id is het attribuut model.id.
Een client bouwen verstuurt niets. Pas een aanroep zoals client.models.list() bereikt de dienst. Daarom kan de controle van je werk een echte client bouwen en zijn instellingen lezen zonder netwerk.
Een gestreamd antwoord van een live model duurt in totaal 25 seconden, en elke halve seconde komt er een nieuw stukje binnen. De client is gebouwd met timeout=10.0. Wat gebeurt er?
Waarom geeft make_client api_key="sandbox" mee als llm-api geen sleutel controleert?
Opdracht
Vervang in client_calls.py de onafgemaakte body van make_client().
Geef
OpenAI(base_url=BASE_URL, api_key=API_KEY, timeout=CLIENT_TIMEOUT, max_retries=0)terug.Gebruik de constanten
BASE_URL,API_KEYenCLIENT_TIMEOUT, niet hun opnieuw uitgetypte waarden.Bouw de client binnen de functie, zodat elke aanroep een nieuwe client teruggeeft.
Voer python client_calls.py uit om de instellingen van de client te zien en de modellen die hij kan bereiken, en controleer daarna je werk.