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

Glaochanna Comhthreomhara agus Seicheamhacha

Ceacht 3 as 20 Forbróir
Ar an leathanach seo
  1. Glaochanna Comhthreomhara agus Seicheamhacha
  2. Glaochanna Comhthreomhara
  3. Glaochanna Comhthreomhara a Dhíchumasú
  4. Glaochanna Seicheamhacha le Lúb
  5. Sampla Oibre: Píblíne Próiseála
  6. Patrún Hibrideach: Comhthreomhar agus ansin Seicheamhach
  7. Príomhphointí

Glaochanna Comhthreomhara agus Seicheamhacha

Is féidir leis an tsamhail roinnt glaoch feidhme a eisiúint in aon fhreagra amháin, agus déanann sí é sin go huathoibríoch a luaithe a aithníonn sí riachtanais neamhspleácha. Ní optamú cosmaideach atá ann seo: tógann trí ghlaoch dhá shoicind a ritear le chéile dhá shoicind san iomlán, ach thógfadh sé sé shoicind dá ndéanfaí iad a shlabhrú go seicheamhach.

Ní hé an chaoi le comhthreomhú a dhéanamh is ábhar an cheachta seo—déanann an tsamhail é sin cheana féin—ach conas na cásanna sin a aithint nach ba chóir duit é a dhéanamh. Tá dhá ghlaoch neamhspleách nuair nach mbíonn tionchar ag ord an fhorghníomhaithe ar an toradh. A luaithe a léann oibríocht amháin an rud a scríobh ceann eile, nó nuair a chaithfidh paraiméadar teacht ó ghlaoch roimhe seo, déanann an comhthreomhú fabht atá deacair a atáirgeadh de.

Glaochanna Comhthreomhara

Ní gá aon rud a chumasú: is é seo an iompar réamhshocraithe. Cruthaíonn fiosrúchán faoi thrí chathair trí mhír function_call san fhreagra céanna; déanann tusa iad a fhorghníomhú. Tabhair faoi deara go ndéanann an tsamhail réasúnú ar bhrí na bhfeidhmeanna bunaithe ar do chuid cur síos—is iad na cur síos a thiomáineann an cinneadh, mar atá i ngach rud beagnach sa chúrsa seo.

from openai import OpenAI
import json
import asyncio

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_meteo",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "get_taux_change",
        "description": "Get exchange rate between two currencies",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "cible": {"type": "string"}
            },
            "required": ["source", "cible"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather in Paris and Berlin, "
          "and what is the EUR/USD exchange rate?",
    tools=tools
)

# The model emits 3 calls in parallel
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3

Glaochanna Comhthreomhara a Fhorghníomhú ar an gCliant

Níl aon mhaith trí ghlaoch a fháil ag an am céanna má fhorghníomhaíonn do chód iad ceann ar cheann: caillfidh tú an tairbhe ar fad ar thaobh an chliaint. Is é asyncio.gather an t-íosmhéid; cuir dhá réamhchúram leis don táirgeadh—teorainn comhthreomhaireachta, ionas nach osclóidh tú caoga ceangal comhuaineach le seirbhís nach dtacaíonn ach le deich, agus láimhseáil earráide in aghaidh an ghlaoigh, ionas nach gcuirfidh teip aonair na torthaí eile as a chéile.

async def executer_fonction(name: str, arguments: str) -> dict:
    args = json.loads(arguments)
    if name == "get_meteo":
        return await api_meteo(args["ville"])
    elif name == "get_taux_change":
        return await api_change(args["source"], args["cible"])

async def traiter_appels_paralleles(appels):
    taches = [
        executer_fonction(appel.name, appel.arguments)
        for appel in appels
    ]
    resultats = await asyncio.gather(*taches)

    return [
        {
            "type": "function_call_output",
            "call_id": appel.call_id,
            "output": json.dumps(resultat)
        }
        for appel, resultat in zip(appels, resultats)
    ]

# Execute
resultats = asyncio.run(traiter_appels_paralleles(appels))

# Send back to the model
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)
print(response_finale.output_text)

Glaochanna Comhthreomhara a Dhíchumasú

Cuirfidh parallel_tool_calls=False iallach ar an tsamhail gan ach glaoch amháin a eisiúint in aghaidh na freagra. Úsáid an socrú seo go hintinneach: malartaíonn sé moille ar shábháilteacht. Coinnigh é do fheidhmeanna a scríobhann, a mhodhnaíonn, nó a spreagann rud éigin seachtrach.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Process these three orders",
    tools=tools,
    parallel_tool_calls=False  # One call per response
)

Cásanna úsáide chun comhthreomhú a dhíchumasú:

  • Oibríochtaí nach mór a fhorghníomhú in ord sonrach
  • Feidhmeanna le fo-iarsmaí a chuireann isteach ar a chéile
  • Nuair a chuireann toradh glao amháin an chéad cheann eile faoi choinníoll

Glaochanna Seicheamhacha le Lúb

Ní paraiméadar a rialaíonn forghníomhú seicheamhach: eascraíonn sé as an lúb. Forghníomhaíonn tú an glaoch, seolann tú an toradh ar ais, agus déanann an tsamhail cinneadh faoin gcéad chéim eile bunaithe ar an méid a d’fhoghlaim sí díreach. Is é seo go díreach a dhéanann idirdhealú idir slabhra dinimiciúil agus plean docht—má nochtann céim 2 nach gá céim 3, ní ghlaofaidh an tsamhail air.

def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
    """Complete loop for sequential function calling."""
    messages_input = prompt
    tour = 0

    while tour < max_tours:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages_input,
            tools=tools,
            parallel_tool_calls=False
        )

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

        if not appels:
            # Model is done, responding with text
            return response.output_text

        # Execute each call
        resultats = []
        for appel in appels:
            resultat = executer_fonction_sync(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare next turn
        messages_input = response.output + resultats
        tour += 1

    return "Turn limit reached"

Sampla Oibre: Píblíne Próiseála

Cás tipiciúil ina bhfuil forghníomhú seicheamhach éigeantach, toisc go n-itheann gach céim an rud a tháirg an ceann roimhe:

tools_pipeline = [
    {
        "type": "function",
        "name": "valider_commande",
        "description": "Verify order validity (stock, price, customer)",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"}
            },
            "required": ["commande_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "calculer_livraison",
        "description": "Calculate shipping fees and delays. "
                       "Requires a validated order.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "mode": {"type": "string", "enum": ["standard", "express"]}
            },
            "required": ["commande_id", "mode"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "confirmer_commande",
        "description": "Confirm the order and trigger payment. "
                       "Requires prior validation and shipping calculation.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "livraison_id": {"type": "string"}
            },
            "required": ["commande_id", "livraison_id"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# The model will naturally call in this order:
# 1. valider_commande
# 2. calculer_livraison (using step 1 result)
# 3. confirmer_commande (using results from steps 1 and 2)
resultat = boucle_function_calling(
    "Process order CMD-42567 with express shipping",
    tools_pipeline
)

Patrún Hibrideach: Comhthreomhar agus ansin Seicheamhach

Go praiticiúil, leanann an chuid is mó de shreabha oibre an domhain fhíor an patrún measctha seo: céim bailithe ina bhféadfar gach rud a rith go comhuaineach, agus ina dhiaidh sin céim próiseála a urramaíonn spleáchais. Ní gá duit aon rud speisialta a chódú chuige seo—is toradh nádúrtha na lúibe é, ar choinníoll go ndéanann do chur síos na spleáchais a shoiléiriú.

# Turn 1: Parallel data collection
# The model calls get_client AND get_stock in parallel

# Turn 2: Sequential decision based on results
# The model calls valider_commande with collected info

# Turn 3: Final action
# The model calls confirmer_commande

Tá an patrún seo nádúrtha: déanann an tsamhail comhthreomhú go huathoibríoch nuair atá glaochanna neamhspleách, agus ansin déanann sí slabhrú go seicheamhach nuair a bhíonn spleáchas ann.

Príomhphointí

  • Déanann an tsamhail glaochanna neamhspleácha a chomhthreomhú go huathoibríoch
  • Úsáid asyncio.gather chun glaochanna comhthreomhara a fhorghníomhú ar thaobh an chliaint
  • Díchumasaigh le parallel_tool_calls=False nuair a bhíonn tábhacht leis an ord
  • Cuir lúb i bhfeidhm do shreabha oibre ilchéime
  • Treoraíonn cur síos na bhfeidhmeanna an tsamhail maidir le spleáchais idir céimeanna