Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Glaoch Feidhme: Ceangail AI le Do Chórais

Ceacht 10 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Glaoch Feidhme: Ceangail AI le Do Chórais
  2. An Sruth Iomlán, Céim ar Chéim
  3. Ligean don Mhúnla Roghnú I measc Uirlisí Iolracha
  4. An Lúb Gníomhaire
  5. Argóintí a Dhaingniú le Mód Doinn
  6. Príomhphointí

Glaoch Feidhme: Ceangail AI le Do Chórais

Ligeann glaoch feidhme don mhúnla feidhmeanna a shainíonn tú a ghlaowh. Coinnigh riail amháin i dtús is i deireadh an scéil, mar eascraíonn gach rud eile aisti: ní fhorghníomhaíonn an múnla iad. Inseoidh sé duit cén fheidhm le glaoch agus le cad iad na hargóintí; is é do chód a dhéanann an fhorghníomhú agus a thugann an toradh ar ais. Ní fhágann do bhunachar sonraí, do chreidiúintí ná do loighic ghnó do bhonneagar riamh.

An Sruth Iomlán, Céim ar Chéim

Tarlaíonn an malartú i gceithre chéim:

  1. Fógraíonn tú na feidhmeanna atá ar fáil mar aon lena bparaiméadair
  2. Déanann an múnla anailís ar an iarratas agus cinneann sé feidhm a ghlaowh
  3. Forghníomhaíonn do chód an fheidhm agus faigheann sé an toradh
  4. Seolann tú an toradh ar ais chuig an múnla ionas gur féidir leis a fhreagra a fhoirmiú

Tuilleann an fógra cúram ar leith: is iad description na feidhme agus cur síos gach paraiméadair an t-aon doiciméadú atá ag an múnla chun a chinneadh a dhéanamh. Leadránach cur síosanna a bheith ann, beidh glaonna neamhchruinne mar thoradh air. Tabhair faoi deara freisin conas an lúb a dhúnadh – téann an toradh ar ais leis an call_id a fuair tú, a fheidhmíonn mar admháil agus a ligeann don API an fhreagra a mheaitseáil leis an iarratas.

from openai import OpenAI
import json

client = OpenAI()

# Céim 1: Fógraigh na feidhmeanna atá ar fáil
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"]
    }
}]

# Céim 2: Cinneann an múnla an fheidhm a ghlaowh
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Céim 3: Forghníomhaigh an fheidhm
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)

        # Do chur i bhfeidhm féin
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Céim 4: Seol an toradh ar ais chuig an múnla
        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}")

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

Ligean don Mhúnla Roghnú I measc Uirlisí Iolracha

Léirítear an fíorluach nuair a nochtann tú catalóg iomlán cumais. I gcúntóir ríomhthráchtála, d’fhógrófá cuardach táirgí, fíorú stoc, agus cur isteach ordaithe, agus ansin ligfeá don mhúnla idirghabháil a dhéanamh. Ag tabhairt aghaidh ar “An bhfuil an ríomhaire glúine cearrbhachais XPS ar fáil?”, ní dhéanfaidh sé cuardach ach déanfaidh sé fiosrúchán ar an stoc go díreach: is iad do chur síosanna feidhme, seachas riail chrua-chódaithe, a thiomáin an rogha sin.

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

# Roghnaíonn an múnla an fheidhm cheart go huathoibríoch
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}")

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

Is féidir le hiarratas amháin freisin glaonna iolracha a spreagadh ag an am céanna. Cruthaíonn comparáid idir aimsir dhá chathair dhá ghlao neamhspleácha: caithfidh do chód, dá bhrí sin, iteráil trí response.output agus gach mír function_call a láimhseáil, gan riamh an chéad cheann amháin. Is deis é seo freisin chun na glaonna seo a fhorghníomhú go comhthreomhar agus an moill a ghearradh faoina leath.

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

# Déanann an múnla dhá ghlao go comhthreomhar
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']})")

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

An Lúb Gníomhaire

Is annamh a leor turas amháin: minic a threoraíonn toradh feidhme amháin an múnla chun ceann eile a ghlaowh. Mar sin, cuimsíonn tú an malartú i lúb a ritheann fad is a bhíonn glaonna feidhme sa fhreagra agus a stopann chomh luath agus nach mbíonn – comhartha go bhfuil an fhreagra dheireanach foirmithe ag an múnla. Is é seo cnámharlach gach gníomhaire, agus feicfidh tú é faoi chuma éagsúil i ngach creatlach gníomhaire.

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

    if nom == "get_meteo":
        # Simléid — cuir do API fíor in ionad é
        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
        )

        # Seiceáil le haghaidh glaonna feidhme
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Gan glaonna feidhme = freagra deiridh
            return response.output_text

        # Forghníomhaigh gach feidhm agus cuir torthaí leis
        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
            })

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

Focal rabhaidh faoin bpatrún seo: níl aon chosaintí ag an lúb while True. Sa táirgeadh, cuir uasmhéid iteráide leis; murach sin, dófaidh múnla a iarrann an uirlis chéanna go síoraí do bhuiséad gan teacht ar chonclúid riamh.

Argóintí a Dhaingniú le Mód Doinn

Cuirann mód doinn an ráthaíocht chéanna i bhfeidhm ar pharaiméadair feidhme agus a chuireann Aschur Struchtúrtha i bhfeidhm ar fhreagraí: leanann argóintí an scéima dearbhaithe go docht. I gcás feidhme a chruthaíonn úsáideoir, coscaíonn sé seo ort aois a fháil mar shreang, nó réimse breise nach raibh súil ag do chód leis.

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

Príomhphointí

  • Nascann glaoch feidhme an múnla le do chórais gan do chuid sonraí a nochtadh
  • Cinneann an múnla cén fheidhm le glaoch; forghníomhaíonn do chód í
  • Tug an toradh ar ais ag baint úsáide as function_call_output agus an call_id
  • Is féidir leis an múnla glaonna iolracha a dhéanamh go comhthreomhar
  • Úsáid lúb gníomhaire le haghaidh comhráite il-chasacha ina bhfuil feidhmeanna i gceist
  • Cumasaigh strict: True chun comhlíonadh argóintí a ráthú