0%

Een LLM-aanroep is een HTTP-request · oefening

Een request kan een body meesturen

Een modelaanroep is een HTTP-request. De dienst is llm-api, de basis-URL is http://llm-api:8080/v1, en je praat ermee via requests, net zoals je in Python in de praktijk met de oefen-API praatte. Open llm_basics.py in de projecteditor. Daarin staan de constanten die je nodig hebt en vijf onafgemaakte functies. In deze les bouw je de eerste twee.

Begin met een request dat je al kent

De dienst kan je vertellen welke modellen hij aanbiedt. Een GET naar /models geeft dit document terug:

{"object": "list", "data": [{"id": "pl-scripted", "object": "model", "owned_by": "python-land"}, {"id": "pl-live", "object": "model", "owned_by": "python-land"}]}

De modelnamen zijn de id-waarden in de lijst data. list_models() haalt dat document op en geeft de ids op volgorde terug, dus voor dit document geeft hij ["pl-scripted", "pl-live"] terug:

def list_models(*, session=None):
    http = requests if session is None else session
    response = http.get(f"{BASE_URL}/models", timeout=TIMEOUT)
    response.raise_for_status()
    ids = []
    for model in response.json()["data"]:
        ids.append(model["id"])
    return ids

Elke regel hier heb je al eens geschreven. session=None is het inhaakpunt (seam) uit hoofdstuk 11 van Python in de praktijk: normaal gebruikt de functie requests, en een controle kan hem een nep-sessie geven die het request vastlegt in plaats van het te versturen. timeout=TIMEOUT begrenst het wachten met de constante bovenaan het bestand, (3.05, 10): maximaal 3.05 seconden om verbinding te maken en maximaal 10 seconden voor elke wachtpauze terwijl het antwoord binnenkomt. raise_for_status() maakt van een foutstatus een exception voordat er JSON gelezen wordt.

Elke functie in deze cursus die met llm-api praat, volgt dit patroon, dus het loont om het één keer zelf uit te typen in plaats van het te plakken.

Een POST stuurt een body mee

Een GET zet zijn hele vraag in de URL. Dat werkt voor “welke modellen zijn er?”, maar een modelaanroep moet het model een prompt sturen, vaak een lange, plus instellingen. Dat gaat in de body van het request: gegevens die met het request meegaan, na de URL en de headers. Een request dat een body meestuurt om te verwerken, is meestal een POST.

Het chat-endpoint, /chat/completions, neemt een JSON-body. JSON is het tekstformaat dat je in Python in de praktijk met .json() decodeerde; hier stuur je het de andere kant op. Een kleine body ziet er als Python-dictionary zo uit:

body = {"model": "pl-scripted", "messages": [{"role": "user", "content": "Hello"}]}

requests maakt van een dictionary een JSON-body als je hem meegeeft als json=:

response = http.post(f"{BASE_URL}/chat/completions", json=body, timeout=TIMEOUT)

json=body doet twee dingen: het zet de dictionary om in JSON-tekst, en het voegt een header Content-Type: application/json toe zodat de dienst weet hoe hij hem moet lezen. De statuscontrole en .json() werken precies zoals na een GET.

send_body(body) is die POST, verpakt in hetzelfde patroon als list_models: kies requests of de meegegeven sessie, POST de body met json=body en timeout=TIMEOUT, werp bij een foutstatus een exception op, en geef het gedecodeerde JSON-antwoord ongewijzigd terug.

Zie wat het model ontving

Als pl-scripted een prompt niet herkent, antwoordt het met een echo: een kort verslag van wat het ontving. Hello is geen van zijn voorbereide vragen, dus de body hierboven krijgt een echo terug.

Je voert je code uit in een , zoals in Python in de praktijk. Open het tabblad Shell naast Project en kies Start Bash terminal. Typ python llm_basics.py en druk op Enter. De terminal blijft draaien tot je hem sluit, dus na elke wijziging kun je hetzelfde commando opnieuw uitvoeren; met pijltje omhoog haal je het terug. Check my work is een knop in de werkbalk van het tabblad Shell.

Als beide functies werken, voer je python llm_basics.py uit. De demonstratie onderaan het bestand toont de modellen, drukt de body af die ze verstuurde en daarna het gedecodeerde antwoord:

Models: ['pl-scripted', 'pl-live']
Sent: {"model": "pl-scripted", "messages": [{"role": "user", "content": "Hello"}]}
Received:
{
  "id": "chatcmpl-scripted-91b01cf4fa744410ab443153",
  "object": "chat.completion",
  "created": 1794134874,
  "model": "pl-scripted",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "[pl-scripted echo] No scripted reply matches this prompt, so here is what I received.\nMessages: 1\nSystem message: (none)\nLast user message: Hello"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 2,
    "completion_tokens": 37,
    "total_tokens": 39
  }
}

Jouw id en created zullen anders zijn; die veranderen bij elke aanroep. Zoek de regel die begint met "content". Elke \n daarin is een regeleinde, dus de echo zegt: één bericht, geen systeembericht, en het laatste gebruikersbericht was Hello. Dat klopt met het bericht dat je stuurde: één bericht, geen systeembericht, en de tekst Hello. In les 5 zie je hoe je die tekst er met Python uithaalt. Merk voor nu op dat je kunt controleren wat het model bereikte zonder te gissen.

Na de uitvoer zie je een regel met Run stopped at the next function to build. Dat is de bedoeling: de demonstratie roept elke functie aan die je tot nu toe gebouwd hebt en stopt bij de eerste die je nog niet hebt. Je ziet die regel in de volgende lessen terug, telkens met een latere functie erin.

Als het commando in plaats daarvan Could not reach llm-api afdrukt, is de dienst uitgevallen of wordt hij herstart. Probeer het over een paar minuten opnieuw. Voor het controleren van je werk is hij niet nodig.

Wat doet json=body in http.post(url, json=body, timeout=TIMEOUT)?

Opdracht

Vervang in llm_basics.py de onafgemaakte bodies van list_models en send_body.

  • list_models(*, session=None) doet één GET naar f"{BASE_URL}/models" met timeout=TIMEOUT, roept raise_for_status() aan en geeft de id van elk item in de lijst data van het document terug, op volgorde.

  • send_body(body, *, session=None) doet één POST naar f"{BASE_URL}/chat/completions" met json=body en timeout=TIMEOUT, roept raise_for_status() aan en geeft het gedecodeerde JSON-antwoord ongewijzigd terug.

Beide gebruiken requests als session gelijk is aan None, en anders de meegegeven sessie. Voer in het tabblad Shell python llm_basics.py uit om de echo te zien en controleer daarna je werk.