Skills: Capaciteiten encapsuleren
Op deze pagina
Les bijgewerkt op 2 november 2026 op basis van OpenAI-documentatie: de Code Interpreter-tool vereist nu een
container-parameter (toegevoegd aan alle voorbeelden), tekstinputonderdelen zijn van het typeinput_text, en webzoekopdrachten gebruiken deweb_search-tool (web_search_previewis nu een verouderde tool zonder domeinfilters). Gegenereerde bestanden worden opgehaald met de functiesfichiers_generesentelechargeruit Les 10. Bronnen: Code Interpreter · Web search.
Skills: Capaciteiten encapsuleren
Een Skill lost een probleem op waar iedereen in week twee mee te maken krijgt: dezelfde systeemprompt die in vier bestanden is gekopieerd en uit elkaar loopt zodra u er slechts één verbetert. Het idee is om een capaciteit als één geheel te behandelen—de instructies, de tools en de referentiedata—en deze bij naam aan te roepen in plaats van ze opnieuw te schrijven.
Het voordeel is niet alleen het vermijden van herhaling. Een benoemde capaciteit wordt een object dat u kunt versiebeheren, testen en aan iemand anders kunt overdragen. Wanneer een advocaat u vertelt dat een standaardclausule is gewijzigd, past u één skill aan en profiteren alle aanroepen daarvan—in plaats dat u moet zoeken waar de prompt is gedupliceerd.
Het Skill-concept
Een Skill encapsuleert alles wat een model nodig heeft om een specifieke taak uit te voeren. De drie onderstaande elementen zijn niet uitwisselbaar: instructies definiëren de rol en het formaat, tools bepalen wat het model kan ophalen, en context verankert antwoorden in uw eigen referenties in plaats van in de algemene kennis van het model.
- Instructies: De gespecialiseerde systeemprompt
- Tools: De noodzakelijke ingebouwde functies en tools
- Context: Referentiedata en voorbeelden
from openai import OpenAI
client = OpenAI()
# Definieer een financiële analyseskill
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"}}
]
}
# Gebruik de 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"]
)
Een Skill-bibliotheek structureren
De overstap van een dictionary naar een klasse is niet louter cosmetisch: het stelt u in staat om voorbeelden aan een skill te koppelen en deze systematisch injecteren. Twee of drie goed gekozen input/output-paren doen meer voor de consistentie van het formaat dan een extra paragraaf met instructies, omdat ze laten zien in plaats van beschrijven. De onderstaande implementatie voegt ze bij elke aanroep samen met de instructies.
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})
# Voorbeelden toevoegen aan de 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
# Skills definiëren
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
}
]
)
Skills combineren
Compositie ketent skills aan elkaar door het resultaat van de ene als context aan de volgende door te geven. Dit is krachtig, en dat is precies waar de problemen beginnen, om een specifieke reden: bij elke stap is de doorgegeven context de output van de vorige stap, niet de oorspronkelijke data. Alle informatie die de eerste skill als secundair beschouwde, verdwijnt voor alle daaropvolgende stappen.
Twee praktische gevolgen. Orden de stappen van algemeen naar specifiek, zodat filteren zo laat mogelijk plaatsvindt. En wanneer een downstream-stap ruwe data nodig heeft, geef de bestanden dan opnieuw door in plaats van te vertrouwen op de samenvatting—dat is precies wat de parameter fichiers in het voorbeeld doet, die alleen aan de eerste stap wordt doorgegeven maar aan alle stappen moet worden doorgegeven die ervan afhankelijk zijn.
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 # Bestanden alleen gebruikt in de eerste stap
return resultats
# Workflow: contractanalyse gevolgd door het opstellen van een samenvatting
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"
}
]
)
Stateful Skills
Een skill die eerdere aanroepen onthoudt, maakt lange gesprekken mogelijk—een technische diagnose, een onderhandeling, casusbeheer. Het introduceert echter ook de enige kostenpost die ongemerkt groeit: bij elke beurt wordt de volledige geschiedenis opnieuw verzonden en gefactureerd. Plan vanaf het begin een beleid voor truncatie of periodieke samenvatting, anders kost de twintigste vraag tien keer zoveel als de eerste voor een kwaliteit die niet tien keer zo goed is geworden.
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:
# Prompt opbouwen met geschiedenis
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
# Gebruik: technische ondersteuning met conversatievolging
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")
Skill-register
Centraliseer uw skill-beheer:
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())
# Globaal register
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)
# Gebruik
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")
Belangrijkste punten
- Een Skill encapsuleert instructies, tools en context in een herbruikbaar pakket
- Combineer skills voor workflows met meerdere stappen
- Gebruik state voor conversationele skills
- Centraliseer uw skills in een register om ontdekking te vereenvoudigen
- Voorbeelden in instructies verbeteren de nauwkeurigheid van het model