Kompetence: Zajemanje zmožnosti
Na tej strani
Lekcija posodobljena 2. novembra 2026 na podlagi dokumentacije OpenAI: orodje Code Interpreter zdaj zahteva parameter
container(dodan vsem primerom), deli besedilnega vnosa so tipainput_text, spletno iskanje pa uporablja orodjeweb_search(web_search_previewje zdaj zastarelo orodje brez filtrov domen). Ustvarjene datoteke se pridobijo s funkcijamafichiers_generesintelechargeriz lekcije 10. Viri: Code Interpreter · Spletno iskanje.
Kompetence: Zajemanje zmožnosti
Kompetenca rešuje težavo, na katero naletiš že v drugem tednu: isti sistemski poziv, kopiran v štiri datoteke, ki se začnejo razhajati takoj, ko izboljšaš le eno od njih. Ideja je obravnavati zmožnost kot enotno celoto – njena navodila, orodja in referenčni podatki – ter jo klicati po imenu, namesto da bi jo prepisoval.
Prednost ni le izogibanje ponavljanju. Poimenovana zmožnost postane predmet, ki ga lahko verzioniraš, testiraš in predash drugemu. Ko ti odvetnik pove, da se je standardna klavzula spremenila, spremeniš eno kompetenco in vsak klic ima od tega korist – namesto da bi lovil, kje vse je bil poziv podvojen.
Koncept kompetence
Kompetenca zajema vse, kar model potrebuje za opravljanje določene naloge. Trije spodnji elementi niso zamenljivi: navodila opredeljujejo vlogo in format, orodja določajo, kaj lahko model pridobi, kontekst pa sidra odgovore v tvojih referencah in ne v splošnem znanju modela.
- Navodila: Specializirani sistemski poziv
- Orodja: Potrebne vgrajene funkcije in orodja
- Kontekst: Referenčni podatki in primeri
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"]
)
Strukturiranje knjižnice kompetenc
Prehod iz slovarja na razred ni le kozmetičen: omogoča ti, da h kompetenci pripneš primere in jih sistematično vstaviš. Dva ali trije dobro izbrani pari vhod/izhod naredijo več za doslednost formatiranja kot dodaten odstavek navodil, ker kažejo namesto opisovanja. Spodnja implementacija jih ob vsakem klicu združi z navodili.
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
}
]
)
Sestavljanje kompetenc
Sestavljanje povezuje kompetence tako, da rezultat ene posreduje kot kontekst naslednji. To je močno, a prav tu se začnejo težave iz specifičnega razloga: v vsakem koraku je posredovani kontekst izhod prejšnjega koraka, ne izvirnih podatkov. Vsaka informacija, ki jo je prva kompetenca štela za drugotno, za vse naslednje izgine.
Dve praktični posledici. Korake razporedi od najbolj splošnih k najbolj specifičnim, da se filtriranje zgodi čim pozneje. In ko spodnji korak potrebuje surove podatke, ponovno posreduj datoteke, namesto da bi se zanašal na povzetek – točno to počne parameter fichiers v primeru, ki se posreduje le prvemu koraku, posredovati pa bi ga bilo treba vsem, ki so od njega odvisni.
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"
}
]
)
Kompetence s stanjem
Kompetenca, ki si zapomni svoje prejšnje klice, omogoča dolge pogovore – tehnično diagnostiko, pogajanja, sledenje primerom. Vendar uvaja tudi edini strošek, ki neopazno narašča: ob vsakem obratu se celotna zgodovina ponovno pošlje in zaračuna. Že na začetku načrtuj politiko obrezovanja ali periodičnega povzemanja, sicer bo dvajseto vprašanje stalo desetkrat več kot prvo, kakovost pa se ne bo desetkrat izboljšala.
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")
Register kompetenc
Centraliziraj upravljanje svojih kompetenc:
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")
Ključne ugotovitve
- Kompetenca zajema navodila, orodja in kontekst v ponovno uporabnem paketu
- Sestavljaj kompetence za večstopenjske delovne tokove
- Uporabi stanje za konverzacijske kompetence
- Centraliziraj svoje kompetence v registru za poenostavitev odkrivanja
- Primeri v navodilih izboljšajo natančnost modela