Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Įgūdžiai: gebėjimų inkapsuliavimas

Paskaita 17 iš 20 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Įgūdžiai: gebėjimų inkapsuliavimas
  2. Įgūdžio samprata
  3. Įgūdžių bibliotekos struktūravimas
  4. Įgūdžių komponavimas
  5. Įgūdžiai su būsena
  6. Įgūdžių registras
  7. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 2 d. pagal „OpenAI“ dokumentaciją: „Code Interpreter“ įrankiui dabar reikia container parametro (pridėta visuose pavyzdžiuose), teksto įvesties dalys yra input_text tipo, o žiniatinklio paieška naudoja web_search įrankį (web_search_preview dabar yra pasenusi priemonė be domenų filtrų). Sugeneruoti failai gaunami naudojant fichiers_generes ir telecharger funkcijas iš 10 pamokos. Šaltiniai: Code Interpreter · Web search.

Įgūdžiai: gebėjimų inkapsuliavimas

Įgūdis (Skill) išsprendžia problemą, su kuria susiduriama jau antrąją savaitę: tas pats sistemos prompt’as nukopijuojamas į keturis failus ir pradeda skirtis vos tik patobulinus vieną iš jų. Idėja yra traktuoti gebėjimą kaip vieną vienetą – jo instrukcijas, įrankius ir referencinius duomenis – bei jį iškviesti pagal pavadinimą, užuot jį iš naujo rašius.

Nauda nėra tik pasikartojimo vengimas. Pavadintas gebėjimas tampa objektu, kurį galima versijuoti, testuoti ir perduoti kitam. Kai teisininkas praneša, kad standartinė sąlyga pasikeitė, pakeiti vieną įgūdį ir naudą gauna visi jo kvietimai – užuot ieškojus, kur prompt’as buvo dubliuotas.

Įgūdžio samprata

Įgūdis inkapsuliuoja viską, ko modeliui reikia konkrečiai užduočiai atlikti. Toliau išvardyti trys elementai nėra keičiami vietomis: instrukcijos apibrėžia vaidmenį ir formatą, įrankiai nulemia, ką modelis gali gauti, o kontekstas įtvirtina atsakymus tavo referenciniuose duomenyse, o ne bendrose modelio žiniose.

  • Instrukcijos: Specializuotas sistemos prompt’as
  • Įrankiai: Būtinos integruotos funkcijos ir įrankiai
  • Kontekstas: Referenciniai duomenys ir pavyzdžiai
from openai import OpenAI

client = OpenAI()

# Apibrėžti finansinės analizės įgūdį
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"}}
    ]
}

# Naudoti įgūdį
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"]
)

Įgūdžių bibliotekos struktūravimas

Perėjimas nuo žodyno prie klasės nėra tik kosmetinis pakeitimas: tai leidžia prie įgūdžio pridėti pavyzdžių ir juos sistemingai įterpti. Du ar trys gerai parinkti įvesties/išvesties porų pavyzdžiai formatui suderinti daro daugiau nei papildomas instrukcijų pastraipa, nes jie rodo, o ne aprašo. Toliau pateiktas įgyvendinimas juos kiekvieno kvietimo metu sujungia su instrukcijomis.

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})

        # Pridėti pavyzdžius prie konteksto
        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


# Apibrėžti įgūdžius
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
        }
    ]
)

Įgūdžių komponavimas

Komponavimas grandine sujungia įgūdžius, perduodant vieno rezultatą kaip kontekstą kitam. Tai galinga, ir būtent čia prasideda bėdos dėl specifinės priežasties: kiekviename žingsnyje perduodamas kontekstas yra ankstesnio žingsnio išvestis, o ne pirminiai duomenys. Bet kokia informacija, kurią pirmasis įgūdis laikė antraeile, visiems vėlesniems išnyksta.

Dvi praktinės pasekmės. Žingsnius išdėstyk nuo bendriausio iki specifiniausio, kad filtravimas vyktų kuo vėliau. Kai tolesniam žingsniui reikia neapdorotų duomenų, failus perduok iš naujo, užuot pasikliaujęs santrauka – būtent tai daro fichiers parametras pavyzdyje, kuris perduodamas tik pirmajam žingsniui, bet turėtų būti perduodamas visiems, kurie nuo jo priklauso.

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  # Failai naudojami tik pirmajame žingsnyje

        return resultats


# Darbo eiga: sutarties analizė, po to santraukos rengimas
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"
        }
    ]
)

Įgūdžiai su būsena

Įgūdis, prisimenantis ankstesnius kvietimus, leidžia vesti ilgas pokalbių sesijas – techninę diagnostiką, derybas, bylų stebėseną. Tačiau tai įveda vienintelę kainą, kuri auga nepastebimai: kiekviename etape visa istorija išsiunčiama iš naujo ir apmokestinama. Nuo pat pradžių numatyk apipjaustymo arba periodinio santraukų kūrimo politiką, kitaip dvidešimtasis klausimas kainuos dešimt kartų daugiau nei pirmasis, nors kokybė nepagerės dešimt kartų.

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:
        # Sukurti prompt'ą su istorija
        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

# Naudojimas: techninė pagalba stebint pokalbį
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")

Įgūdžių registras

Centralizuok savo įgūdžių valdymą:

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())

# Globalus registras
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

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

Svarbiausi punktai

  • Įgūdis inkapsuliuoja instrukcijas, įrankius ir kontekstą pakartotinai naudojamame pakete
  • Komponuok įgūdžius daugiapakopėms darbo eigoms
  • Pokalbių įgūdžiams naudok būseną
  • Centralizuok savo įgūdžius registre, kad supaprastintum jų radimą
  • Pavyzdžiai instrukcijose pagerina modelio tikslumą