Programowanie agentowe z wywoływaniem narzędzi
Na tej stronie
Lekcja zaktualizowana 2 listopada 2026 r. Oryginalne przykłady korzystały z modelu Devstral, który został usunięty z API 31 lipca 2026 r. Obecnie wykorzystują one Mistral Small 4 (
mistral-small-2603), a pętla agentowa podąża za modelem opisanym w dokumentacji Mistral (wszystkie wywołania narzędzi w odpowiedzi są przetwarzane aż do uzyskania końcowego wyniku). Źródło: Function calling.
Czym jest programowanie agentowe?
Programowanie agentowe zmienia charakter zadań, które powierzasz modelowi. Zamiast prosić o jeden fragment kodu, potem o drugi, następnie o trzeci i samodzielnie je scalać, przydzielasz kompletne zadanie. Model rozwiązuje je, samodzielnie łącząc kolejne kroki: eksplorację, planowanie, implementację i weryfikację. Ty pozostajesz decydentem w kwestii tego, co należy zrobić, ale przestajesz mikrozarządzać każdym ruchem.
Modele Devstral zostały stworzone z myślą o tym przepływie pracy; obecne modele ogólnego przeznaczenia, na czele z Mistral Small 4, obsługują go poprzez wywoływanie narzędzi. Agent nie tylko odpowiada na pytanie; on działa w repozytorium.
Cykl agentowy
Faza 1 — Zrozumienie
Agent zawsze zaczyna od rozeznania się w sytuacji. Odczytuje strukturę folderów i plików, identyfikuje pliki istotne dla żądanego zadania, śledzi zależności między modułami, aby zobaczyć, na co może wpłynąć zmiana, i odnotowuje istniejące konwencje – nazewnictwo, organizację testów oraz powtarzające się wzorce. Ta faza może wydawać się nieproduktywna, ponieważ nie generuje żadnego kodu, a jednak decyduje o tym, czy powstały kod będzie wyglądał jak Twój, czy jak dzieło osoby postronnej.
Faza 2 — Planowanie
Zanim agent napisze choćby jedną linię kodu, formułuje plan. Dzieli zadanie na uporządkowane podzadania, rozróżnia pliki do modyfikacji od tych, które należy utworzyć, przewiduje skutki uboczne i ryzyko regresji, a także ustala podejście techniczne. To moment, w którym Twoja interwencja jest najtańsza: skorygowanie planu zajmuje trzydzieści sekund; poprawianie dziesięciu plików, które już napisałeś, zajmuje znacznie więcej czasu.
Faza 3 — Wykonanie
Implementacja realizuje plan krok po kroku. Agent edytuje istniejące pliki, tworzy nowe, gdy wymaga tego struktura, aktualizuje importy i zależności przesunięte przez jego zmiany, a po drodze dostosowuje pliki konfiguracyjne. Spójność tych zmian to dokładnie to, czego model uzupełniający nie jest w stanie zagwarantować.
Faza 4 — Weryfikacja
Na koniec przychodzi dowód na to, że praca się obroniła. Agent uruchamia istniejący zestaw testów, pisze nowe testy dla właśnie dodanego kodu, upewnia się, że kompilacja przebiega pomyślnie, i przegląda własny diff w poszukiwaniu błędów lub przypadkowych modyfikacji. Agent, który pomija tę fazę, produkuje kod wyglądający na poprawny, a nie kod faktycznie działający.
Przykład praktyczny: naprawa błędu
Załóżmy, że mówisz agentowi: „Użytkownicy otrzymują błąd 500 podczas przesyłania formularza z adresem e-mail zawierającym znak ’+’“. Cykl przybiera wówczas następującą postać:
1. ZROZUMIENIE
-> Wyszukaj pliki związane z formularzem (wyszukaj „email“ w kodzie)
-> Przeczytaj kontroler obsługujący przesyłanie
-> Przeczytaj funkcję walidacji e-maila
-> Zidentyfikuj wyrażenie regularne odrzucające znak '+'
2. PLANOWANIE
-> Zmodyfikuj wyrażenie regularne walidacji, aby akceptowało znak '+'
-> Dodaj test jednostkowy dla e-maili zawierających '+'
-> Zweryfikuj, czy żadna inna część kodu nie filtruje znaku '+'
3. WYKONANIE
-> Zmodyfikuj src/validators/email.py: napraw wzorzec wyrażenia regularnego
-> Utwórz tests/test_email_validation.py: dodaj przypadki testowe z '+'
-> Zmodyfikuj src/controllers/form.py: dodaj logowanie do celów debugowania
4. WERYFIKACJA
-> Uruchom pytest -> wszystkie testy przechodzą pomyślnie
-> Sprawdź diff -> zmiany są spójne i minimalne
Zwróć uwagę na trzeci wiersz planu: agent nie tylko naprawia miejsce, w którym objawia się błąd; sprawdza również, czy żaden inny filtr nie odrzuca tego znaku gdzie indziej. To poszukiwanie przyczyny źródłowej, a nie tylko objawu, odróżnia naprawę agentową od doraźnej łatki.
Wykorzystanie narzędzi w praktyce
Agent działa na swoim środowisku poprzez wywołania funkcji. Deklarujesz dostępne narzędzia w żądaniu, podając ich nazwę, opis i schemat parametrów; model decyduje, których z nich użyć i z jakimi argumentami.
# Przykład konwersacji agentowej
messages = [
{
"role": "user",
"content": "Dodaj silną walidację hasła do modułu auth."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Odczytuje zawartość pliku projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Ścieżka do pliku"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Zapisuje lub modyfikuje plik projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Wykonuje polecenie powłoki",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # wartość domyślna: model decyduje, czy wywołać narzędzie
)
Dla tego żądania typowa sekwencja zaczyna się od read_file("src/auth/validators.py"), aby zrozumieć istniejący kod, kontynuuje przez read_file("tests/test_auth.py"), aby zobaczyć format obecnych testów, a następnie przechodzi do zapisu: write_file("src/auth/validators.py", ...) z dodaną regułą walidacji, write_file("tests/test_auth.py", ...) z nowymi przypadkami testowymi i na końcu run_command("pytest tests/test_auth.py") w celu weryfikacji. Kolejność ma znaczenie: otwierając oba pliki przed dotknięciem choćby jednego znaku, agent wychwytuje Twoje konwencje i je odwzorowuje, zamiast importować te, które widział gdzie indziej.
Wieloetapowa pętla agentowa
Żadne z powyższych nie dzieje się w ramach jednego wywołania. Sercem programowania agentowego jest pętla wieloetapowa: model proponuje działanie, Twój kod je wykonuje, a Ty odsyłasz wynik z powrotem, aby model mógł zdecydować o kolejnym kroku. Zachowujesz kontrolę nad rzeczywistym wykonaniem, co stanowi również Twoje zabezpieczenie.
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): # zabezpieczenie: agent nigdy nie powinien działać w nieskończonej pętli
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # brak kolejnych wywołań narzędzi: nadeszła końcowa odpowiedź
for tool_call in tool_calls: # odpowiedź może zawierać wiele wywołań
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)
Trzy szczegóły mają kluczowe znaczenie. Wiadomość agenta oraz każdy wynik działania narzędzia są ponownie wprowadzane do historii, sparowane za pomocą tool_call_id: pominięcie któregokolwiek z nich sprawi, że agent zgubi wątek i będzie w kółko przywoływał te same narzędzia. Pojedyncza odpowiedź może zawierać wiele wywołań narzędzi, ponieważ wywołania równoległe są domyślnie dozwolone (parallel_tool_calls=False ich zabrania): przetwarzaj je wszystkie. Na koniec ogranicz liczbę tur i spraw, aby człowiek zatwierdzał polecenia powłoki oraz zapisy plików: agent, który wykonuje wszystko, co zaproponuje, stanowi ryzyko, a nie oszczędność czasu.
Kluczowe wnioski
- Programowanie agentowe podlega cyklowi: zrozumienie, planowanie, wykonanie, weryfikacja
- Agent działa na repozytorium poprzez wywoływanie narzędzi (
tools,tool_choice) - Pętla wieloetapowa pozwala agentowi iterować aż do pełnego rozwiązania problemu
- Agent spójnie modyfikuje wiele plików w ramach jednego zadania
- Faza weryfikacji (testy, kompilacja) jest niezbędna dla niezawodności