Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Compétences : encapsuler des capacités

Lekce 17 z 20 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Compétences : encapsuler des capacités
  2. Le concept de compétence
  3. Structurer une bibliothèque de compétences
  4. Composer des compétences
  5. Compétences avec état
  6. Registre de compétences
  7. Klíčové poznatky

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 type input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctions fichiers_generes et telecharger de la leçon 10. Sources : Code Interpreter · Recherche web.

Compétences : encapsuler des capacités

Une compétence (Skill) résout un problème récurrent dès la deuxième semaine : le même prompt système copié dans quatre fichiers, qui divergent dès que tu en améliores 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 tu peux versionner, tester et transmettre. Lorsqu’un juriste t’informe qu’une clause standard a changé, tu modifies 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 tes 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 qu’une question de cosmétique : cela te 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 les 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 précisément là que les problèmes commencent, pour une raison spécifique : à chaque étape, le contexte transmis est la sortie de l’étape précédente, et non les données d’origine. Toute information que la première compétence a jugée secondaire disparaît pour toutes les suivantes.

Deux conséquences pratiques. Ordonne les étapes du plus général au plus spécifique, afin que le filtrage intervienne le plus tard possible. Et lorsqu’une étape en aval a besoin de données brutes, repasse les fichiers au lieu de te 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  # Files used only at the first step

        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 aussi le seul coût qui augmente sans qu’on s’en rende compte : à chaque tour, l’historique entier est renvoyé et refacturé. Prévois 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 n’aura pas décuplé.

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

Centralise la gestion de tes 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")

Klíčové poznatky

  • Une compétence encapsule instructions, outils et contexte dans un paquet réutilisable
  • Compose des compétences pour des flux de travail en plusieurs étapes
  • Utilise l’état pour les compétences conversationnelles
  • Centralise tes compétences dans un registre pour simplifier leur découverte
  • Des exemples dans les instructions améliorent la précision du modèle