De OpenAI-client gebruiken · oefening
Dezelfde aanroep via de client
In hoofdstuk 1 kostte één vraag twee functies. ask_model bouwde de body en postte die, en answer_text viste de antwoordtekst uit het gedecodeerde antwoord. Met de client is het één aanroep en één regel om het antwoord te lezen. De body die bij llm-api aankomt, is dezelfde.
Hetzelfde request, op twee manieren geschreven
Dit is de manier van hoofdstuk 1, met alles wat send_body en answer_text deden uitgeschreven:
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"]
En dit is hetzelfde request via de client:
response = client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}])
answer = response.choices[0].message.content
client.chat.completions.create volgt het pad van het endpoint, /chat/completions. Elk keywordargument wordt één veld van de requestbody, dus model=MODEL en messages=[...] sturen precies de body die hoofdstuk 1 bouwde. De client voegt de basis-URL, de time-out en de statuscontrole toe.
Attributen in plaats van sleutels
De client decodeert het antwoord voor je en geeft het terug als object. De waarden zijn dezelfde als in het JSON-document; je bereikt ze met punten in plaats van vierkante haken:
| Hoofdstuk 1, een gedecodeerde dictionary | Hoofdstuk 5, het object van de client |
|---|---|
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 is nog steeds een lijst, dus [0] blijft staan. Elke sleutel daartussen wordt een attribuut, zoals je in Python in de praktijk error.response las op een exception en in hoofdstuk 4 question.choices op een pydantic-model. De objecten die de client teruggeeft, zijn zelfs pydantic-modellen, dus response.model_dump() geeft je het hele antwoord terug als dictionary, mocht je het ooit willen afdrukken of opslaan.
Een sleutel lezen die niet bestaat, gaf KeyError. Een attribuut lezen dat niet bestaat, geeft AttributeError. En wie uit gewoonte response["choices"] schrijft, krijgt TypeError, omdat je het object niet met een string kunt indexeren.
Fouten komen van de client
Omdat de client de status zelf controleert, bereikt een mislukt request je code nooit als response. De client werpt dan een van zijn eigen fouten op, die allemaal in het pakket openai zitten:
een
500van de dienst geeftopenai.InternalServerError;een dienst die onbereikbaar is, geeft
openai.APIConnectionError;een wachtperiode langer dan de time-out geeft
openai.APITimeoutError, een soortAPIConnectionError.
ask vangt geen van deze fouten af. Net als bij send_body bepaalt de aanroeper wat een mislukking betekent, en hoofdstuk 9 bouwt de code die dat doet.
Bouw ask
ask(question, *, client) in client_calls.py:
Doe één aanroep:
client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}]). Geef verder niets mee.Lees
response.choices[0].message.content.Geef die terug, of
""als dieNoneis, zoalsanswer_textdeed.
De parameter client komt na de *, dus aanroepers moeten hem bij naam noemen: ask("What is a list?", client=client). Hij heeft geen standaardwaarde. Dat is het inhaakpunt voor tests uit hoofdstuk 1 tot en met 4, met één verschil: daar betekende session=None “gebruik requests”; hier geeft elke aanroeper een client mee. De demonstratie geeft make_client() mee. De controle van je werk geeft een nep-client mee die elke aanroep vastlegt en een voorbereid antwoord teruggeeft, dus ask moet de client gebruiken die hij krijgt en er nooit zelf een bouwen.
Voer het uit
Voer python client_calls.py uit. De demonstratie stelt één vraag:
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.
Dat is het antwoord van het gescripte model op deze vraag, hetzelfde dat ask_model uit hoofdstuk 1 kreeg.
Probeer het live (optioneel)
Als je account live toegang heeft, stuur dan dezelfde vraag naar het live model. Plak dit in show_progress direct onder de regel print(ask("What is a Python list?", client=client)) en voer python client_calls.py uit:
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")
Tekst die je naar pl-live stuurt, verlaat Python Land, dus stuur niets privés. Heeft je account geen live toegang, dan krijg je openai.PermissionDeniedError, de fout van de client voor een 403. openai.RateLimitError is een 429: je hebt voorlopig de limiet bereikt. openai.APITimeoutError is een normale uitkomst bij een live model, dat langer kan nadenken dan de time-out van de cursus. Haal de regels weer weg als je klaar bent.
Hoofdstuk 1 las de finish reason als document["choices"][0]["finish_reason"]. Hoe lees je die uit het antwoord van de client?
De dienst beantwoordt het request van ask met status 500. Wat bereikt de code die ask aanriep?
Opdracht
Vervang in client_calls.py de onafgemaakte body van ask(question, *, client).
Doe één aanroep:
client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": question}]), en geef verder niets mee.Geef
response.choices[0].message.contentterug, of""als dieNoneis.Vang niets af: fouten van de client bereiken de aanroeper.
Gebruik de client die je krijgt; bouw er geen binnen ask. Voer python client_calls.py uit om het antwoord te zien, en controleer daarna je werk.