Премини към основното съдържание
Български— Изберете език
Меню

Многократен диалог

Урок 7 от 14 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Отвъд единичните заявки
  2. Принципът: Поддържане на историята
  3. Пълен цикъл на разговора
  4. Пример за многократен диалог
  5. Верижно свързване на последователни извиквания
  6. Управление на размера на историята
  7. Ключови изводи

Отвъд единичните заявки

В реално приложение потребителите не задават един въпрос и не изчезват. Те верижат заявки, връщат се към предишни теми и пускат намеци като „а какво става с този?“, които самото изречение не може да разреши. Извикването на функции трябва да работи в контекста на многократен диалог, където моделът може да извиква функции на всяка стъпка от разговора, без никога да губи следа за предишното.

Принципът: Поддържане на историята

Ключът се свежда до едно изречение: пазете всички съобщения в списък, който расте с всяка размяна. Моделът няма собствена памет между API повикванията; единственият контекст, с който разполага, е това, което му изпратите обратно. Тази пълна история му позволява да разбира имплицитни препратки.

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"

# История на разговора
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Пълен цикъл на разговора

Кодът по-долу работи на два етапа. process_tool_calls изпълнява всички заявки, направени от модела, и рестартира разговора с резултатите; chat обработва пълен ход – от входа на потребителя до крайния текст.

def process_tool_calls(response, messages, available_functions, tools):
    """Обработва tool_calls и връща крайния отговор."""
    message = response.choices[0].message
    messages.append(message)

    # Изпълнение на всяко 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
        })

    # Повторно извикване на модела с резултатите
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Обработва пълен ход на разговора."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Цикъл, докато моделът иска да извиква функции
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Моделът приключи – отговаря с текст
    messages.append(message)
    return message.content

Цикълът while е критичният елемент. След получаване на резултат от функция, моделът може да поиска друга: цикълът продължава, докато се генерират tool_calls, и спира едва когато най-накрая върне текст. Обикновено if би обработило първото извикване и след това би върнало празен отговор във всеки случай, когато са нужни две извиквания.

Пример за многократен диалог

Нека видим как изглежда този цикъл през четири свързани хода.

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

# Ход 2 — последващ въпрос
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Ход 3 — нова транзакция
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Ход 4 — въпрос без функция
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."

Ход 2 е този, който трябва да разгледате внимателно. „When was it made?“ не съдържа идентификатор; историята е тази, която позволява на модела да разбере, че това все още се отнася за T1001 и да извика retrieve_payment_date с правилния аргумент. Премахнете съобщенията от Ход 1 и това изречение става нерешимо. В Ход 3 моделът може да реши да извика няколко функции – статус и дата за T1003 – за да изгради сравнението с вече получените резултати за T1001. Ход 4 не задейства никакви извиквания: моделът знае кога да се въздържа също.

Верижно свързване на последователни извиквания

Някои заявки изискват моделът да изчака един резултат, преди да знае какво да поиска след това. Цикълът while във chat() обработва този случай без нито един допълнителен ред код.

# Потребителят иска нещо, изискващо 2 последователни извиквания
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Моделът може:
# 1. Да извика retrieve_payment_status(T1002)
# 2. Да получи резултата
# 3. Да извика retrieve_payment_date(T1002)
# 4. Да получи резултата
# 5. Да формулира крайния отговор с двете части информация

Гледано от историята на съобщенията, последователният поток изглежда така:

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

Пребройте ходове на асистента: три, което означава три заявки, таксувани от API. Това е цената на последователното изпълнение и причината следващият урок да се фокусира върху паралелните извиквания.

Управление на размера на историята

В производствена среда дълготрайният разговор става скъп: всеки ход изпраща обратно целия набор от предишни съобщения и сметката за токени расте квадратично. Проста стратегия е да се запазват само системното съобщение и най-скорошните размени.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Запазва системното съобщение и последните N съобщения."""
    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

Една предпазна мярка, преди да свържете тази функция: никога не отрязвайте tool_call без съответното му съобщение tool. Ако съкращаването попадне между двете, API получава неотговорена заявка за извикване и отхвърля заявката. Коригирайте точката на рязане, за да запазите пълни двойки, вместо да броите съобщенията сляпо.

Ключови изводи

  • Поддържайте пълна история на съобщенията, за да разбира моделът контекста
  • Използвайте цикъл while, за да обработвате последователни извиквания на функции
  • Моделът разбира имплицитни препратки („този“, „предишният“) благодарение на контекста
  • В производствена среда ограничавайте размера на историята, като запазвате двойките tool_call/tool непокътнати
  • Функцията chat(), показана тук, е многократен шаблон за всяко приложение с извикване на функции