Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Færdigheder: Indkapsling af funktioner

Lektion 17 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Færdigheder: Indkapsling af funktioner
  2. Konceptet bag færdigheder
  3. Strukturering af et færdighedsbibliotek
  4. Sammensætning af færdigheder
  5. Færdigheder med tilstand (Stateful)
  6. Færdighedsregister
  7. Vigtige pointer

Lektion opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en container-parameter (tilføjet til alle eksempler), tekstinput-dele er af typen input_text, og websøgning bruger værktøjet web_search (web_search_preview er nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionerne fichiers_generes og telecharger fra lektion 10. Kilder: Code Interpreter · Websøgning.

Færdigheder: Indkapsling af funktioner

En færdighed (Skill) løser et problem, som alle støder på inden for de første to uger: den samme system-prompt kopieres ind i fire forskellige filer og begynder at afvige fra hinanden, så snart du forbedrer blot én af dem. Ideen er at behandle en funktion som en enkelt enhed – dens instrukser, dens værktøjer, dens referencedata – og kalde den ved navn i stedet for at omskrive den hver gang.

Fordelen er ikke blot at undgå gentagelser. En navngiven funktion bliver til et objekt, du kan versionere, teste og overdrage til andre. Når en advokat fortæller dig, at en standardklausul er ændret, modificerer du én færdighed, og alle kald drager fordel af det – i stedet for at skulle lede efter alle de steder, hvor prompten var duplikeret.

Konceptet bag færdigheder

En færdighed indkapsler alt, hvad en model har brug for for at udføre en specifik opgave. De tre elementer nedenfor er ikke udskiftelige: Instrukser definerer rollen og formatet, værktøjer bestemmer, hvad modellen kan hente, og kontekst forankrer svar i dine egne referencer frem for modellens generelle viden.

  • Instrukser: Den specialiserede system-prompt
  • Værktøjer: De nødvendige indbyggede funktioner og værktøjer
  • Kontekst: Referencedata og eksempler
from openai import OpenAI

client = OpenAI()

# Definer en færdighed til finansiel analyse
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"}}
    ]
}

# Brug færdigheden
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"]
)

Strukturering af et færdighedsbibliotek

At gå fra et dictionary til en klasse er ikke blot kosmetisk: Det giver dig mulighed for at knytte eksempler til en færdighed og injicere dem systematisk. To eller tre velvalgte input/output-par gør mere for formatkonsistens end et ekstra afsnit med instrukser, fordi de viser frem for at beskrive. Implementeringen nedenfor sammenkæder dem med instrukserne ved hvert kald.

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})

        # Tilføj eksempler til konteksten
        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


# Definer færdigheder
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
        }
    ]
)

Sammensætning af færdigheder

Sammensætning kæder færdigheder sammen ved at sende resultatet fra den ene som kontekst til den næste. Det er kraftfuldt, og det er præcis her, problemerne starter af en specifik årsag: Ved hvert trin er den overførte kontekst outputtet fra det foregående trin, ikke de oprindelige data. Alle oplysninger, som den første færdighed anså for sekundære, forsvinder for alle efterfølgende trin.

To praktiske konsekvenser. Arrinér trinene fra det mest generelle til det mest specifikke, så filtrering sker så sent som muligt. Og når et downstream-trin har brug for rådata, skal du sende filerne igen i stedet for at stole på sammendraget – det er præcis, hvad parameteren fichiers i eksemplet gør, som kun sendes til det første trin, men bør sendes til alle, der afhænger af det.

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  # Filer bruges kun ved første trin

        return resultats


# Workflow: Kontraktanalyse efterfulgt af udarbejdelse af sammendrag
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"
        }
    ]
)

Færdigheder med tilstand (Stateful)

En færdighed, der husker sine tidligere kald, muliggør lange samtaler – en teknisk diagnose, en forhandling, sagsopfølgning. Det introducerer dog også den eneste omkostning, der vokser ubemærket: Ved hver omgang sendes hele historikken igen og refaktureres. Planlæg en politik for trunkering eller periodisk sammendrag fra starten, ellers vil det tyvende spørgsmål koste ti gange så meget som det første for en kvalitet, der ikke er blevet ti gange bedre.

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:
        # Byg prompt med historik
        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

# Brug: Teknisk support med samtaleopfølgning
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")

Færdighedsregister

Centralisér din styring af færdigheder:

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())

# Globalt register
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

# Brug
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")

Vigtige pointer

  • En færdighed indkapsler instrukser, værktøjer og kontekst i en genanvendelig pakke
  • Sammensæt færdigheder til arbejdsgange med flere trin
  • Brug tilstand (state) til samtalebaserede færdigheder
  • Centralisér dine færdigheder i et register for at forenkle opdagelse
  • Eksempler i instrukser forbedrer modellens nøjagtighed