Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Skills: Capaciteiten encapsuleren

Les 17 van 20 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Skills: Capaciteiten encapsuleren
  2. Het Skill-concept
  3. Een Skill-bibliotheek structureren
  4. Skills combineren
  5. Stateful Skills
  6. Skill-register
  7. Belangrijkste punten

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 type input_text, en webzoekopdrachten gebruiken de web_search-tool (web_search_preview is nu een verouderde tool zonder domeinfilters). Gegenereerde bestanden worden opgehaald met de functies fichiers_generes en telecharger uit 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