Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Function Calling: Qabbad l-AI mas-Sistemi Tiegħek

Lezzjoni 10 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Function Calling: Qabbad l-AI mas-Sistemi Tiegħek
  2. Il-Fluss Sħiħ, Pass wara Pass
  3. Tħalli lill-Mudell Jagħżel fost Għodod Multipli
  4. Iċ-Ċiklu tal-Aġent (Agent Loop)
  5. Issakkar l-Argumenti bil-Modalità Stretta (Strict Mode)
  6. Punti Ewlenin

Function Calling: Qabbad l-AI mas-Sistemi Tiegħek

Il-function calling jippermetti lill-mudell jinvoka funzjonijiet li tiddefinixxi int. Żomm regola waħda quddiem għajnejk dejjem, għax kollox ieħor joħroġ minnha: il-mudell ma jesegwixxihomx. Huwa jgħidlek liema funzjoni għandek tsejjaħ u b’liema argumenti; il-kodiċi tiegħek iwettaq l-eżekuzzjoni u jirritorna r-riżultat. Id-database tiegħek, il-kredenzjali, u l-loġika tan-negozju tiegħek qatt ma joħorġu mill-infrastruttura tiegħek.

Il-Fluss Sħiħ, Pass wara Pass

L-iskambju jseħħ f’erba’ stadji:

  1. Int tiddikjara l-funzjonijiet disponibbli flimkien mal-parametri tagħhom
  2. Il-mudell janalizza t-talba u jiddeċiedi li jsejjaħ funzjoni
  3. Il-kodiċi tiegħek jesegwixxi l-funzjoni u jikseb ir-riżultat
  4. Int tibgħat ir-riżultat lura lill-mudell biex ikun jista’ jifformula t-tweġiba tiegħu

Id-dikjarazzjoni tiġbor attenzjoni speċjali: id-description tal-funzjoni u d-deskrizzjoni ta’ kull parametru huma l-unika dokumentazzjoni li għandu l-mudell biex jieħu d-deċiżjoni tiegħu. Deskrizzjonijiet vagi jwasslu għal sejħiet approssimattivi. Innota wkoll kif tingħalaq iċ-ċirkwit—ir-riżultat jerġa’ jintbagħat bil-call_id li rċevejt, li jaġixxi bħala konferma u jippermetti lill-API tqabbel it-tweġiba mat-talba.

from openai import OpenAI
import json

client = OpenAI()

# Step 1: Declare available functions
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"]
    }
}]

# Step 2: The model decides to call the function
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Step 3: Execute the function
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)

        # Your actual implementation
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Step 4: Send the result back to the model
        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}")

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

Tħalli lill-Mudell Jagħżel fost Għodod Multipli

Il-valur reali jidher meta tesponi katalogu sħiħ ta’ kapaċitajiet. F’assistent tal-kummerċ elettroniku, tiddikjara t-tfittxija tal-prodotti, il-verifika tal-istokk, u t-tqegħid tal-ordnijiet, imbagħad tħalli lill-mudell jagħmel l-arbitraġġ. Quddiem mistoqsija bħal “Il-laptop tal-logħob XPS huwa disponibbli?”, mhux se jwettaq tfittxija iżda se jistaqsi direttament dwar l-istokk: id-deskrizzjonijiet tal-funzjonijiet tiegħek, mhux regola miktuba b’mod iebsor, immexxew dik il-għażla.

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

# The model automatically chooses the right function
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}")

# Result: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}

Talba waħda tista’ wkoll ttriggera sejħiet multipli fl-istess ħin. It-tqabbil tat-temp f’żewġ bliet jipproduċi żewġ sejħiet indipendenti: il-kodiċi tiegħek għalhekk irid jgħaddi minn response.output u jittratta l-oġġetti function_call kollha, qatt biss l-ewwel wieħed. Din hija wkoll opportunità biex tesegwixxi dawn is-sejħiet b’mod parallel u taqta’ l-latency bin-nofs.

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

# The model makes two calls in parallel
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']})")

# Result:
# Number of calls: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

Iċ-Ċiklu tal-Aġent (Agent Loop)

Vjaġġ wieħed ‘l hemm u ‘l hawn rari jkun biżżejjed: ir-riżultat ta’ funzjoni waħda spiss iwassal lill-mudell biex isejjaħ oħra. Għalhekk, int tgħatti l-iskambju f’ċiklu li jibbaħar sakemm it-tweġiba tkun fiha sejħiet ta’ funzjonijiet u jieqaf hekk kif ma jkollhiex aktar—sinjal li l-mudell ifformula t-tweġiba finali tiegħu. Dan huwa l-qafas ta’ kull aġent, u se tarah taħt forom varji fil-qafas kollha tal-aġenti.

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

    if nom == "get_meteo":
        # Simulation — replace with your real 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
        )

        # Check for function calls
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # No function calls = final response
            return response.output_text

        # Execute each function and add results
        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
            })

# Usage
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

Kelma ta’ twissija dwar dan il-mudell: iċ-ċiklu while True m’għandux gardrails. Fil-produzzjoni, żid kontur massimu ta’ iterazzjonijiet; inkella, mudell li jitlob l-istess għodda għal żmien indefinit se jaħraq il-baġit tiegħek mingħajr qatt ma jikkonkludi.

Issakkar l-Argumenti bil-Modalità Stretta (Strict Mode)

Il-modalità stretta (strict mode) tapplika l-istess garanzija għall-parametri tal-funzjoni li l-Output Strutturat japplika għat-tweġibiet: l-argumenti jaderixxu strettament mal-iskema ddikjarata. Għal funzjoni li toħloq utent, dan jipprevjenik milli tirċievi età bħala string, jew kamp addizzjonali li l-kodiċi tiegħek ma kienx jistenna.

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

Punti Ewlenin

  • Il-function calling iqabbad il-mudell mas-sistemi tiegħek mingħajr ma jesponi d-data tiegħek
  • Il-mudell jiddeċiedi liema funzjoni għandu jsejjaħ; il-kodiċi tiegħek jesegwixxiha
  • Irritorna r-riżultat bl-użu ta’ function_call_output u l-call_id
  • Il-mudell jista’ jsejjaħ funzjonijiet multipli b’mod parallel
  • Uża ċiklu ta’ aġent (agent loop) għal konversazzjonijiet multi-turn li jinvolvu funzjonijiet
  • Ippermetti strict: True biex tiggarantixxi l-konformità tal-argumenti