Przejdź do głównej treści
Polski— Wybierz język
Menu

Programowanie agentowe z wywoływaniem narzędzi

Lekcja 6 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Czym jest programowanie agentowe?
  2. Cykl agentowy
  3. Przykład praktyczny: naprawa błędu
  4. Wykorzystanie narzędzi w praktyce
  5. Wieloetapowa pętla agentowa
  6. Kluczowe wnioski

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