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

Агентно програмиране с извикване на инструменти

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

Урокът е актуализиран на 2 ноември 2026 г. Оригиналният пример използваше Devstral, който беше премахнат от API на 31 юли 2026 г. Сега те използват Mistral Small 4 (mistral-small-2603), а агентният цикъл следва модела на документацията на Mistral (всички извиквания на инструменти в отговор се обработват до получаване на крайния отговор). Източник: Function calling.

Какво е агентно програмиране?

Агентното програмиране променя същността на това, което искате от модела да направи. Вместо да поискате един фрагмент код, после втори, после трети и да ги сглобите сами, Вие възлагате цялостна задача. Моделът я решава, като сам свързва стъпките: проучване, планиране, изпълнение и проверка. Вие оставате лицето, което взема решенията за това какво трябва да се направи, но спирате да микроуправлявате всяко движение.

Моделите Devstral бяха създадени за този работен поток; текущите модели с общо предназначение, водени от Mistral Small 4, го обработват чрез извикване на инструменти. Един агент не просто отговаря на въпрос; той действа върху хранилището с код.

Агентният цикъл

Фаза 1 — Разбиране

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

Фаза 2 — Планиране

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

Фаза 3 — Изпълнение

Изпълнението разгръща плана стъпка по стъпка. Агентът редактира съществуващи файлове, създава нови, когато структурата го изисква, актуализира импорти и зависимости, променени от неговите действия, и коригира конфигурационните файлове по пътя. Съгласуваността на тези промени е точно онова, което модел за автоматично допълване не може да гарантира.

Фаза 4 — Проверка

Накрая идва доказателството, че работата е устойчива. Агентът стартира съществуващия набор от тестове, пише нови тестове за току-що добавения код, гарантира, че компилацията (build) преминава успешно, и преглежда собствената си разлика (diff) за грешки или случайни промени. Агент, който пропуска тази фаза, произвежда правдоподобен код, а не правилен код.

Пример от практиката: поправяне на бъг

Да предположим, че кажете на агента: „Потребителите получават грешка 500, когато изпратят форма с имейл, съдържащ ’+’.“ Тогава цикълът приема следната форма:

1. РАЗБИРАНЕ
   -> Търсене на файлове, свързани с формата (търсене на "email" в кода)
   -> Четене на контролера, обработващ изпращането
   -> Четене на функцията за валидиране на имейл
   -> Идентифициране на регулярния израз, отхвърлящ '+'

2. ПЛАНИРАНЕ
   -> Модифициране на регулярния израз за валидиране, за да приема '+'
   -> Добавяне на юнит тест за имейли с '+'
   -> Проверка дали няма друга част от кода, която филтрира '+'

3. ИЗПЪЛНЕНИЕ
   -> Модифициране на src/validators/email.py: поправка на шаблона на регулярния израз
   -> Създаване на tests/test_email_validation.py: добавяне на случаи с '+'
   -> Модифициране на src/controllers/form.py: добавяне на запис в логовете за дебъгване

4. ПРОВЕРКА
   -> Стартиране на pytest -> всички тестове преминават
   -> Проверка на diff -> промените са съгласувани и минимални

Забележете третия ред на плана: агентът не просто поправя мястото, където бъгът се проявява; той проверява дали няма друг филтър, който отхвърля символа на друго място. Това търсене на първопричината, а не само на симптома, е което отличава агентната поправка от локален кръпкач.

Използване на инструменти на практика

Агентът действа върху своята среда чрез извиквания на функции. Вие декларирате наличните инструменти в заявката, включително тяхното име, описание и схема на параметрите; моделът избира кои да извика и с какви аргументи.

# Пример за агентен разговор
messages = [
    {
        "role": "user",
        "content": "Add strong password validation to the auth module."
    }
]

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the content of a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "File path"}
                },
                "required": ["path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write or modify a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Execute a shell command",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string"}
                },
                "required": ["command"]
            }
        }
    }
]

response = client.chat.complete(
    model="mistral-small-2603",
    messages=messages,
    tools=tools,
    tool_choice="auto",   # default value: the model decides whether to call a tool
)

За тази заявка типичната последователност започва с read_file("src/auth/validators.py"), за да се разбере съществуващият код, продължава с read_file("tests/test_auth.py"), за да се види форматът на текущите тестове, след което преминава към записване: write_file("src/auth/validators.py", ...) с добавеното правило за валидиране, write_file("tests/test_auth.py", ...) с новите случаи и накрая run_command("pytest tests/test_auth.py") за проверка. Редът има значение: като отваря и двата файла, преди да докосне и един символ, агентът възприема Вашите конвенции и ги възпроизвежда, вместо да импортира такива, които е виждал другаде.

Многократен агентен цикъл

Нищо от това не се случва в едно единствено извикване. Сърцето на агентното програмиране е многократният цикъл: моделът предлага действие, Вашият код го изпълнява и Вие изпращате резултата обратно, за да може той да реши следващата стъпка. Вие запазвате контрола над действителното изпълнение, което служи и като Ваша предпазна мярка.

import json

TOOLS = {"read_file": read_file, "write_file": write_file, "run_command": run_command}

response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)

for _ in range(30):   # guardrail: an agent must never loop indefinitely
    tool_calls = response.choices[0].message.tool_calls
    if not tool_calls:
        break         # no more tool calls: the final answer has arrived
    for tool_call in tool_calls:   # a response can contain multiple calls
        name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        result = TOOLS[name](**arguments)
        messages.append({
            "role": "tool",
            "name": name,
            "content": str(result),
            "tool_call_id": tool_call.id,
        })
    response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
    messages.append(response.choices[0].message)

print(response.choices[0].message.content)

Три детайла са от значение. Съобщението на агента и всеки резултат от инструмента се инжектират отново в историята, сдвоени чрез tool_call_id: пропуснете ли което и да е от двете, и агентът губи нишката, припомняйки си същите инструменти в безкраен цикъл. Един единствен отговор може да съдържа няколко извиквания на инструменти, тъй като паралелните извиквания са разрешени по подразбиране (parallel_tool_calls=False ги забранява): обработете ги всички. Накрая, ограничете броя на завъртанията и накарайте човек да валидира shell командите и записите във файлове: агент, който изпълнява всичко, което предложи, е риск, а не спестяване на време.

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

  • Агентното програмиране следва цикъл: разбиране, планиране, изпълнение, проверка
  • Агентът действа върху хранилището чрез извикване на инструменти (tools, tool_choice)
  • Многократният цикъл позволява на агента да повтаря действията си до пълно разрешаване на задачата
  • Агентът модифицира множество файлове съгласувано в рамките на една задача
  • Фазата на проверка (тестове, компилация) е съществена за надеждността