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

Glao feidhme chun cinn: scéimí agus bailíochtú

Ceacht 7 as 25 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Glao feidhme chun cinn: scéimí agus bailíochtú
  2. Scéimí JSON agus mód dian
  3. Bailíochtú saincheaptha le Pydantic
  4. Earráidí a láimhseáil in uirlisí
  5. Aschur struchtúrtha d’uirlisí
  6. Patrún: uirlisí le comhthéacs roinnte
  7. Príomhphointí

Glao feidhme chun cinn: scéimí agus bailíochtú

Is é an glao feidhme an príomh-mheicníocht a ligeann do ghníomhaire a chinneadh cathain agus conas do chuid uirlisí a ghlaowh. Tá sé leor uirlis a dhearbhú do phrótaitíopa, ach chun dul i mbun táirgeachta, caithfidh tú glaonna a shriain, luachanna gnó a bhailíochtú, agus teipeanna a láimhseáil gan an gníomhaire a chur as feidhm. Sin é an t-ábhar a phléitear sa cheacht seo.

Scéimí JSON agus mód dian

Úsáideann an API Freagraí scéimí JSON chun paraiméadair gach uirlise a chur síos, agus ráthaíonn an mód dian go leanann an múnla an scéim go beacht. Go sonrach, cuireann úsáid Enum nó Literal deireadh le luachanna cumtha.

from agents import function_tool
from pydantic import BaseModel, Field
from typing import Literal
from enum import Enum

class Priority(str, Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"

class CreateTicket(BaseModel):
    title: str = Field(description="Short ticket title (max 100 characters)")
    description: str = Field(description="Detailed problem description")
    priority: Priority = Field(description="Ticket priority level")
    component: Literal["frontend", "backend", "infra", "data"] = Field(
        description="Affected technical component"
    )
    tags: list[str] = Field(
        default_factory=list,
        description="Optional tags to categorize the ticket"
    )

@function_tool
def create_support_ticket(ticket: CreateTicket) -> str:
    """Creates a new technical support ticket."""
    # In production: call Jira, Linear, GitHub Issues, etc.
    return f"Ticket created: [{ticket.priority.value}] {ticket.title} ({ticket.component})"

Leis an mód dian gníomhachtaithe go réamhshocraithe, ní féidir leis an múnla tosaíocht neamhbhailí nó comhpháirt lasmuigh den liosta ceadaithe a sheoladh riamh. Ní bheidh ort cód cúltaca cosantach a scríobh chun “práinneach” nó “P1” a aistriú go luach a aithníonn do chóras ticéadúcháin.

Bailíochtú saincheaptha le Pydantic

Ní chuireann seiceáil cineála deireadh le luachanna dodhéanta, ach le luachanna absurdacha amháin. Is teaghrán bailí go hiomlán é IBAN cúigear carachtar déag; diúltaíonn do loighic gnó é. Ligeann Pydantic duit na rialacha seo a leabú go díreach sa scéim.

from pydantic import BaseModel, Field, field_validator

class MoneyTransfer(BaseModel):
    source_account: str = Field(description="Source account IBAN")
    destination_account: str = Field(description="Destination account IBAN")
    amount: float = Field(gt=0, le=50000, description="Amount in euros (max 50,000)")
    reason: str = Field(min_length=5, max_length=200, description="Reason for transfer")

    @field_validator("source_account", "destination_account")
    @classmethod
    def validate_iban(cls, v):
        if not v.startswith("FR"):
            raise ValueError("Only French IBANs are accepted")
        if len(v) != 27:
            raise ValueError("IBAN must contain 27 characters")
        return v

@function_tool
def execute_transfer(transfer: MoneyTransfer) -> str:
    """Executes a bank transfer between two accounts."""
    return f"Transfer of €{transfer.amount} initiated from {transfer.source_account[:8]}... to {transfer.destination_account[:8]}..."

Tá ról cosúil ag na srianta gt=0 agus le=50000 ar an méid ar leibhéal eile: déanann siad aistriú diúltach nó aistriú a sháraíonn an teorainn struchtúrtha dodhéanta, beag beann ar an gcaoi a gcuireann an t-úsáideoir an t-iarratas in iúl.

Earráidí a láimhseáil in uirlisí

Cad faoi nuair a fheidhmíonn uirlis ach a theipeann? Is é an claonadh ná ligean don eisceacht teacht chun cinn; is botún é sin, toisc go gcuireann sé isteach ar lúb an ghníomhaire. Ina ionad sin, seol teachtaireacht earráide shoiléir is féidir leis an múnla a léamh agus a léirmhíniú.

import json
from agents import function_tool

@function_tool
def query_external_api(endpoint: str, parameters: dict) -> str:
    """Queries an external API with the specified parameters."""
    try:
        # In production: real HTTP call
        import httpx
        response = httpx.get(f"https://api.example.com/{endpoint}", params=parameters, timeout=10)
        response.raise_for_status()
        return json.dumps(response.json(), ensure_ascii=False)
    except httpx.TimeoutException:
        return json.dumps({
            "error": True,
            "message": f"Timeout calling {endpoint}. Retry in a few moments."
        })
    except httpx.HTTPStatusError as e:
        return json.dumps({
            "error": True,
            "message": f"HTTP error {e.response.status_code} on {endpoint}.",
            "details": str(e)
        })
    except Exception as e:
        return json.dumps({
            "error": True,
            "message": f"Unexpected error: {str(e)}"
        })

Déanann gach brainse formáidiú ar an teachtaireacht i dteanga a thuigeann an múnla. I gcás ama-teorainn, déanfaidh an gníomhaire iarracht eile; i gcás earráid HTTP 404, cuirfidh sé an t-úsáideoir ar an eolas nó athróidh sé cur chuige seachas leanúint ar aghaidh go dall.

Aschur struchtúrtha d’uirlisí

Baineann an srian seo leis an aschur deiridh freisin. Le output_type, ní téacs le parsáil é final_output a thuilleadh ach oibiacht chineálaithe atá inúsáidte go díreach ag an gcód glaonna.

from pydantic import BaseModel
from agents import Agent, Runner

class AnalysisResponse(BaseModel):
    summary: str
    key_points: list[str]
    recommendation: str
    confidence_score: float

agent = Agent(
    name="Analyst",
    instructions="Analyze the provided data and produce a structured report.",
    model="gpt-5.6-terra",
    output_type=AnalysisResponse,
)

result = Runner.run_sync(agent, "Analyze Q1 2026 sales trends.")
# result.final_output is of type AnalysisResponse
print(f"Summary: {result.final_output.summary}")
print(f"Score: {result.final_output.confidence_score}")

Patrún: uirlisí le comhthéacs roinnte

Saincheist athfhillteach amháin eile: go minic teastaíonn staid roinnte ó d’uirlisí—seisiún úsáideora, nasc bunachair sonraí, eochair API—nach mbeadh ciall ar bith ann a rith tríd an múnla. Réitíonn an comhthéacs é seo trí é a rith in éineacht leis an gcomhrá.

from dataclasses import dataclass
from agents import Agent, Runner, RunContextWrapper, function_tool

@dataclass
class AppContext:
    user_id: str
    db_connection: object  # Your DB connection
    api_key: str

@function_tool
def get_user_profile(ctx: RunContextWrapper[AppContext]) -> str:
    """Retrieves the current user's profile."""
    user_id = ctx.context.user_id
    # Use ctx.context.db_connection for the query
    return f"User profile {user_id}: Premium, active since 2024"

agent = Agent(
    name="Personalized Agent",
    instructions="You assist the logged-in user.",
    tools=[get_user_profile],
)

context = AppContext(user_id="usr_123", db_connection=None, api_key="xxx")
result = Runner.run_sync(agent, "What is my profile?", context=context)

Níl aon pharaiméadair gnó ag an uirlis: tagann céannacht an úsáideora ón gcomhthéacs, ní ón múnla. Is beart slándála é seo freisin, ós rud é nach féidir leis an ngníomhaire próifíl duine eile a fheiceáil trí argóint a athrú.

Príomhphointí

  • Ráthaíonn scéimí Pydantic le heinsímí agus Literals bailíocht an ghlao
  • Cuireann bailíochtóirí réimse bailíochtú gnó le seiceáil cineála
  • Seol teachtaireachtaí earráide JSON in ionad eisceachtaí a ardú in uirlisí
  • Éigníonn output_type an gníomhaire a fhreagairt dheiridh a struchtúrú
  • Ligeann comhthéacs roinnte (RunContextWrapper) d’uirlisí teacht ar staid an fheidhmchláir