Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Function Calling : yhdistä tekoäly järjestelmiisi

Oppitunti 10 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Function Calling : yhdistä tekoäly järjestelmiisi
  2. Koko prosessi vaihe vaiheelta
  3. Anna mallin valita useista työkaluista
  4. Agenttisilmukka
  5. Lukitse argumentit tiukalla tilalla
  6. Keskeiset asiat

Function Calling : yhdistä tekoäly järjestelmiisi

Function Callingin avulla malli voi kutsua määrittelemiäsi funktioita. Pidä yksi sääntö mielessäsi kaiken perustana, sillä kaikki muu seuraa siitä: malli ei suorita funktioita. Se kertoo sinulle, mikä funktio tulee kutsua ja millä argumenteilla; sinun koodisi hoitaa suorituksen ja palauttaa tuloksen. Tietokantasi, tunnistetietosi ja liiketoimintalogiikkasi eivät koskaan poistu infrastruktuuristasi.

Koko prosessi vaihe vaiheelta

Viestintä etenee neljässä vaiheessa:

  1. Määrittelet käytettävissä olevat funktiot ja niiden parametrit
  2. Malli analysoi pyynnön ja päättää kutsua funktion
  3. Koodisi suorittaa funktion ja hankkii tuloksen
  4. Lähetät tuloksen takaisin mallille, jotta se voi muotoilla vastauksensa

Määrittely vaatii erityistä huolellisuutta: funktion description ja kunkin parametrin kuvaus ovat ainoat dokumentit, joiden perusteella malli tekee päätöksensä. Epämääräiset kuvaukset johtavat epätarkkoihin kutsuihin. Huomaa myös, miten silmukka suljetaan: tulos lähetetään takaisin käyttämällä vastaanottamaasi call_id:tä, joka toimii kuittauksena ja antaa rajapinnan yhdistää vastauksen pyyntöön.

from openai import OpenAI
import json

client = OpenAI()

# Vaihe 1: Määrittele käytettävissä olevat funktiot
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"]
    }
}]

# Vaihe 2: Malli päättää kutsua funktion
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Vaihe 3: Suorita funktio
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)

        # Todellinen toteutuksesi
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Vaihe 4: Lähetä tulos takaisin mallille
        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}")

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

Anna mallin valita useista työkaluista

Todellinen arvo paljastuu, kun tarjoat käyttöön koko katalogin ominaisuuksia. Verkkokauppa-assistentissa määrittelisit tuotuhaun, varaston tarkistuksen ja tilauksen tekemisen, ja antaisit mallin tehdä valinnat. Kun se kohtaa kysymyksen “Onko XPS-pelikannettava saatavilla?”, se ei suorita hakua, vaan kysyy suoraan varastotilannetta: valinnan ohjasivat funktion kuvaukset, ei kovakoodattu sääntö.

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

# Malli valitsee automaattisesti oikean funktion
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}")

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

Yksi pyyntö voi laukaista myös useita kutsuja samanaikaisesti. Kahden kaupungin sään vertailu tuottaa kaksi erillistä kutsua: koodisi täytyy siksi iteroida response.output läpi ja käsitellä kaikki function_call-kohteet, ei vain ensimmäistä. Tämä on myös tilaisuus suorittaa nämä kutsut rinnakkain ja puolittaa viive.

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

# Malli tekee kaksi kutsua rinnakkain
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']})")

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

Agenttisilmukka

Yksi edestakainen viesti harvoin riittää: yhden funktion tulos saa usein mallin kutsumaan toista funktion. Siksi käärit viestinnän silmukkaan, joka pyörii niin kauan kuin vastaus sisältää funktiokutsuja, ja pysähtyy heti kun niitä ei enää ole – tämä merkitsee, että malli on muotoillut lopullisen vastauksensa. Tämä on jokaisen agentin runko, ja näet sen eri muodoissa kaikissa agenttikehyksissä.

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

    if nom == "get_meteo":
        # Simulaatio – korvaa omalla APIllasi
        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
        )

        # Tarkista funktiokutsut
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Ei funktiokutsuja = lopullinen vastaus
            return response.output_text

        # Suorita jokainen funktio ja lisää tulokset
        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
            })

# Käyttö
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

Varoitus tähän malliin liittyen: while True -silmukassa ei ole turvavälejä. Tuotantoympäristössä lisää maksimikierroslaskuri; muuten malli, joka pyytää samaa työkalua loputtomiin, polttaa budjettisi tekemättä koskaan johtopäätöstä.

Lukitse argumentit tiukalla tilalla

Strict mode (tiukka tila) tarjoaa funktioparametreille saman takuun kuin Structured Output vastauksille: argumentit noudattavat tarkasti määriteltyä skeemaa. Funktiolle, joka luo käyttäjän, tämä estää tilanteen, jossa vastaanotat iän merkkijonona tai ylimääräisen kentän, jota koodisi ei odottanut.

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

Keskeiset asiat

  • Function Calling yhdistää mallin järjestelmiisi paljastamatta dataasi
  • Malli päättää, mikä funktio kutsutaan; koodisi suorittaa sen
  • Palauta tulos käyttämällä function_call_output ja call_id
  • Malli voi kutsua useita funktioita rinnakkain
  • Käytä agenttisilmukkaa monivaiheisiin keskusteluihin, jotka sisältävät funktioita
  • Ota käyttöön strict: True varmistaaksesi argumenttien yhteensopivuuden