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

Definování funkcí v Pythonu

Lekce 4 z 14 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Od teorie ke kódu
  2. Instalace Mistral SDK
  3. Vytvoření funkcí v Pythonu
  4. Zápis specifikací JSON
  5. Organizace funkcí ve slovníku
  6. Možnost tool_choice
  7. Klíčové poznatky

Od teorie ke kódu

Nyní už chápeš pětikrokový proces i strukturu JSON Schema. Je čas napsat skutečný kód v Pythonu. V této lekci vytvoříš funkce, navrhneš jejich specifikace a připravíš vše pro Mistral API – tedy všechno, co musí existovat před prvním síťovým voláním.

Instalace Mistral SDK

Začni instalací oficiálního balíčku:

pip install mistralai

Dále nakonfiguruj svůj API klíč. Nejlepší praxe diktuje, abys jej nikdy neukládal přímo do zdrojových souborů. Místo toho jej načti z proměnné prostředí, aby bylo možné kód bezpečně commitovat do systému pro správu verzí.

export MISTRAL_API_KEY="your-api-key"
import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

Vytvoření funkcí v Pythonu

Podívejme se na konkrétní příklad: systém pro sledování plateb založený na DataFrame z knihovny Pandas. Jde o klasický příklad z dokumentace Mistral, který dokonale ilustruje danou koncepci – zde DataFrame hraje roli, kterou by v produkčním prostředí zastávala databáze.

import pandas as pd
import json

# Data o platbách
data = {
    "transaction_id": ["T1001", "T1002", "T1003", "T1004", "T1005"],
    "customer_id": ["C001", "C002", "C003", "C002", "C001"],
    "payment_amount": [125.50, 89.99, 350.00, 45.00, 210.75],
    "payment_date": ["2026-03-15", "2026-03-16", "2026-03-17", "2026-03-17", "2026-03-18"],
    "payment_status": ["paid", "paid", "pending", "paid", "failed"]
}
df = pd.DataFrame(data)

Následuje kód, který tato data skutečně využívá. Jde o standardní funkce v Pythonu; nic v jejich implementaci nenaznačuje, že je bude řídit LLM.

def retrieve_payment_status(df: pd.DataFrame, transaction_id: str) -> str:
    """Načte stav platby podle jejího ID."""
    if transaction_id in df["transaction_id"].values:
        status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
        return json.dumps({"status": status})
    return json.dumps({"error": f"Transaction {transaction_id} not found"})


def retrieve_payment_date(df: pd.DataFrame, transaction_id: str) -> str:
    """Načte datum platby podle jejího ID."""
    if transaction_id in df["transaction_id"].values:
        date = df[df["transaction_id"] == transaction_id]["payment_date"].values[0]
        return json.dumps({"date": date})
    return json.dumps({"error": f"Transaction {transaction_id} not found"})

Dva implementační detaily si zaslouží tvou pozornost. Zaprvé, tyto funkce vždy vracejí řetězec JSON, nikdy neholý Python objekt. Toto je formát, který model očekává jako výsledek nástroje, takže json.dumps() je nezbytností. Zadruhé, explicitně ošetřují případ, kdy transakce není nalezena, místo aby vyvolaly výjimku. Tato chyba, naformátovaná jako JSON, se vrátí modelu stejně jako jakýkoli jiný výsledek, což mu umožní zdvořile informovat uživatele, že transakce T9999 neexistuje. Později v kurzu uvidíš, proč je tento reflex zásadní.

Zápis specifikací JSON

Každá funkce potřebuje specifikaci, aby ji model pochopil. Zde aplikuješ strukturu z předchozí lekce na dvě výše uvedené funkce – všimni si přísné shody mezi poli name a skutečnými názvy funkcí v Pythonu.

tools = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_status",
            "description": "Retrieves the status of a payment (paid, pending, failed) "
                           "based on the transaction ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_date",
            "description": "Retrieves the date a payment was made "
                           "based on the transaction ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Organizace funkcí ve slovníku

Model vrací název funkce jako řetězec. Potřebuješ způsob, jak tento řetězec namapovat na odpovídající volatelný objekt, aniž bys musel používat eval nebo kaskádu příkazů if. Dispatch slovník tento problém vyřeší na tři řádky.

from functools import partial

# Svázání DataFrame s každou funkcí
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

functools.partial řeší specifický, reálný problém. Tvoje funkce očekávají dva argumenty – DataFrame a ID – ale model poskytuje pouze jeden. Model nic neví o df, ani by neměl. partial předvyplní tento první parametr jednou provždy. Stejný mechanismus platí pro připojení k databázi, HTTP klienty nebo autentizační tokeny. Dynamické volání se pak stane triviální záležitostí.

function_name = "retrieve_payment_status"
function_params = {"transaction_id": "T1001"}

result = available_functions[function_name](**function_params)
# → '{"status": "paid"}'

Možnost tool_choice

Při odesílání těchto nástrojů API parametr tool_choice rozhoduje, kolik volnosti modelu dáš. Možné jsou tři hodnoty.

# Model se sám rozhodne, zda použít nástroj, nebo odpovědět přímo (výchozí)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Vnutit modelu použití nástroje
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"
)

# Zakázat modelu použití nástrojů
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"
)

Režim "auto" je v produkci nejběžnější z dobrého důvodu: asistent pro sledování plateb by měl umět říct „ahoj“, aniž by spustil dotaz do databáze. Model odpovídá přímo na obecné otázky a funkce používá pouze tehdy, když je to relevantní. Celá lekce později v kurzu pokrývá specifické případy použití pro any a none.

Klíčové poznatky

  • Funkce musí vracet řetězce JSON – nikdy neholé Python objekty
  • Použij dispatch slovník pro mapování názvů funkcí na jejich implementace
  • functools.partial je ideální pro předvyplnění parametrů, jako jsou připojení k DB nebo DataFrame
  • tool_choice řídí, zda model může nebo musí používat funkce (auto, any, none)
  • Ve svých funkcích vždy ošetřuj případy chyb (neplatné parametry, chybějící data)