Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Razgovor u više koraka

Lekcija 7 od 14 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Izvan pojedinačnih poziva
  2. Načelo: Održavanje povijesti
  3. Potpuna petlja razgovora
  4. Primjer razgovora u više koraka
  5. Lančano povezivanje sekvencijalnih poziva
  6. Upravljanje veličinom povijesti
  7. Ključne točke

Izvan pojedinačnih poziva

U stvarnoj aplikaciji korisnici ne postave jedno pitanje i nestanu. Oni povezuju zahtjeve, vraćaju se na prethodne teme i ubacuju naznake poput „što je s ovim?“ koje sama rečenica ne može razriješiti. Pozivanje funkcija mora raditi unutar ovog konteksta razgovora u više koraka, gdje model može pozivati funkcije u svakom koraku dijaloga, a da pritom nikada ne izgubi nit onoga što je prethodilo.

Načelo: Održavanje povijesti

Ključ se svodi na jednu rečenicu: čuvaj sve poruke u listi koja raste sa svakom razmjenom. Model nema vlastito pamćenje između API poziva; jedini kontekst koji ima jest ono što mu pošalješ natrag. Upravo ta potpuna povijest omogućuje mu razumijevanje implicitnih referenci.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Povijest razgovora
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Potpuna petlja razgovora

Kod ispod radi u dvije faze. process_tool_calls izvršava sve pozive koje je model zatražio i ponovno pokreće razgovor s rezultatima; chat obrađuje cijeli korak, od korisnikovog unosa do konačnog teksta.

def process_tool_calls(response, messages, available_functions, tools):
    """Obrađuje tool_calls i vraća konačni odgovor."""
    message = response.choices[0].message
    messages.append(message)

    # Izvrši svaki tool_call
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Ponovno pozovi model s rezultatima
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Obrađuje cijeli korak razgovora."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Ponavljaj sve dok model želi pozivati funkcije
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Model je završio – odgovara tekstom
    messages.append(message)
    return message.content

Petlja while ključni je dio. Nakon primitka rezultata funkcije, model može zatražiti još jedan: petlja se nastavlja sve dok proizvodi tool_calls i zaustavlja se tek kada konačno vrati tekst. Običan if obradio bi prvi poziv, a zatim vratio prazan odgovor u svakom slučaju gdje su bila potrebna dva poziva.

Primjer razgovora u više koraka

Pogledajmo kako ta petlja izgleda kroz četiri povezana koraka.

# Korak 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Korak 2 — pitanje za nastavak
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Korak 3 — nova transakcija
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Korak 4 — pitanje bez funkcije
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

Korak 2 je onaj koji trebaš pažljivo ispitati. „When was it made?“ ne sadrži identifikator; povijest je ono što modelu omogućuje da shvati kako se to i dalje odnosi na T1001 i da pozove retrieve_payment_date s ispravnim argumentom. Ukloniš li poruke iz Koraka 1, ova rečenica postaje nerješiva. U Koraku 3 model može odlučiti pozvati više funkcija – status i datum za T1003 – kako bi izgradio usporedbu s rezultatima već dobivenima za T1001. Korak 4 ne pokreće nikakve pozive: model zna i kada se treba suzdržati.

Lančano povezivanje sekvencijalnih poziva

Neki zahtjevi zahtijevaju da model pričekaju jedan rezultat prije nego što zna što dalje pitati. Petlja while u chat() obrađuje ovaj slučaj bez ijednog dodatnog retka koda.

# Korisnik traži nešto što zahtijeva 2 sekvencijalna poziva
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Model može:
# 1. Pozvati retrieve_payment_status(T1002)
# 2. Primiti rezultat
# 3. Pozvati retrieve_payment_date(T1002)
# 4. Primiti rezultat
# 5. Formulirati konačni odgovor s obje informacije

Gledano iz perspektive povijesti poruka, sekvencijalni tok izgleda ovako:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Prebroj korake asistenta: tri, što znači tri zahtjeva naplaćena od API-ja. To je cijena sekvencijalnog izvršavanja i razlog zbog kojeg se sljedeća lekcija fokusira na paralelne pozive.

Upravljanje veličinom povijesti

U proizvodnji, dugotrajan razgovor postaje skup: svaki korak šalje natrag cijeli skup prethodnih poruka, a račun za tokene raste kvadratno. Jednostavna strategija je zadržati samo sistemsku poruku i najnovije razmjene.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Zadržava sistemsku poruku i zadnjih N poruka."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Jedan oprez prije povezivanja ove funkcije: nikada ne odsijeci tool_call bez njegove odgovarajuće tool poruke. Ako se skraćivanje dogodi između ta dva, API prima neobrađen zahtjev za poziv i odbija upit. Prilagodi točku rezanja tako da sačuvaš kompletne parove umjesto da slijepo brojiš poruke.

Ključne točke

  • Održavaj potpunu povijest poruka kako bi model razumio kontekst
  • Koristi petlju while za rukovanje sekvencijalnim pozivima funkcija
  • Model razumije implicitne reference („taj“, „prethodni“) zahvaljujući kontekstu
  • U proizvodnji ograniči veličinu povijesti dok održavaš parove tool_call/tool netaknutima
  • Funkcija chat() prikazana ovdje predstavlja obrazac koji se može ponovno koristiti za bilo koju aplikaciju koja poziva funkcije