Ailtireachtaí il-uirlisí sa táirgeadh
Ar an leathanach seo
Nuashonraithe an 2 Samhain, 2026 bunaithe ar dhoiciméadú OpenAI: éilíonn an uirlis Code Interpreter anois paraiméadar
container(curtha leis i ngach sampla), tá codanna ionchuir téacs cineálaithe marinput_text, agus úsáideann cuardach gréasáin an uirlisweb_search(níl saweb_search_previewach uirlis sheanda gan scagairí fearainn). Faightear comhaid ghinte trí na feidhmeannafichiers_generesagustelechargeró Cheacht 10. Foinse: Code Interpreter · Cuardach gréasáin.
Ailtireachtaí il-uirlisí sa táirgeadh
Oibríonn prótatáip il-uirlisí toisc go n-úsáideann duine amháin é, aithníonn sé a theorainneacha, agus atosnaíonn sé é nuair a theipeann air. Bainíonn an táirgeadh na trí choinníoll sin ar fad ag an am céanna. Ní cháilíocht na freagra an rud is criticiúla anois—bhí sé sin ann cheana féin—ach trí airí nach raibh ag an bprótatáip: a fhios a bheith agat cad a tharla nuair a theipeann ar ghlao, cosc a chur ar lúb rite a chuirfeadh do bhuiséad i mbaol, agus an cumas iompraíocht a mhodhnú gan ath-imscaradh.
Pléann na patrúin thíos ceann amháin de na riachtanais sin. Ná glac leo go léir ag an am céanna: tosaigh le hinbhreathnaitheacht, mar gan í ní bheidh a fhios agat fiú cé acu de na cinn eile atá in easnamh ort.
Ailtireacht shraitheach
Ní áilleacht ailtireachta atá i ndeighilt imní ina sraitheanna: déanann sé gach cuid in-ionadaithe. Is é an sochar concreideach ná gur féidir leat an t-ordú a athrú gan an comhéadan a bhaint, nó uirlis a chur leis gan an loighic gnó a athscríobh. Is iad na ceithre shraith thíos an bhriseadh síos íosta a sheasann i bhfíorshaol.
# Sraith 1: Comhéadan - glacadh le hiarratais
# Sraith 2: Ordrú - bainistíocht lúibe agus ródaíochta
# Sraith 3: Feidhmiú - glaoite uirlisí agus feidhmeanna
# Sraith 4: Inbhreathnaitheacht - logaí, méadrachtaí, rianta
from openai import OpenAI
from dataclasses import dataclass, field
from datetime import datetime
import json
import time
import logging
logger = logging.getLogger("il-uirlisí")
@dataclass
class RianFeidhmithe:
"""Rian feidhmithe le haghaidh monatóireachta."""
requete_id: str
debut: float = field(default_factory=time.time)
tours: list = field(default_factory=list)
outils_utilises: list = field(default_factory=list)
tokens_total: int = 0
erreurs: list = field(default_factory=list)
duree_totale: float = 0.0
Ordróir táirgeachta
class OrchestreurProduction:
def __init__(self, config: dict):
self.client = OpenAI()
self.config = config
self.tools = self._construire_tools(config)
self.dispatcher = self._construire_dispatcher(config)
def _construire_tools(self, config: dict) -> list:
"""Tógann sé an eagar uirlisí ón gcumraíocht."""
tools = []
if config.get("file_search"):
tools.append({
"type": "file_search",
"vector_store_ids": config["file_search"]["vector_stores"],
"max_num_results": config["file_search"].get("max_results", 10)
})
if config.get("web_search"):
tools.append({
"type": "web_search",
"search_context_size": config["web_search"].get("context_size", "medium")
})
if config.get("code_interpreter"):
tools.append({"type": "code_interpreter", "container": {"type": "auto"}})
for func in config.get("fonctions", []):
tools.append(func)
return tools
def _construire_dispatcher(self, config: dict) -> dict:
"""Mapálann sé ainmneacha feidhme lena gcur i bhfeidhm."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Feidhmíonn sé iarratas le rianú iomlán."""
trace = TraceExecution(
requete_id=f"req_{int(time.time()*1000)}"
)
content = [{"type": "input_text", "text": requete}]
if fichiers:
for fid in fichiers:
content.append({"type": "input_file", "file_id": fid})
messages = [{"role": "user", "content": content}]
try:
for tour in range(max_tours):
debut_tour = time.time()
response = self.client.responses.create(
model=self.config.get("model", "gpt-5.6-terra"),
input=messages,
tools=self.tools,
instructions=self.config.get("instructions", "")
)
trace.tokens_total += response.usage.total_tokens
# Aithin glaoite feidhme
appels = [
item for item in response.output
if item.type == "function_call"
]
# Taifead na huirlisí a úsáideadh
for item in response.output:
if hasattr(item, "type"):
trace.outils_utilises.append(item.type)
trace.tours.append({
"numero": tour + 1,
"appels_fonction": len(appels),
"duree": time.time() - debut_tour
})
if not appels:
trace.duree_totale = time.time() - trace.debut
return {
"reponse": response.output_text,
"trace": trace
}
# Feidhmigh feidhmeanna saincheaptha
resultats = self._executer_fonctions(appels, trace)
messages = response.output + resultats
except Exception as e:
trace.erreurs.append(str(e))
trace.duree_totale = time.time() - trace.debut
logger.error(f"Earráid iarratais {trace.requete_id}: {e}")
return {"reponse": None, "erreur": str(e), "trace": trace}
trace.duree_totale = time.time() - trace.debut
return {"reponse": "Teorainn turas", "trace": trace}
def _executer_fonctions(self, appels: list, trace: TraceExecution) -> list:
"""Feidhmíonn sé feidhmeanna le láimhseáil earráidí."""
resultats = []
for appel in appels:
try:
func = self.dispatcher.get(appel.name)
if not func:
raise ValueError(f"Feidhm anaithnid : {appel.name}")
args = json.loads(appel.arguments)
resultat = func(**args)
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
})
except Exception as e:
trace.erreurs.append(f"{appel.name}: {str(e)}")
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps({"error": str(e)})
})
return resultats
Cumraíocht dheclaráideach
Trí shainmhínithe córais a bhogadh amach as an gcód agus isteach sa chumraíocht, athraíonn sé cé is féidir idirghabháil a dhéanamh. Is athrú comhaid é córas leid a choigeartú, uirlis a bhaint, nó uasteorainn costais a mhodhnú—inar féidir é a athbhreithniú agus a chúlghairm—in ionad imscaradh. Ar chóras a fhorbraíonn go seachtainiúil, sin an difríocht idir iteráil agus freagairt.
config_assistant_commercial = {
"model": "gpt-5.6-terra",
"instructions": (
"Is cúntóir díolacháin tú. Tá rochtain agat ar shonraí CRM, "
"doiciméadú táirge, an gréasán, agus anailís sonraí. "
"Tosaigh le sonraí inmheánacha, saibhrigh le sonraí gréasáin."
),
"file_search": {
"vector_stores": ["vs_fiches_produit", "vs_propositions"],
"max_results": 10
},
"web_search": {
"context_size": "medium"
},
"code_interpreter": True,
"fonctions": [
{
"type": "function",
"name": "creer_opportunite",
"description": "Cruthaigh deis sa CRM",
"parameters": {
"type": "object",
"properties": {
"client": {"type": "string"},
"montant": {"type": "number"},
"probabilite": {"type": "integer"}
},
"required": ["client", "montant", "probabilite"],
"additionalProperties": False
},
"strict": True
}
],
"implementations": {
"creer_opportunite": lambda client, montant, probabilite:
crm_service.creer_opportunite(client, montant, probabilite)
}
}
orchestreur = OrchestreurProduction(config_assistant_commercial)
resultat = orchestreur.executer("Ullmhaigh togra do Acme Corp")
Inbhreathnaitheacht agus monatóireacht
Deasc mhéadrachtaí
Tá trí mhéadracht go leor chun tosú, agus freagraíonn gach ceann acu ceist eile: insíonn moill in aghaidh na huirlise duit cé acu ceann atá ag cur moill ar an gcóras, insíonn ráta teipthe in aghaidh na huirlise duit cé acu ceann atá leochaileach, agus insíonn costas in aghaidh na hiarrata duit cé acu ceann atá ag dul amú. Ní fhreagraíonn meán domhanda ar fud na dtrí cheist ar bith díobh seo.
class MetriquesMultiOutils:
def __init__(self):
self.requetes = []
def enregistrer(self, trace: TraceExecution):
self.requetes.append({
"id": trace.requete_id,
"timestamp": datetime.now().isoformat(),
"duree": trace.duree_totale,
"tours": len(trace.tours),
"tokens": trace.tokens_total,
"outils": list(set(trace.outils_utilises)),
"erreurs": len(trace.erreurs),
"cout_estime": self._estimer_cout(trace)
})
def _estimer_cout(self, trace: TraceExecution) -> float:
"""Meastachán ar chostas i ndollairí an fheidhmithe."""
# Rátaí neasacha do gpt-5.6-terra: $2 / $12 in aghaidh an mhilliúin
cout_input = trace.tokens_total * 0.6 * 0.000002
cout_output = trace.tokens_total * 0.4 * 0.000012
return round(cout_input + cout_output, 4)
def rapport(self) -> dict:
if not self.requetes:
return {}
durees = [r["duree"] for r in self.requetes]
tokens = [r["tokens"] for r in self.requetes]
couts = [r["cout_estime"] for r in self.requetes]
return {
"total_requetes": len(self.requetes),
"duree_moyenne": sum(durees) / len(durees),
"tokens_moyen": sum(tokens) / len(tokens),
"cout_total": sum(couts),
"taux_erreur": sum(1 for r in self.requetes if r["erreurs"] > 0) / len(self.requetes),
"outils_les_plus_utilises": self._outils_frequents()
}
def _outils_frequents(self) -> dict:
compteur = {}
for r in self.requetes:
for outil in r["outils"]:
compteur[outil] = compteur.get(outil, 0) + 1
return dict(sorted(compteur.items(), key=lambda x: -x[1]))
Bainistíocht costais
class GestionnaireCouts:
def __init__(self, budget_quotidien: float = 50.0):
self.budget = budget_quotidien
self.depenses_jour = 0.0
self.date_reset = datetime.now().date()
def peut_executer(self, cout_estime: float) -> bool:
"""Seiceálann sé an ligeann an buiséad don fheidhmiú."
aujourdhui = datetime.now().date()
if aujourdhui > self.date_reset:
self.depenses_jour = 0.0
self.date_reset = aujourdhui
return (self.depenses_jour + cout_estime) <= self.budget
def enregistrer_depense(self, cout: float):
self.depenses_jour += cout
def budget_restant(self) -> float:
return self.budget - self.depenses_jour
# Comhtháthú san ordóir
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Meastachán coimeádach
if not gestionnaire_couts.peut_executer(cout_estime):
return {"erreur": "Buiséad laethúil bainte amach", "restant": 0}
resultat = orchestreur.executer(requete, **kwargs)
cout_reel = resultat["trace"].tokens_total * 0.000002
gestionnaire_couts.enregistrer_depense(cout_reel)
return resultat
Patrún: ródaire cliste
De réir mar a mhéadaíonn cásanna úsáide, is é an temptáil gach rud a thabhairt do chóras amháin atá feistithe le gach uirlis. Sin an rogha is costasaí: iompraíonn gach iarratas, fiú cinn thriviálacha, an tacar iomlán de shainmhínithe uirlisí. Coinníonn ródaire a aicmíonn an t-iarratas ar dtús, agus a ghlaonn ansin ar ordóir speisialaithe, comhthéacsanna gearr agus déanann sé gach sreabha in-tomhaiste ar leith.
class RouteurIntelligent:
def __init__(self):
self.client = OpenAI()
self.orchestreurs = {}
def enregistrer(self, domaine: str, orchestreur: OrchestreurProduction):
self.orchestreurs[domaine] = orchestreur
def router(self, requete: str) -> dict:
"""Cinneann sé an fearann agus ródaíonn sé chuig an ordóir ceart."""
# Aicmiú tapa le samhail éadrom
response = self.client.responses.create(
model="gpt-5.6-terra",
input=f"Aicmigh an t-iarratas seo i bhfearann: {requete}\n"
f"Fearainn ar fáil: {list(self.orchestreurs.keys())}\n"
f"Freagair leis an ainm fearainn amháin.",
)
domaine = response.output_text.strip().lower()
if domaine not in self.orchestreurs:
domaine = "general" # Cúlpháirtí
logger.info(f"Iarratas ródaíte chuig : {domaine}")
return self.orchestreurs[domaine].executer(requete)
# Cumraíocht
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))
# Úsáid
resultat = routeur.router("Cé mhéad lá saoire atá fágtha agam?")
# -> Ródaíonn sé go huathoibríoch chuig an ordóir HR
Seicliosta táirgeachta
Tá an seicliosta seo beartaithe a bheith gairid go dánta. Ní dhíríonn sé ar iomláine ach clúdaíonn sé na pointí a chosnaíonn tú in iontaobhais seachas míchompord—agus nach féidir leat a chur leis ar bhiaiste an lá atá an córas cheana féin i lámha na n-úsáideoirí.
checklist = {
"securite": [
"Bailíochtaigh argóintí do gach feidhm",
"Teorannú ráta in aghaidh an úsáideora",
"Glan isteach agus amach",
"Gan sonraí íogaire i logaí"
],
"fiabilite": [
"Athiarracht le cúlú ar earráidí sealadacha",
"Briseadh ciorcaid in aghaidh gach seirbhíse seachtraí",
"Teorainn ama in aghaidh na huirlise agus na hiarrata domhanda",
"Cúlpháirtí nuair nach bhfuil uirlis ar fáil"
],
"performance": [
"Feidhmiú comhthreomhar de ghlaoite neamhspleácha",
"Taisce torthaí cuardaigh minic",
"Teorainn ar líon na n-atriallta lúibe",
"Roghnaigh an tsamhail oiriúnach don chastacht (gpt-5.6-terra vs gpt-5.6-terra)"
],
"observabilite": [
"Logáil struchtúrtha do gach glao",
"Méadrachtaí moille agus costais",
"Fógraí ar ráta earráide",
"Rian iomlán de gach iarratas"
],
"couts": [
"Buiséad laethúil le briseadh ciorcaid",
"Meastachán costais roimh fheidhmiú",
"Tuairisc caiteachais seachtainiúil",
"Optamú roghnaíochta samhla de réir castachta"
]
}
Príomhphointí
- Déan díchóimeáil i sraitheanna: comhéadan, ordú, feidhmiú, inbhreathnaitheacht
- Úsáid cumraíocht dheclaráideach chun córais a shainiú
- Rianaigh gach feidhmiú le haghaidh monatóireachta agus dífhabhtaithe
- Cuir bainisteoir costais i bhfeidhm le buiséad laethúil
- Dáileann ródaire cliste iarratais chuig na hordóirí cearta
Tástáil do chuid eolais
Glao feidhme, cuardach, feidhmiú: an t-armchlár iomlán i gcúig cheist.
1. Cad ba chóir a bheith i scéim feidhme mhaith?
Freagra: Cineálacha docht agus cur síos oibríochtúil in aghaidh an pharaiméadair—is é seo an conradh a úsáideann an tsamhail chun cinneadh a dhéanamh cathain a ghlaofar agus conas é a líonadh; diúltaíonn bailíochtú an chuid eile.
2. Cuardach Gréasáin nó Cuardach Comhad: conas a roghnaíonn tú?
Freagra: Cuardach Gréasáin le haghaidh faisnéise poiblí, le déanaí; Cuardach Comhad do do dhoiciméid innéacsaithe (míreanna + rangú ionsuite)—agus comhcheanglaíonn cuardach hibrideach an dá cheann nuair a shíneann an freagra thar an dá shaol.
3. Cad a cheadaíonn Code Interpreter san API?
Freagra: Cód a fheidhmiú i ngaineamhlann: próiseáil CSV/Excel/íomhánna, ríomh go cruinn, cairteacha a tháirgeadh—déanann an tsamhail réasúnaíocht, ríomhann an cód, agus aonraíonn an ghaineamhlann.
4. Cad é Cuardach Uirlisí ann?
Freagra: Chun catalóg mhór uirlisí a nochtadh go dinimiciúil: déanann an tsamhail cuardach ar an uirlis ábhartha in ionad na céadta scéime a fháil ag an am céanna—fanann an comhthéacs éadrom, fanann na cumais ollmhór.
5. Cé na rialacha a bhaineann le hailtireacht il-uirlisí sa táirgeadh?
Freagra: Uirlisí le raon feidhme soiléir, láimhseáil earráidí agus cúlpháirtithe in aghaidh na huirlise, glaoite comhthreomhara nuair atá siad neamhspleách, agus inbhreathnaitheacht do gach glao—dearthar láidreacht uirlis ar uirlis.
Tá a thalamh féin ag gach uirlis; comhcheanglaíonn an táirgeadh iad—is é an ailtireacht dheireanach thuas do phlean tagartha.