Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Function Calling: Propojení AI s vašimi systémy

Lekce 10 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Function Calling: Propojení AI s vašimi systémy
  2. Celý proces krok za krokem
  3. Nechání modelu vybrat si z více nástrojů
  4. Smyčka agenta
  5. Uzamčení argumentů pomocí Strict Mode
  6. Klíčové poznatky

Function Calling: Propojení AI s vašimi systémy

Function Calling umožňuje modelu vyvolávat vámi definované funkce. Zapamatuj si jedno zásadní pravidlo, protože od něj se odvíjí vše ostatní: model tyto funkce neprovádí. Pouze ti sdělí, kterou funkci zavolat a s jakými argumenty; provedení zajistí tvůj kód a vrátí výsledek. Tvá databáze, pověření ani obchodní logika nikdy neopustí tvou infrastrukturu.

Celý proces krok za krokem

Komunikace probíhá ve čtyřech fázích:

  1. Deklaruješ dostupné funkce spolu s jejich parametry
  2. Model analyzuje požadavek a rozhodne se zavolat funkci
  3. Tvůj kód funkci provede a získá výsledek
  4. Výsledek odešleš zpět modelu, aby mohl formulovat svou odpověď

Deklarace si zaslouží zvláštní pozornost: description funkce a popis každého parametru jsou jedinou dokumentací, kterou má model k dispozici pro své rozhodnutí. Nejasné popisy vedou k nepřesným voláním. Všimni si také, jak uzavřít smyčku – výsledek se vrací s call_id, které jsi obdržel. To funguje jako potvrzení a umožňuje API spárovat odpověď s požadavkem.

from openai import OpenAI
import json

client = OpenAI()

# Krok 1: Deklarace dostupných funkcí
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Get the current weather for a city",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "The name of the city"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["ville"]
    }
}]

# Krok 2: Model se rozhodne funkci zavolat
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Krok 3: Provedení funkce
for item in response.output:
    if item.type == "function_call":
        print(f"Function: {item.name}")
        print(f"Arguments: {item.arguments}")
        args = json.loads(item.arguments)

        # Tvá skutečná implementace
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Krok 4: Odeslání výsledku zpět modelu
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "What's the weather like in Marseille?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Response: {final.output_text}")

# Výsledek:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.

Nechání modelu vybrat si z více nástrojů

Skutečná hodnota se projeví, když zpřístupníš celý katalog schopností. U asistenta pro e-commerce bys deklaroval vyhledávání produktů, kontrolu skladových zásob a zadávání objednávek a nechal model, aby rozhodl. Při dotazu „Je herní notebook XPS skladem?“ neprovede vyhledávání, ale přímo se zeptá na stav zásob: toto rozhodnutí řídí tvé popisy funkcí, nikoli natvrdo zakódované pravidlo.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Search for a product in the catalog",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Search terms"},
                "categorie": {"type": "string", "description": "Category (optional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Check product availability",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "Product ID"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Place an order for a product",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Number of units"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# Model automaticky vybere správnou funkci
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Is the XPS gaming laptop available?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Function chosen: {item.name}")
        print(f"Arguments: {item.arguments}")

# Výsledek: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}

Jediný požadavek může také spustit více volání najednou. Porovnání počasí ve dvou městech vygeneruje dvě nezávislá volání: tvůj kód proto musí iterovat přes response.output a zpracovat všechny položky function_call, nejen tu první. Je to také příležitost provést tato volání paralelně a zkrátit latenci na polovinu.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare the weather between Paris and Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Get the weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# Model provede dvě volání paralelně
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Number of calls: {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Výsledek:
# Number of calls: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

Smyčka agenta

Jedna výměna informací málokdy stačí: výsledek jedné funkce často vede model k volání další. Proto celou komunikaci zabalíš do smyčky, která běží, dokud odpověď obsahuje volání funkcí, a zastaví se, jakmile žádná neobsahuje – což je signál, že model formuloval svou konečnou odpověď. Toto je kostra každého agenta a setkáš se s ní v různých podobách ve všech frameworkech pro agenty.

def executer_fonction(nom: str, arguments: str) -> str:
    """Execute a function and return the result."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulace — nahraď svým skutečným API
        return json.dumps({"temp": 18, "condition": "cloudy"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Unknown function"})

def agent_loop(question: str, tools: list) -> str:
    """Agent loop: call functions until the final response."""
    input_messages = [{"role": "user", "content": question}]

    while True:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=input_messages,
            tools=tools
        )

        # Kontrola volání funkcí
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Žádná volání funkcí = konečná odpověď
            return response.output_text

        # Provedení každé funkce a přidání výsledků
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Použití
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

U tohoto vzoru buď opatrný: smyčka while True nemá žádné ochranné mechanismy. V produkčním prostředí přidej maximální počet iterací; jinak model, který bude donekonečna požadovat stejný nástroj, spálí tvůj rozpočet, aniž by kdy dospěl k závěru.

Uzamčení argumentů pomocí Strict Mode

Strict Mode aplikuje na parametry funkcí stejnou záruku, jakou Structured Output poskytuje u odpovědí: argumenty striktně dodržují deklarované schéma. U funkce, která vytváří uživatele, to zabrání tomu, abys obdržel věk jako řetězec nebo extra pole, které tvůj kód neočekával.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Create a new user",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Klíčové poznatky

  • Function Calling propojuje model s tvými systémy bez vystavení tvých dat
  • Model rozhoduje, kterou funkci zavolat; tvůj kód ji provádí
  • Výsledek vrať pomocí function_call_output a call_id
  • Model může volat více funkcí paralelně
  • Pro vícekolové konverzace zahrnující funkce použij smyčku agenta
  • Povol strict: True pro zajištění souladu argumentů