Compétences : encapsuler des capacités
Pe această pagină
Leçon mise à jour le 2 novembre 2026 sur la base de la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre
container(ajouté à tous les exemples), les parties de saisie texte sont de typeinput_text, et la recherche web utilise l’outilweb_search(web_search_previewest désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés à l’aide des fonctionsfichiers_generesettelechargerde la leçon 10. Sources : Code Interpreter · Recherche web.
Compétences : encapsuler des capacités
Une compétence (Skill) résout un problème que tout le monde rencontre dès la deuxième semaine : le même prompt système copié dans quatre fichiers, qui divergent dès que vous en améliorez un seul. L’idée est de traiter une capacité comme une unité unique—ses instructions, ses outils, ses données de référence—et de l’appeler par son nom plutôt que de la réécrire.
L’avantage ne se limite pas à éviter la répétition. Une capacité nommée devient un objet que vous pouvez versionner, tester et transmettre à quelqu’un d’autre. Lorsqu’un avocat vous indique qu’une clause standard a changé, vous modifiez une seule compétence et tous les appels en bénéficient, au lieu de devoir traquer partout où le prompt a été dupliqué.
Le concept de compétence
Une compétence encapsule tout ce dont un modèle a besoin pour accomplir une tâche spécifique. Les trois éléments ci-dessous ne sont pas interchangeables : les instructions définissent le rôle et le format, les outils déterminent ce que le modèle peut récupérer, et le contexte ancre les réponses dans vos propres références plutôt que dans les connaissances générales du modèle.
- Instructions : Le prompt système spécialisé
- Outils : Les fonctions et outils intégrés nécessaires
- Contexte : Données de référence et exemples
from openai import OpenAI
client = OpenAI()
# Définir une compétence d'analyse financière
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"}}
]
}
# Utiliser la compétence
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"]
)
Structurer une bibliothèque de compétences
Passer d’un dictionnaire à une classe n’est pas seulement cosmétique : cela vous permet d’attacher des exemples à une compétence et de les injecter systématiquement. Deux ou trois paires entrée/sortie bien choisies font plus pour la cohérence du format qu’un paragraphe supplémentaire d’instructions, car elles montrent au lieu de décrire. L’implémentation ci-dessous les concatène aux instructions à chaque appel.
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})
# Ajouter des exemples au contexte
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
# Définir des compétences
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
}
]
)
Composer des compétences
La composition enchaîne les compétences en passant le résultat de l’une comme contexte à la suivante. C’est puissant, et c’est exactement là que les problèmes commencent, pour une raison précise : à chaque étape, le contexte transmis est la sortie de l’étape précédente, et non les données originales. Toute information que la première compétence a jugée secondaire disparaît pour toutes les suivantes.
Deux conséquences pratiques. Ordonnez les étapes du plus général au plus spécifique, afin que le filtrage ait lieu le plus tard possible. Et lorsqu’une étape en aval a besoin de données brutes, repassez les fichiers au lieu de vous fier au résumé ; c’est précisément ce que fait le paramètre fichiers dans l’exemple, qui est passé uniquement à la première étape mais devrait l’être à toutes celles qui en dépendent.
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 # Fichiers utilisés uniquement à la première étape
return resultats
# Flux de travail : analyse de contrat suivie de la rédaction d'un résumé
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"
}
]
)
Compétences avec état
Une compétence qui se souvient de ses appels précédents permet des conversations longues—un diagnostic technique, une négociation, un suivi de dossier. Elle introduit également le seul coût qui augmente sans qu’on s’en rende compte : à chaque tour, l’historique entier est renvoyé et refacturé. Prévoyez dès le départ une politique de troncature ou de résumé périodique, sinon la vingtième question coûtera dix fois plus cher que la première pour une qualité qui ne se sera pas améliorée d’autant.
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:
# Construire le prompt avec l'historique
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
# Utilisation : support technique avec suivi de conversation
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")
Registre de compétences
Centralisez la gestion de vos compétences :
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())
# Registre global
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)
# Utilisation
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")
Puncte cheie
- Une compétence encapsule les instructions, les outils et le contexte dans un paquet réutilisable
- Composez des compétences pour des flux de travail en plusieurs étapes
- Utilisez l’état pour les compétences conversationnelles
- Centralisez vos compétences dans un registre pour simplifier leur découverte
- Les exemples dans les instructions améliorent la précision du modèle