Oskused: Võimete kapseldamine
Sellel lehel
Tund uuendatud 2. novembril 2026 OpenAI dokumentatsiooni põhjal: Code Interpreteri tööriist nõuab nüüd parameetrit
container(lisatud kõigile näidetele), tekstisisendi osad on tüüpiinput_textja veebiotsing kasutab tööriistaweb_search(web_search_previewon nüüd aegunud tööriist ilma domeenifiltriteta). Genereeritud failid laaditakse alla, kasutades 10. tunni funktsioonefichiers_generesjatelecharger. Allikad: Code Interpreter · Veebiotsing.
Oskused: Võimete kapseldamine
Oskus lahendab probleemi, millega puutud kokku juba teisel nädalal: sama süsteemne viip kopeeritakse nelja faili, mis hakkavad lahknenema niipea, kui täiustad vaid ühte neist. Idee on käsitleda võimet kui terviklikku üksust – selle juhised, tööriistad ja võrdlusandmed – ning kutsuda seda nime järgi, selle asemel et seda ümber kirjutada.
Kasu ei seisne ainult korduste vältimises. Nimega võimest saab objekt, mida saad versioneerida, testida ja teisele üle anda. Kui jurist ütleb, et standardne klausel on muutunud, muudad ühte oskust ja sellest võidavad kõik väljakutsed, selle asemel et otsida, kuhu viip oli dubleeritud.
Oskuse kontseptsioon
Oskus kapseldab kõik, mida mudel vajab konkreetse ülesande täitmiseks. Allpool toodud kolm elementi ei ole omavahel asendatavad: juhised määratlevad rolli ja vormingu, tööriistad määravad, mida mudel saab hankida, ja kontekst ankrurdab vastused sinu enda allikatesse, mitte mudeli üldteadmistesse.
- Juhised: Spetsialiseeritud süsteemne viip
- Tööriistad: Vajalikud sisseehitatud funktsioonid ja tööriistad
- Kontekst: Võrdlusandmed ja näited
from openai import OpenAI
client = OpenAI()
# Defineeri finantsanalüüsi oskus
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"}}
]
}
# Kasuta oskust
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"]
)
Oskusteegi struktureerimine
Sõnastikult klassile üleminek ei ole pelgalt kosmeetiline: see võimaldab oskusele lisada näiteid ja neid süstemaatiliselt sisestada. Kaks või kolm hästi valitud sisendi/väljundi paari teevad vormingu järjepidevuse jaoks rohkem kui üks täiendav lõik juhiseid, sest need näitavad, mitte ei kirjelda. Allpool toodud teostus liidab need iga väljakutse korral juhistega.
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})
# Lisa näited konteksti
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
# Määratle oskused
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
}
]
)
Oskuste komponeerimine
Kompositsioon aheldab oskusi, edastades ühe tulemuse järgmisele kontekstina. See on võimas, ja just siin tekivadki probleemid ühel kindlal põhjusel: igas etapis edastatav kontekst on eelmise etapi väljund, mitte algne andmestik. Kogu teave, mille esimene oskus pidas teisejärguliseks, kaob kõigi järgnevate jaoks.
Sellel on kaks praktilist tagajärge. Järjesta sammud kõige üldisemast kõige spetsiifilisemani, et filtreerimine toimuks võimalikult hilja. Ja kui allavoolu asuv samm vajab toorandmeid, edasta failid uuesti, selle asemel et tugineda kokkuvõttele – just seda teeb näites parameeter fichiers, mis antakse edasi ainult esimesele sammule, kuid tuleks edastada kõigile, kes sellest sõltuvad.
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 # Faile kasutatakse ainult esimeses sammus
return resultats
# Töövoog: lepingu analüüs, millele järgneb kokkuvõtte koostamine
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"
}
]
)
Olekuga oskused
Oskus, mis mäletab oma eelmisi väljakutseid, võimaldab pikki vestlusi – tehniline diagnostika, läbirääkimised, juhtumi jälgimine. See toob aga kaasa ainsa kuluelemendi, mis kasvab märkamatult: igas voorus saadetakse kogu ajalugu uuesti ja seda arvestatakse uuesti. Planeeri algusest peale kärpimis- või perioodilise kokkuvõtmise poliitika, vastasel juhul maksab kahekümnes küsimus esimesest kümme korda rohkem, kuigi kvaliteet pole kümnekordistunud.
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:
# Koosta viip koos ajalooga
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
# Kasutus: tehniline tugi vestluse jälgimisega
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")
Oskuste register
Tsentraliseeri oma oskuste haldamine:
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())
# Globaalne register
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)
# Kasutus
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")
Peamised punktid
- Oskus kapseldab juhised, tööriistad ja konteksti taaskasutatavasse paketti
- Komponeeri oskusi mitmeastmeliste töövoogude jaoks
- Kasuta vestlusoskuste puhul olekut
- Tsentraliseeri oma oskused registrisse, et lihtsustada nende leidmist
- Näited juhistes parandavad mudeli täpsust