Zručnosti: Zapuzdrenie schopností
Na tejto strane
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ú typuinput_texta webové vyhľadávanie používa nástrojweb_search(web_search_previewje teraz zastaraný nástroj bez filtrov domén). Vygenerované súbory sa získavajú pomocou funkciífichiers_generesatelechargerz 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