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

Možnosti tool_choice

Lekce 9 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Kdo rozhoduje?
  2. auto — Nech rozhodnout model
  3. any — Vynucení strukturovaného výstupu
  4. none — Zakázání nástrojů bez jejich odstranění
  5. Úprava nastavení v průběhu konverzace
  6. Klíčové poznatky

Kdo rozhoduje?

Předání parametru tools API neznamená, že model musí tyto nástroje použít, ani že mu to je vůbec povoleno. Mezi těmito dvěma extrémy funguje parametr tool_choice jako rozhodčí. Podle hodnoty, kterou mu přiřadíš, můžeš modelu nechat volnou ruku, aby sám posoudil situaci, donutit ho vygenerovat strukturovaný volání, nebo mu zcela zakázat přístup k nástrojům, které jsi právě definoval. Jde o jemné nastavení, které však radikálně mění chování stejného kódu při zodpovídání stejného dotazu.

HodnotaChováníPřípad použití
autoModel se svobodně rozhodne, zda použije nástroj, nebo odpoví textem. Toto je výchozí režim.Konverzační asistenti, univerzální chatboti
anyModel je nucen zavolat alespoň jeden nástroj. Nemůže odpovědět pouze textem.Automatizované pipeline, extrakce strukturovaných dat
noneModel nemůže použít nástroje, ani když jsou definovány. Odpovídá pouze textem.Shrnutí výsledků bez nových volání, přeformulování odpovědi
requiredSynonymum pro any. Model musí použít alespoň jeden nástroj.Ekvivalent any, určené pro kompatibilitu

auto — Nech rozhodnout model

Toto je výchozí hodnota, kterou používáš, aniž bys o tom věděl, kdykoli tento parametr vynecháš.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto"  # Volitelné, toto je výchozí hodnota
)

Při nastavení auto model nejprve vyhodnotí požadavek a teprve poté jedná. Pokud dotaz vyžaduje externí data, která model nemá, zavolá funkci; pokud je dotaz obecný nebo konverzační, odpoví přímo textem. Právě tento přepínač dělá asistenta přirozeným: uživatel nemusí vědět, že za scénou stojí nějaké nástroje.

# Model zavolá funkci
messages = [{"role": "user", "content": "Stav platby T1001?"}]
# → tool_call: retrieve_payment_status(transaction_id="T1001")

# Model odpoví přímo
messages = [{"role": "user", "content": "Ahoj, jak se máš?"}]
# → content: "Ahoj! Jsem platební asistent. Jak ti mohu pomoci?"

Druhý příklad si zaslouží pozornost: vynucení volání funkce při prostém pozdravu by vedlo k vygenerování retrieve_payment_status s vymyšleným ID. Přesně tomu auto zabraňuje, a proto zůstává tento režim v produkčním prostředí nejpoužívanější.

any — Vynucení strukturovaného výstupu

Naopak existují kontexty, kde pro tebe volný text nemá žádnou hodnotu. Ingestní pipeline zpracovávající deset tisíc dokumentů očekává použitelné JSON, nikoliv zdvořilou větu. S hodnotou any musí model zavolat alespoň jednu funkci, i když se zdá, že to dotaz nevyžaduje.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"
)

Zajímavé je, že nejčastější případ použití mění původní účel volání funkcí: nedeklaruješ funkci proto, aby byla spuštěna, ale aby byla zaručena schéma výstupu. Zde se extract_entities na straně serveru nikdy nevyvolá; záleží nám pouze na JSON kontraktu.

# Strukturovaná extrakce: donutíme model extrahovat data
tools = [{
    "type": "function",
    "function": {
        "name": "extract_entities",
        "description": "Extrahuje pojmenované entity z textu",
        "parameters": {
            "type": "object",
            "properties": {
                "persons": {"type": "array", "items": {"type": "string"}},
                "organizations": {"type": "array", "items": {"type": "string"}},
                "dates": {"type": "array", "items": {"type": "string"}}
            },
            "required": ["persons", "organizations", "dates"]
        }
    }
}]

messages = [{"role": "user", "content": "Sophia Yang ze společnosti Mistral představila "
            "volání funkcí dne 15. března 2026."}]

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"  # Vynucení extrakce
)

# → extract_entities(persons=["Sophia Yang"],
#                     organizations=["Mistral"],
#                     dates=["15. března 2026"])

Mimochodem, hodnota required: je to synonymum pro any, zahrnuté pro kompatibilitu s kódem psaným pro jiná API. Obě hodnoty produkují stejné chování; vyber si tu, která učiní tvůj kód čitelnějším, a drž se jí.

none — Zakázání nástrojů bez jejich odstranění

Třetí hodnota řeší méně zřejmou potřebu. Data jsi již získal prostřednictvím několika tool_calls a nyní chceš, aby je model syntetizoval. Pokud budeš v konverzaci pokračovat v režimu auto, nic nebrání modelu znovu zavolat funkci „jen pro jistotu“, což zvyšuje latenci a může spustit nekonečnou smyčku. Hodnota none zakazuje jakákoliv nová volání, zatímco definice nástrojů ponechává v kontextu, což pomáhá modelu přesně hovořit o datech, která již má k dispozici.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"
)

Tři případy použití se objevují neustále: žádost o shrnutí po sérii volání funkcí, přeformulování odpovědi bez spuštění nových volání a testování ve vývojovém prostředí, jak se model chová, když je připraven o své nástroje, což rychle odhalí otázky, na které si myslí, že dokáže odpovědět z paměti.

# Po získání dat prostřednictvím tool_calls...
# Žádost o shrnutí bez nových volání
messages.append({
    "role": "user",
    "content": "Shrň informace ze všech plateb, které jsi našel."
})

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"  # Model shrne data, která již má
)

Úprava nastavení v průběhu konverzace

Parametr tool_choice nemusíš nastavit pouze jednou při startu. V produkčním prostředí je běžné počítat jeho hodnotu v každém kroku na základě kontextu: první zpráva konverzace, záměr detekovaný v požadavku nebo počet již provedených volání. Následující funkce ilustruje tuto logiku v nejjednodušší podobě – model má ve výchozím nastavení volnou ruku, kromě případů, kdy uživatel explicitně požádá o shrnutí.

def get_tool_choice(user_input: str, turn_count: int) -> str:
    """Určuje tool_choice na základě kontextu."""

    # První krok: necháme rozhodnout model
    if turn_count == 0:
        return "auto"

    # Pokud uživatel explicitně požádá o shrnutí
    if any(word in user_input.lower() for word in ["summarize", "recap", "synthesis"]):
        return "none"

    # Výchozí nastavení
    return "auto"

V praxi měj auto jako své základní nastavení: je nejpřirozenější a nejflexibilnější. Hodnotu any si rezervuj pro pipeline extrakce strukturovaných dat a none pro momenty, kdy musíš zabránit nekonečným smyčkám tool_call. Jedno omezení je absolutní: nikdy neměň tool_choice uprostřed zpracování tool_call. Nejprve dokonči cyklus vrácením všech očekávaných zpráv tool a až poté uprav tento parametr v dalším kroku – jinak se historie stane nekonzistentní a API žádost odmítne.

Klíčové poznatky

  • tool_choice řídí, kdy model použije funkce
  • auto = model se rozhoduje svobodně (výchozí, doporučeno pro chatboty)
  • any = model je nucen zavolat nástroj (pipeline, strukturovaná extrakce)
  • none = nástroje jsou zakázány (shrnutí, přeformulování)
  • Přizpůsobuj tool_choice dynamicky na základě kontextu konverzace