Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Definēt funkcijas Python valodā

Nodarbība 4 no 14 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. No teorijas uz kodu
  2. Instalē Mistral SDK
  3. Izveido Python funkcijas
  4. Raksti JSON specifikācijas
  5. Organizē funkcijas vārdnīcā
  6. Opcija tool_choice
  7. Galvenās atziņas

No teorijas uz kodu

Tagad tu saproti piecu soļu procesu un JSON shēmas struktūru. Ir laiks rakstīt īstu Python kodu. Šajā nodarbībā tu izveidosi funkcijas, sastādīsi to specifikācijas un sagatavosi visu Mistral API izmantošanai — viss, kam jābūt gatavam pirms pirmā tīkla pieprasījuma veikšanas.

Instalē Mistral SDK

Sāc ar oficiālās pakotnes instalēšanu:

pip install mistralai

Tālāk konfigurē savu API atslēgu. Labākā prakse nosaka, ka tu nekad to tieši neiekodē avota failos. Tā vietā nolasī to no vides mainīgā, lai droši varētu augšupielādēt savu kodu versiju kontrolei.

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

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

Izveido Python funkcijas

Apskatīsim konkrētu piemēru: maksājumu izsekošanas sistēmu, kas balstīta uz Pandas DataFrame. Tas ir klasisks piemērs no Mistral dokumentācijas, kas lieliski ilustrē koncepciju — šeit DataFrame aizstāj datubāzi, ko izmantotu ražošanas vidē.

import pandas as pd
import json

# Maksājumu dati
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)

Tālāk seko kods, kas faktiski piekļūst šiem datiem. Tās ir standarta Python funkcijas; to ieviešanā nekas neliecina, ka tās vadīs LLM.

def retrieve_payment_status(df: pd.DataFrame, transaction_id: str) -> str:
    """Atgriež maksājuma statusu pēc tā 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:
    """Atgriež maksājuma datumu pēc tā 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"})

Divas ieviešanas detaļas ir pelnījušas tavu uzmanību. Pirmkārt, šīs funkcijas vienmēr atgriež JSON virkni, nekad neapstrādātu Python objektu. Tas ir formāts, ko modelis sagaida kā rīka rezultātu, tāpēc json.dumps() ir obligāts. Otrkārt, tās eksplicīti apstrādā gadījumu, kad darījums nav atrasts, tā vietā, lai izraisītu izņēmumu. Šī kļūda, formatēta kā JSON, atgriežas modelim tāpat kā jebkurš cits rezultāts, ļaujot tam pieklājīgi informēt lietotāju, ka darījums T9999 nepastāv. Vēlāk kursā tu redzēsi, kāpēc šī pieeja ir būtiska.

Raksti JSON specifikācijas

Katrai funkcijai ir nepieciešama specifikācija, lai modelis to saprastu. Šeit tu piemēro iepriekšējā nodarbībā apgūto struktūru abām augstāk minētajām funkcijām — ņem vērā stingro atbilstību starp laukiem name un faktiskajiem Python funkciju nosaukumiem.

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"]
            }
        }
    }
]

Organizē funkcijas vārdnīcā

Modelis atgriež funkcijas nosaukumu kā virkni. Tev ir nepieciešams veids, kā kartēt šo virkni uz atbilstošo izsaucamo objektu, neizmantojot eval vai bezgalīgu if priekšrakstu kaskādi. Izpildes vārdnīca atrisina šo problēmu trīs rindās.

from functools import partial

# Piesaisti DataFrame katrai funkcijai
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

functools.partial risina specifisku, reālu grūtību. Tavas funkcijas sagaida divus argumentus — DataFrame un ID —, bet modelis nodrošina tikai vienu. Modelis nezina neko par df, un tam tā arī nevajadzētu zināt. partial vienreiz un uz visiem laikiem aizpilda šo pirmo parametru. Šis pats mehānisms attiecas uz datubāzu savienojumiem, HTTP klientiem vai autentifikācijas tokeniem. Dinamiska izsaukšana tad kļūst triviāla.

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

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

Opcija tool_choice

Sūtot šos rīkus API, parametrs tool_choice nosaka, cik lielu brīvību tu dod modelim. Ir iespējamas trīs vērtības.

# Modelis pats izlemj, vai izmantot rīku vai atbildēt tieši (noklusējums)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Piespiež modeli izmantot rīku
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"
)

# Aizliedz modelim izmantot rīkus
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"
)

Režīms "auto" ražošanas vidē ir visizplatītākais pamatota iemesla dēļ: maksājumu izsekošanas asistentam jāspēj teikt „sveiki”, neizraisot datubāzes vaicājumu. Modelis atbild tieši uz vispārīgiem jautājumiem un izmanto funkcijas tikai tad, kad tas ir relevanti. Vēlāk kursā atsevišķa nodarbība aptvers specifiskus lietojumgadījumus vērtībām any un none.

Galvenās atziņas

  • Funkcijām jāatgriež JSON virknes — nekad neapstrādāti Python objekti
  • Izmanto izpildes vārdnīcu, lai kartētu funkciju nosaukumus uz to ieviešanu
  • functools.partial ir ideāls parametru, piemēram, DB savienojumu vai DataFrame, iepriekšējai aizpildīšanai
  • tool_choice kontrolē, vai modelis var vai tam ir jāizmanto funkcijas (auto, any, none)
  • Vienmēr apstrādā kļūdu gadījumus savās funkcijās (nederīgi parametri, trūkstoši dati)