Færdigheder: Indkapsling af funktioner
På denne side
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 typeninput_text, og websøgning bruger værktøjetweb_search(web_search_previewer nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionernefichiers_generesogtelechargerfra 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