0%

Een LLM-aanroep is een HTTP-request · eindproject

Eindproject: Project: stel één vraag vanaf de opdrachtregel

Je hebt vier geteste functies in llm_basics.py: send_body verstuurt een request, ask_model maakt van een vraag een chatrequest, answer_text leest het antwoord en call_cost berekent de prijs van de aanroep. Dit project zet ze achter een commando dat je vanuit de kunt uitvoeren:

$ python ask.py "What is a Python list?"
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.
Tokens: 6 in, 42 out. Cost at live prices: $0.00000564

Elk onderdeel ervan heb je al eerder gebouwd of gebruikt. Het werk zit in het samenvoegen, zodat het commando zich netjes gedraagt, ook als de modeldienst niet antwoordt.

Wat ask.py doet

Maak ask.py naast llm_basics.py en importeer daaruit wat je nodig hebt. Het bestand definieert één functie, main(argv=None, *, session=None):

  1. Verwerk de met argparse. Er is één positioneel argument, question. Doordat je argv doorgeeft aan parse_args(argv), kan een controle main(["What is a Python list?"]) direct aanroepen, terwijl een echte run met argv=None de argumenten uit de terminal leest, zoals in Python in de praktijk.

  2. Roep ask_model aan met de vraag en geef session=session door, zodat een controle een nep-versie kan meegeven.

  3. Druk het antwoord af met answer_text.

  4. Druk nog één regel af met de tokenaantallen uit de usage van de response en de kosten van call_cost tegen LIVE_PRICES, precies in deze vorm, met de kosten op acht decimalen:

    Tokens: 6 in, 42 out. Cost at live prices: $0.00000564
    
  5. Geef 0 terug.

De module eindigt met de regel die main alleen uitvoert als het bestand als programma wordt gestart:

if __name__ == "__main__":
    raise SystemExit(main())

raise SystemExit(main()) maakt van het getal dat main teruggeeft de exitcode van het programma. Als je ask importeert vanuit een andere module of een controle, wordt er niets uitgevoerd, omdat __name__ dan "ask" is.

Als het request mislukt

De modeldienst kan uitgevallen of traag zijn, of met een foutstatus antwoorden. Al die gevallen komen naar boven als exceptions van requests: een verbindingsfout, een time-out, of de HTTPError die raise_for_status() binnen send_body opwerpt. Ze hebben één gemeenschappelijke ouderklasse, requests.RequestException, dus één except-clausule rond de aanroep van ask_model vangt ze allemaal.

Als dat gebeurt, druk je één regel af naar de standaardfout (standard error) in plaats van een traceback:

Model request failed: <the error>

ask.py heeft import requests nodig voor de exceptionklasse en import sys voor print(..., file=sys.stderr), dat naar de standaardfout schrijft. Geef daarna 1 terug. Vang alleen requests.RequestException af, en alleen rond het request. Een KeyError of TypeError door een fout in je eigen code moet het programma nog steeds stoppen met zijn traceback, want als je die verbergt, is de fout veel moeilijker te vinden.

Voer het uit

Voer het commando in de terminal uit met een vraag tussen aanhalingstekens, zodat de shell die als één argument doorgeeft:

python ask.py "What is a Python list?"
python ask.py "What does len() return?"
python ask.py "Tell me a joke."

De eerste twee zijn voorbereide vragen. De derde krijgt de gescripte echo, dus het antwoord is vier regels lang en de tokenaantallen veranderen mee. Voer je python ask.py uit zonder vraag, dan drukt argparse een gebruiksmelding af en stopt met status 2 voordat er een request wordt gedaan.

Loop je vast, vraag Monty dan om een hint over één stap, bijvoorbeeld het uitlezen van de tokenaantallen uit usage, zonder om het hele bestand te vragen.

Waarom vangt main requests.RequestException af en niet Exception?

Opdracht

Maak ask.py met main(argv=None, *, session=None):

  • Verwerk met argparse één positioneel argument, question, uit argv.

  • Roep ask_model(question, session=session) uit llm_basics aan.

  • Druk het antwoord van answer_text af en daarna Tokens: {I} in, {O} out. Cost at live prices: ${cost:.8f}, waarbij I en O de prompt_tokens en completion_tokens van de response zijn en cost de uitkomst van call_cost voor de usage ervan tegen LIVE_PRICES. Geef 0 terug.

  • Als het request requests.RequestException opwerpt, druk je Model request failed: {error} af naar de standaardfout en geef je 1 terug. Vang verder niets af.

  • Sluit het bestand af met if __name__ == "__main__": raise SystemExit(main()), zodat het importeren van ask niets uitvoert.

Probeer python ask.py "What is a Python list?" in de en controleer daarna je werk.