Агентно програмиране с извикване на инструменти
На тази страница
Урокът е актуализиран на 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) - Многократният цикъл позволява на агента да повтаря действията си до пълно разрешаване на задачата
- Агентът модифицира множество файлове съгласувано в рамките на една задача
- Фазата на проверка (тестове, компилация) е съществена за надеждността