Kurs Python · Moduł 10: AI i modele językowe

Function Calling - AI, które sięga po narzędzia

4 min czytania ·
W tej lekcji5

Model językowy sam z siebie nie zna dzisiejszej pogody w Serengeti ani aktualnej populacji lwów - potrafi tylko układać słowa. Function calling daje mu narzędzia: Twoje funkcje Pythona, po które może sięgnąć, gdy pytanie wykracza poza to, co wie.

Najważniejsze: model nie wykonuje funkcji

Zanim napiszesz linijkę kodu, zrozum jedno - to źródło wszystkich nieporozumień z function calling. Model nigdy sam nie uruchamia Twojej funkcji. On tylko mówi: "chcę wywołać get_weather z argumentem Serengeti". Wykonanie należy do Ciebie. To rozmowa w turach:

  1. Dajesz modelowi pytanie i listę dostępnych narzędzi.
  2. Model odpowiada nie tekstem, lecz prośbą: "wywołaj tę funkcję z tymi argumentami".
  3. Ty uruchamiasz funkcję w Pythonie i dostajesz wynik.
  4. Oddajesz wynik modelowi.
  5. Model układa z niego ludzką odpowiedź.

Przejdziemy przez te tury po kolei. Zaczynamy od tego, jak opisać modelowi narzędzie - bo model nie widzi Twojego kodu, tylko jego opis.

from openai import OpenAI
import json

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Pobiera pogodę dla lokalizacji Safari",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Nazwa lokalizacji, np. 'Serengeti'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

Zwróć uwagę: to jest sam opis narzędzia, nie jego działanie. Pola description są tu najważniejsze - to po nich model decyduje, kiedy sięgnąć po funkcję i co wpisać w argument. Im lepszy opis, tym trafniej model wybiera narzędzie. Sekcja required mówi, które argumenty są obowiązkowe.

Tura druga: model prosi o wywołanie

Teraz wysyłamy pytanie razem z listą narzędzi. Uważnie przeczytaj, co model zwraca - to nie odpowiedź dla użytkownika.

response = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Jaka jest pogoda w Serengeti?"}],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message
if message.tool_calls:
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        print(f"Model chce wywołać: {function_name}({arguments})")

Zamiast gotowej odpowiedzi model zwrócił tool_calls - listę próśb o wywołanie. Argumenty przychodzą jako tekst JSON, dlatego json.loads zamienia je na słownik Pythona. Na tym etapie nic się jeszcze nie wydarzyło - model tylko powiedział, czego chce. Wykonanie jest naszym kolejnym krokiem.

Tura trzecia: to Ty wykonujesz funkcję

Model zna nazwę funkcji tylko jako napis. Musimy więc mieć jej prawdziwą implementację i sposób, by z nazwy trafić do właściwego kodu.

def get_weather(location: str) -> dict:
    # W prawdziwej aplikacji - wywołanie API pogodowego
    return {"location": location, "temperature": 28, "conditions": "Słonecznie"}

available_functions = {
    "get_weather": get_weather
}

Słownik available_functions to most między światem modelu a Twoim kodem: model podaje napis "get_weather", a Ty po tym napisie wyciągasz prawdziwą funkcję. To Ty decydujesz, co naprawdę się wykona - model nie ma dostępu do niczego, czego mu tu nie udostępnisz. Zauważ, że to naturalne miejsce na kontrolę bezpieczeństwa.

Wszystkie tury razem

Zobacz teraz pełną rozmowę: pytanie, prośba modelu, wykonanie, oddanie wyniku i finalna odpowiedź. Prześledź, jak lista messages rośnie o kolejne tury.

def chat_with_tools(user_message: str):
    messages = [{"role": "user", "content": user_message}]

    response = client.chat.completions.create(
        model="gpt-5", messages=messages, tools=tools
    )
    message = response.choices[0].message

    if message.tool_calls:
        messages.append(message)  # zapisz prośbę modelu

        for tool_call in message.tool_calls:
            name = tool_call.function.name
            args = json.loads(tool_call.function.arguments)
            result = available_functions[name](**args)  # Ty wykonujesz

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result)  # oddaj wynik modelowi
            })

        final = client.chat.completions.create(model="gpt-5", messages=messages)
        return final.choices[0].message.content

    return message.content

Kluczowe są dwa wywołania create: pierwsze, w którym model prosi o narzędzie, i drugie - po dopisaniu wyniku - w którym model układa odpowiedź dla człowieka. Rola "tool" i tool_call_id to sposób, w jaki mówisz modelowi "oto wynik dokładnie tej funkcji, o którą prosiłeś". Bez tej drugiej tury użytkownik dostałby surowy JSON zamiast zdania.

LangChain - ta sama idea, mniej kodu

Ręczne prowadzenie tur bywa żmudne. LangChain pakuje całą tę pętlę w agenta - Ty tylko oznaczasz funkcje jako narzędzia, a on sam prowadzi rozmowę.

from langchain.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

@tool
def calculate_distance(from_loc: str, to_loc: str) -> str:
    """Oblicza odległość między lokalizacjami Safari."""
    return f"Odległość z {from_loc} do {to_loc}: 150 km"

llm = ChatOpenAI(model="gpt-5")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Jesteś pomocnym asystentem Safari."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(llm, [calculate_distance], prompt)
executor = AgentExecutor(agent=agent, tools=[calculate_distance], verbose=True)
executor.invoke({"input": "Jak daleko jest z Nairobi do Serengeti?"})

Dekorator @tool robi to, co wcześniej pisaliśmy ręcznie: z docstringa buduje opis dla modelu, a z sygnatury - listę argumentów. AgentExecutor prowadzi za Ciebie wszystkie tury z poprzedniego przykładu, w kółko, aż model uzna, że ma komplet informacji.

Pamiętaj z tej lekcji jedno zdanie: function calling to nie "AI uruchamia kod", tylko model prosi, a Ty wykonujesz i oddajesz wynik. Cała reszta - OpenAI czy LangChain - to tylko wygodniejszy zapis tej samej rozmowy w turach.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest Function Calling w kontekście LLM?

  2. 2. Jak definiuje się tools w OpenAI API?

Zadania praktyczne w grze

  • Edytor kodu

    Zdefiniuj tool i obsłuż wywołanie funkcji przez model.

  • Układanie w pionie

    Uporządkuj kroki:

  • Układanie w poziomie

    Ułóż import dekoratora tool z LangChain:

  • Klikanie w kolejności

    Kliknij w przyciski, aby dodać odpowiedź narzędzia:

  1. PytanieFunction Calling
  2. PytanieTools w OpenAI
  3. Zadanie z kodemFunction Calling
  4. Ułóż w kolejnościFlow Function Calling
  5. Ułóż w kolejnościLangChain @tool
  6. Kliknij w kolejnościTool response

Przydatne artykuły