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

Ailtireachtaí il-uirlisí sa táirgeadh

Ceacht 20 as 20 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Ailtireachtaí il-uirlisí sa táirgeadh
  2. Ailtireacht shraitheach
  3. Ordróir táirgeachta
  4. Cumraíocht dheclaráideach
  5. Inbhreathnaitheacht agus monatóireacht
  6. Bainistíocht costais
  7. Patrún: ródaire cliste
  8. Seicliosta táirgeachta
  9. Príomhphointí
  10. Tástáil do chuid eolais

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 mar input_text, agus úsáideann cuardach gréasáin an uirlis web_search (níl sa web_search_preview ach uirlis sheanda gan scagairí fearainn). Faightear comhaid ghinte trí na feidhmeanna fichiers_generes agus telecharger ó 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.