Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Ħiliet: Inkapsular il-Kapaċitajiet

Lezzjoni 17 / 20 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Ħiliet: Inkapsular il-Kapaċitajiet
  2. Il-Kunċett tal-Ħila
  3. L-Istrutturar ta’ Librerija tal-Ħiliet
  4. Il-Kompożizzjoni tal-Ħiliet
  5. Ħiliet b’Istat (Stateful)
  6. Reġistru tal-Ħiliet
  7. Punti Ewlenin

Lezzjoni aġġornata fit-2 ta’ Novembru 2026 abbażi tad-dokumentazzjoni ta’ OpenAI: l-għodda Code Interpreter issa teħtieġ parametru container (miżjud mal-eżempji kollha), il-partijiet tal-input tat-test huma tat-tip input_text, u t-tiftix fuq il-web juża l-għodda web_search (web_search_preview issa hija għodda antika mingħajr filtri tad-dominju). Il-fajls iġġenerati jiġu rkuprati bl-użu tal-funzjonijiet fichiers_generes u telecharger mil-Lezzjoni 10. Sorsi: Code Interpreter · Web search.

Ħiliet: Inkapsular il-Kapaċitajiet

Ħila (Skill) issolvi problema li kulħadd jiltaqa’ magħha sal-ġimgħa tnejn: l-istess prompt tas-sistema kkupjat f’erba’ fajls, li jibdew jiddevjaw malli ttejjeb wieħed biss minnhom. L-idea hija li tittratta kapaċità bħala unità waħda—l-istruzzjonijiet tagħha, l-għodod tagħha, id-data ta’ referenza tagħha—u ssejħilha b’isemha minflok ma terġa’ tiktebha.

Il-benefiċċju mhux biss li tevita r-ripetizzjoni. Kapaċità msemmija ssir oġġett li tista’ tagħmlilha verżjoni ġdida, tittestjah, u tgħaddih lil xi ħadd ieħor. Meta avukat jgħidlek li klawsola standard inbidlet, timmodifika ħila waħda u kull sejħa tibbenefika—minflok ma tfittex fejn ġie dduplikat il-prompt.

Il-Kunċett tal-Ħila

Ħila tinkapsula kull ma mudell jeħtieġ biex iwettaq kompitu speċifiku. It-tliet elementi hawn taħt mhumiex interkambjabbli: l-istruzzjonijiet jiddefinixxu r-rwol u l-format, l-għodod jiddeterminaw x’jista’ jiġbed il-mudell, u l-kuntest jgħaqqad ir-risposti mar-referenzi tiegħek stess minflok il-għarfien ġenerali tal-mudell.

  • Istruzzjonijiet: Il-prompt speċjalizzat tas-sistema
  • Għodod: Il-funzjonijiet u l-għodod integrati meħtieġa
  • Kuntest: Data ta’ referenza u eżempji
from openai import OpenAI

client = OpenAI()

# Define a financial analysis skill
skill_analyse_financiere = {
    "instructions": (
        "You are a financial analyst specializing in French SMEs. "
        "You analyze accounting documents and produce structured reports "
        "with key indicators, trends, and recommendations. "
        "Use French accounting standards (PCG). "
        "Format amounts in euros with thousands separators."
    ),
    "tools": [
        {"type": "file_search", "vector_store_ids": ["vs_normes_comptables"]},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
}

# Use the skill
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=skill_analyse_financiere["instructions"],
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Analyze this balance sheet and produce a report"},
            {"type": "input_file", "file_id": fichier_bilan.id}
        ]
    }],
    tools=skill_analyse_financiere["tools"]
)

L-Istrutturar ta’ Librerija tal-Ħiliet

Li tmur minn dizzjunarju għal klassi mhix biss kosmetika: tippermettilek mehmuż eżempji ma’ ħila u tinjettahom b’mod sistematiku. Żewġ jew tliet pari ta’ input/output magħżula sew jagħmlu aktar għall-konsistenza tal-format milli paragrafu addizzjonali ta’ istruzzjonijiet, għax juru minflok ma jiddeskrivu. L-implimentazzjoni hawn taħt tgħaqqadhom mal-istruzzjonijiet f’kull sejħa.

class Skill:
    def __init__(self, nom: str, instructions: str, tools: list, exemples: list = None):
        self.nom = nom
        self.instructions = instructions
        self.tools = tools
        self.exemples = exemples or []

    def executer(self, client: OpenAI, requete: str, fichiers: list = None) -> str:
        content = [{"type": "input_text", "text": requete}]
        if fichiers:
            for fid in fichiers:
                content.append({"type": "input_file", "file_id": fid})

        # Add examples to context
        instructions = self.instructions
        if self.exemples:
            instructions += "\n\nReference examples:\n"
            for ex in self.exemples:
                instructions += f"- Input: {ex['input']}\n  Output: {ex['output']}\n"

        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions=instructions,
            input=[{"role": "user", "content": content}],
            tools=self.tools
        )
        return response.output_text


# Define skills
skill_redaction_contrat = Skill(
    nom="redaction-contrat",
    instructions=(
        "You are a lawyer specializing in contract law. "
        "You draft clear, precise clauses compliant with French law. "
        "Each clause must be numbered and structured."
    ),
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_modeles_contrats"]},
        {"type": "web_search"}
    ],
    exemples=[
        {
            "input": "Confidentiality clause for a contractor",
            "output": "Article X - Confidentiality\nX.1 The Contractor undertakes..."
        }
    ]
)

skill_support_technique = Skill(
    nom="support-technique",
    instructions=(
        "You are a level 2 technical support agent. "
        "You diagnose problems by asking targeted questions. "
        "Search the knowledge base first before proposing solutions. "
        "Document every resolution."
    ),
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_base_connaissances"]},
        {
            "type": "function",
            "name": "creer_ticket_escalade",
            "description": "Escalate an issue to level 3",
            "parameters": {
                "type": "object",
                "properties": {
                    "titre": {"type": "string"},
                    "description": {"type": "string"},
                    "priorite": {"type": "string", "enum": ["basse", "moyenne", "haute", "critique"]}
                },
                "required": ["titre", "description", "priorite"],
                "additionalProperties": False
            },
            "strict": True
        }
    ]
)

Il-Kompożizzjoni tal-Ħiliet

Il-kompożizzjoni tgħaqqad il-ħiliet billi tgħaddi r-riżultat ta’ waħda bħala kuntest għall-oħra. Din hija qawwija, u eżattament hawnhekk tibda l-problema, għal raġuni speċifika: f’kull pass, il-kuntest trażmess huwa l-output tal-pass preċedenti, mhux id-data oriġinali. Kwalunkwe informazzjoni li l-ewwel ħila qieset bħala sekondarja tisparixxi għal dawk kollha li jmiss.

Żewġ konsegwenzi prattiċi. Ippjana l-passi mill-aktar ġenerali għall-aktar speċifiċi, sabiex il-filtrar iseħħ l-aktar tard possibbli. U meta pass sussegwenti jeħtieġ data mhux ipproċessata, għaddi l-fajls mill-ġdid minflok ma tiddependi fuq is-sommarju—dan huwa eżattament dak li jagħmel il-parametru fichiers fl-eżempju, li jiġi mgħoddi biss lill-ewwel pass iżda għandu jiġi mgħoddi lil dawk kollha li jiddependu fuqu.

class SkillComposee:
    def __init__(self, nom: str, etapes: list[dict]):
        self.nom = nom
        self.etapes = etapes
        self.client = OpenAI()

    def executer(self, requete_initiale: str, fichiers: list = None) -> dict:
        contexte = requete_initiale
        resultats = {}

        for etape in self.etapes:
            skill = etape["skill"]
            instruction_etape = etape.get("instruction", "")
            prompt = f"{instruction_etape}\n\nPrevious context: {contexte}"

            resultat = skill.executer(self.client, prompt, fichiers)
            resultats[etape["nom"]] = resultat
            contexte = resultat
            fichiers = None  # Files used only at the first step

        return resultats


# Workflow: contract analysis followed by summary drafting
workflow_audit_contrat = SkillComposee(
    nom="audit-contrat",
    etapes=[
        {
            "nom": "analyse",
            "skill": skill_analyse_financiere,
            "instruction": "Analyze the financial aspects of this contract"
        },
        {
            "nom": "juridique",
            "skill": skill_redaction_contrat,
            "instruction": "Identify legal risks and propose improvements"
        }
    ]
)

Ħiliet b’Istat (Stateful)

Ħila li tiftakar is-sejħiet preċedenti tagħha tippermetti konversazzjonijiet twal—dijanjosi teknika, negozjazzjoni, traċċar ta’ każijiet. Dan jintroduċi wkoll l-uniku kost li jikber mingħajr ma tinduna: f’kull dawra, l-istorja kollha tintbagħat mill-ġdid u tiġi fatturata mill-ġdid. Ippjana politika ta’ trankazzjoni jew ta’ sommarju perjodiku mill-bidu, inkella l-għoxrin mistoqsija se tkollha kost għaxar darbiet akbar mill-ewwel għal kwalità li ma tjibitx għaxar darbiet.

class SkillAvecEtat:
    def __init__(self, skill: Skill):
        self.skill = skill
        self.client = OpenAI()
        self.historique = []
        self.contexte_accumule = ""

    def appeler(self, requete: str, fichiers: list = None) -> str:
        # Build prompt with history
        instructions = self.skill.instructions
        if self.contexte_accumule:
            instructions += f"\n\nContext from previous interactions:\n{self.contexte_accumule}"

        content = [{"type": "input_text", "text": requete}]
        if fichiers:
            for fid in fichiers:
                content.append({"type": "input_file", "file_id": fid})

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            instructions=instructions,
            input=[{"role": "user", "content": content}],
            tools=self.skill.tools
        )

        resultat = response.output_text
        self.historique.append({"requête": requete, "reponse": resultat})
        self.contexte_accumule += f"\n- {requete} -> {resultat[:200]}..."

        return resultat

# Usage: technical support with conversation tracking
session = SkillAvecEtat(skill_support_technique)
r1 = session.appeler("My application crashes at startup")
r2 = session.appeler("I have version 3.2.1 on Ubuntu 24.04")
r3 = session.appeler("The log shows a database connection error")

Reġistru tal-Ħiliet

Iċċentralizza l-ġestjoni tal-ħiliet tiegħek:

class RegistreSkills:
    def __init__(self):
        self.skills = {}

    def enregistrer(self, skill: Skill):
        self.skills[skill.nom] = skill

    def obtenir(self, nom: str) -> Skill:
        if nom not in self.skills:
            raise KeyError(f"Skill '{nom}' not found. "
                          f"Available: {list(self.skills.keys())}")
        return self.skills[nom]

    def lister(self) -> list[str]:
        return list(self.skills.keys())

# Global registry
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

# Usage
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")

Punti Ewlenin

  • Ħila tinkapsula istruzzjonijiet, għodod u kuntest f’pakkett li jista’ jerġa’ jintuża
  • Agħmel kompożizzjoni tal-ħiliet għal flussi ta’ xogħol b’diversi passi
  • Uża l-istat għal ħiliet konversazzjonali
  • Iċċentralizza l-ħiliet tiegħek f’reġistru biex tissimplifika s-sejbien
  • L-eżempji fl-istruzzjonijiet itejbu l-preċiżjoni tal-mudell