Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Zručnosti: Zapuzdrenie schopností

Lekcia 17 z 20 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Zručnosti: Zapuzdrenie schopností
  2. Koncept zručnosti
  3. Štruktúrovanie knižnice zručností
  4. Skladanie zručností
  5. Zručnosti so stavom
  6. Register zručností
  7. Kľúčové poznatky

Lekcia aktualizovaná 2. novembra 2026 na základe dokumentácie OpenAI: nástroj Code Interpreter teraz vyžaduje parameter container (pridaný do všetkých príkladov), časti textového vstupu sú typu input_text a webové vyhľadávanie používa nástroj web_search (web_search_preview je teraz zastaraný nástroj bez filtrov domén). Vygenerované súbory sa získavajú pomocou funkcií fichiers_generes a telecharger z Lekcie 10. Zdroje: Code Interpreter · Web search.

Zručnosti: Zapuzdrenie schopností

Zručnosť (Skill) rieši problém, na ktorý narazíš do dvoch týždňov: ten istý systémový prompt skopírovaný do štyroch súborov, ktoré sa začnú líšiť hneď, ako vylepšíš len jeden z nich. Myšlienkou je zaobchádzať so schopnosťou ako s jednou jednotkou – jej inštrukciami, nástrojmi a referenčnými údajmi – a volať ju podľa názvu, namiesto toho, aby si ju prepisoval.

Výhodou nie je len vyhnutie sa opakovaniu. Pomenovaná schopnosť sa stáva objektom, ktorý môžeš verzionovať, testovať a odovzdať niekomu inému. Keď ti právnik povie, že sa zmenila štandardná klauzula, upravíš jednu zručnosť a benefitujú z toho všetky volania – namiesto toho, aby si hľadal, kde bol prompt duplikovaný.

Koncept zručnosti

Zručnosť zapuzdruje všetko, čo model potrebuje na vykonanie konkrétnej úlohy. Tri nižšie uvedené prvky nie sú zameniteľné: inštrukcie definujú rolu a formát, nástroje určujú, čo môže model získať, a kontext ukotvuje odpovede vo vašich vlastných referenciách, namiesto všeobecných vedomostí modelu.

  • Inštrukcie: Špecializovaný systémový prompt
  • Nástroje: Potrebné vstavané funkcie a nástroje
  • Kontext: Referenčné údaje a príklady
from openai import OpenAI

client = OpenAI()

# Definícia zručnosti pre finančnú analýzu
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"}}
    ]
}

# Použitie zručnosti
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"]
)

Štruktúrovanie knižnice zručností

Prechod od slovníka k triede nie je len kozmetický: umožňuje ti pripojiť k zručnosti príklady a systematicky ich vkladať. Dva alebo tri dobre zvolené páry vstup/výstup urobia pre konzistenciu formátu viac ako extra odsek inštrukcií, pretože ukazujú, namiesto toho, aby opisovali. Nižšie uvedená implementácia ich pri každom volaní pripája k inštrukciám.

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

        # Pridanie príkladov do kontextu
        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


# Definícia zručností
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
        }
    ]
)

Skladanie zručností

Skladanie (Composition) reťazí zručnosti tak, že výsledok jednej odovzdáva ako kontext ďalšej. Je to mocné a presne tu začínajú problémy, a to z konkrétneho dôvodu: v každom kroku je prenášaným kontextom výstup predchádzajúceho kroku, nie pôvodné dáta. Akékoľvek informácie, ktoré prvá zručnosť považovala za vedľajšie, zmiznú pre všetky nasledujúce.

Dva praktické dôsledky. Usporiadaj kroky od najvšeobecnejších po najšpecifickejšie, aby k filtrovaniu dochádzalo čo najneskôr. A keď downstreamový krok potrebuje surové dáta, odovzdaj súbory znova, namiesto spoliehania sa na súhrn – presne to robí parameter fichiers v príklade, ktorý sa odovzdáva len prvému kroku, ale mal by sa odovzdať všetkým, ktoré na ňom závisia.

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  # Súbory použité len v prvom kroku

        return resultats


# Pracovný postup: analýza zmluvy nasledovaná vytvorením súhrnu
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"
        }
    ]
)

Zručnosti so stavom

Zručnosť, ktorá si pamätá svoje predchádzajúce volania, umožňuje dlhé konverzácie – technickú diagnostiku, vyjednávanie, sledovanie prípadov. Zavádza však aj jediné náklady, ktoré rastú nepozorovane: pri každom kole sa celá história znova odosiela a účtuje. Naplánuj si politiku orezávania alebo pravidelného sumarizovania hneď od začiatku, inak bude dvadsiata otázka stáť desaťkrát viac ako prvá, pričom kvalita sa nezlepší desaťnásobne.

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:
        # Vytvorenie promptu s históriou
        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

# Použitie: technická podpora so sledovaním konverzácie
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")

Register zručností

Centralizuj správu svojich zručností:

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

# Globálny register
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

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

Kľúčové poznatky

  • Zručnosť zapuzdruje inštrukcie, nástroje a kontext do opakovane použiteľného balíka
  • Skladaj zručnosti pre viacstupňové pracovné postupy
  • Používaj stav pre konverzačné zručnosti
  • Centralizuj svoje zručnosti v registri pre zjednodušenie objavovania
  • Príklady v inštrukciách zlepšujú presnosť modelu