Twój pierwszy agent AI używający narzędzi z LangChain

Krótkie ćwiczenie z Pythonem i LangChain polega na stworzeniu agenta w stylu kalkulatora, który w razie potrzeby może wywołać funkcje dodawania, odejmowania, mnożenia, dzielenia lub obliczania pierwiastka kwadratowego.

Arytmetyka jest tu tylko dodatkowym elementem. Istotną lekcją jest obserwowanie modelu językowego, który otrzymuje dostępne funkcje pomocnicze i decyduje którą z nich wywołać oraz w którym momencie.

Przykładowe zadania, które może rozwiązać gotowy agent:

Mnożymy 25 przez 4. Następnie obliczamy pierwiastek kwadratowy z 144, a uzyskany wynik mnożymy przez 5.

Zamiast zaprogramować dokładną sekwencję obliczeń, rejestruje się kilka funkcji pomocniczych. Model wybiera spośród nich na podstawie sformułowania użytkownika.

1. Inicjalizacja modelu

Najpierw konstruuje się model do rozmów:

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4o-mini")

Jeszcze nie istnieje nic w stylu agenta — tylko model tekstu, który potrafi czytać i pisać.

2. Rejestracja funkcji pomocniczych

Agenci stają się przydatni, gdy wykraczają poza prostą generację tekstu i mogą wywoływać funkcje aplikacji.

Zdefiniuj pięć minimalnych pomocników:

from langchain.tools import tool
import math

@tool
def add(a: float, b: float) -> float:
    """Add two numbers."""
    return a + b

@tool
def subtract(a: float, b: float) -> float:
    """Subtract two numbers."""
    return a - b


@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers."""
    return a * b


@tool
def divide(a: float, b: float) -> float:
    """Divide two numbers."""
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b


@tool
def square_root(a: float) -> float:
    """Calculate the square root of a number."""
    if a < 0:
        raise ValueError("Cannot calculate square root of a negative number.")
    return math.sqrt(a)

Dekorowanie funkcji za pomocą @tool umożliwia ich dostęp w formie zrozumiałej dla silnika działania agenta.

Dwa elementy kierują pracą modelu:

1. Parametry z adnotacjami określają typy oczekiwanych argumentów.

a: float
b: float

1. Opisy dokumentacyjne dostarczają prostych, zrozumiałych opisów, które model czyta podczas oceny istotności informacji.

W przypadku narzędzi dla agentów opis narracyjny funkcji stanowi część interfejsu sterowania, a nie element dekoracji.

"""Multiply two numbers."""

3. Połącz agenta

Priłącz pomocniki do modelu:

from langchain.agents import create_agent

agent = create_agent(
    model=model,
    tools=[
        add,
        subtract,
        multiply,
        divide,
        square_root
    ],
)

Od tego momentu model do rozmów może funkcjonować jako agent, a nie tylko jako narzędzie do udzielania jednorazowych odpowiedzi.

Typowe kroki obejmują:

1. Analizę intencji użytkownika

Ocena, czy potrzebny jest pomocnik

Wybór pomocnika

Dostarczenie argumentów

Użycie wartości zwróconej przez pomocnika

Decyzja o konieczności kolejnego kroku

Wysłanie ostatecznej odpowiedzi

Na wyższym poziomie:

User
 ↓
Agent
 ↓
Should I use a tool?
 ↓
Choose tool
 ↓
Execute tool
 ↓
Get result
 ↓
Final response

Zadania wieloetapowe mogą powtarzać ten pętlę.

4. Wykonanie rundy

Dostateczny jest prosty otoczak do jej uruchomienia:

def run_agent(question: str):
    """Run the agent and print the execution trace."""

    print(f"User: {question}")

    result = agent.invoke({
        "message": [("user", question)],
    })

    print("Agent:", result)

Wezwanie za pomocą prostego pytania:

run_agent("What is 25 multiplied by 4?")

Zauważ, że nie ma instrukcji mówiącej „wezwij multiply”.

Dostarczono jedynie katalog pomocników.

Biorąc pod uwagę sformułowanie i opis każdego pomocnika, model dochodzi do wniosku, że mnożenie jest odpowiednie.

5. Łączenie więcej niż jednego pomocnika

Spróbuj złożonego promptu:

run_agent(
    "Calculate the square root of 144 and multiply the result by 5."
)

Wymagane są dwie operacje.

Koncepcyjny przebieg wygląda następująco:

User:

Calculate √144 × 5
        ↓
Agent chooses square_root
        ↓
square_root(144)
        ↓
12
        ↓
Agent chooses multiply
        ↓
multiply(12, 5)
        ↓
60
        ↓
Final answer

To cykliczne działanie – wybór, wywołanie, obserwacja, ponowny wybór – stanowi istotę agentów używających narzędzi.

Kod aplikacji nie musi z góry zawierać pełnego porządku operacji.

Model może wywnioskować następny krok na podstawie dostępnych narzędzi i stanu rozmowy.

6. Różnica w porównaniu z zwykłym LLM

Bez narzędzi model mógłby wymyślić tekst „Odpowiedź to 60”.

Gdy są zarejestrowane narzędzia, może przekazać zadania numeryczne rzeczywistym funkcjom.

Zmiana kontroli

Tylko ścieżka tekstowa: Użytkownik → model → ciąg znaków z odpowiedzią

w przeciwieństwie do:

Tool-using agent

User
  ↓
LLM
  ↓
Choose tool
  ↓
Execute code
  ↓
Observe result
  ↓
LLM
  ↓
Answer

Model nie musi już sam wykonywać wszystkich obliczeń.

Zaproponuje którą akcję należy wykonać dalej; aplikacja decyduje, jakie akcje istnieją i w jaki sposób są realizowane.

7. Granica wymagająca ochrony

Kalkulator to narzędzie edukacyjne.

Trwałą koncepcją jest rozdzielenie osądu modelu od uprawnień do wykonywania działań.

Rozumienie języka naturalnego i wybór działań dobrze pasują do LLM.

Wykonywanie tych działań powinno odbywać się w Pythonie, pod twoją kontrolą.

Model może dojść do wniosku, że potrzebuje takiego podziału.

Twój proces odpowiada za implementację tego rozdzielenia oraz jego skutki uboczne.

Zastąp prostsze narzędzia matematyczne operacjami specyficznymi dla danej dziedziny, takimi jak:

get_customer()
search_transactions()
create_report()
send_email()
query_database()
get_weather()
create_ticket()

i ten sam wzorzec orkiestracji zaczyna przypominać projekty agentów produkcyjnych.

Podsumowanie ćwiczenia

Kilka modułów stworzyło agenta, który potrafi:

• Interpretować pytania w formie swobodnej
• Wybierać spośród zarejestrowanych narzędzi
• Prawidłowo łączyć argumenty
• Łączyć narzędzia w ramach jednej sesji
• Przekazywać wyniki narzędzi do dalszych rozumowań

Odpowiedz użytkownikowi po zakończeniu łańcucha

Krótko mówiąc: LLM, które wybiera i wykonuje działania, a nie takie, które jedynie wytwarza tekst prozatorski.