Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Készségek: Képességek kapszulázása

17. lecke 20 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Készségek: Képességek kapszulázása
  2. A készség fogalma
  3. Egy készségkönyvtár felépítése
  4. Készségek komponálása
  5. Állapotfüggő készségek
  6. Készség-regiszter
  7. Főbb megállapítások

Lecke frissítve: 2026. november 2. az OpenAI dokumentációja alapján: a Code Interpreter eszköz mostantól igényli a container paramétert (hozzáadva minden példához), a szöveges bemeneti részek típusa input_text, a webes keresés pedig a web_search eszközt használja (a web_search_preview már elavult eszköz, domain-szűrők nélkül). A generált fájlok lekérése a 10. leckéből ismert fichiers_generes és telecharger függvényekkel történik. Források: Code Interpreter · Web search.

Készségek: Képességek kapszulázása

Egy készség (Skill) megoldja azt a problémát, amellyel mindenki találkozik a második héten: ugyanazt a rendszerüzenetet négy fájlba másoljuk, amelyek aztán divergálnak, mihelyt csak az egyiket fejlesztjük. A lényeg, hogy a képességet egyetlen egységként kezeljük – tartalmazza az utasításait, az eszközeit és a referenciadatait –, majd név szerint hívjuk meg, ahelyett, hogy újraírnánk.

Az előny nem csupán az ismétlődés elkerülése. Egy elnevezett képesség olyan objektummá válik, amelyet verziókezelhetsz, tesztelhetsz és átadhatsz másoknak. Ha egy jogász szól, hogy egy szabványos záradék megváltozott, módosítasz egyetlen készséget, és minden hívás profitál belőle – ahelyett, hogy vadásznál arra, hol lett duplikálva az utasítás.

A készség fogalma

Egy készség kapszulálja mindazt, amire a modellnek egy adott feladat végrehajtásához szüksége van. Az alábbi három elem nem felcserélhető: az utasítások határozzák meg a szerepet és a formátumot, az eszközök döntik el, mit tud lekérni a modell, a kontextus pedig a saját referenciáidhoz rögzíti a válaszokat, nem pedig a modell általános tudásához.

  • Utasítások: A specializált rendszerüzenet
  • Eszközök: A szükséges beépített függvények és eszközök
  • Kontextus: Referenciadatok és példák
from openai import OpenAI

client = OpenAI()

# Egy pénzügyi elemző készség definiálása
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"}}
    ]
}

# A készség használata
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"]
)

Egy készségkönyvtár felépítése

A szótárból osztállyá való átállás nem csupán kozmetikai jellegű: lehetővé teszi, hogy példákat társíts egy készséghez, és ezeket szisztematikusan beillesszd. Két vagy három jól megválasztott bemeneti/kimeneti pár többet tesz a formátum konzisztenciájáért, mint az utasítások egy extra bekezdése, mert mutatják, nem pedig leírják a kívánt eredményt. Az alábbi megvalósítás minden híváskor hozzáfűzi ezeket az utasításokhoz.

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

        # Példák hozzáadása a kontextushoz
        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


# Készségek definiálása
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
        }
    ]
)

Készségek komponálása

A komponálás láncolja a készségeket azáltal, hogy az egyik eredményét kontextusként továbbítja a következőnek. Ez erőteljes módszer, és pontosan itt kezdődnek a gondok, egy specifikus ok miatt: minden lépésben a továbbított kontextus az előző lépés kimenete, nem pedig az eredeti adat. Bármilyen információ, amelyet az első készség másodlagosnak ítélt, eltűnik az összes ezt követő számára.

Ennek két gyakorlati következménye van. Rendezd a lépéseket az általánostól a specifikus felé, így a szűrés a lehető legkésőbb történjen meg. És amikor egy downstream lépésnek nyers adatokra van szüksége, add át újra a fájlokat, ahelyett, hogy az összefoglalóra hagyatkoznál – pontosan ezt csinálja a példában szereplő fichiers paraméter, amelyet csak az első lépésnek adunk át, pedig minden olyan lépésnek továbbítani kellene, amely függ tőle.

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  # A fájlokat csak az első lépésben használjuk

        return resultats


# Munkafolyamat: szerződéselemzést követi az összefoglaló megírása
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"
        }
    ]
)

Állapotfüggő készségek

Egy olyan készség, amely emlékszik a korábbi hívásaira, lehetővé teszi a hosszú beszélgetéseket – legyen szó technikai diagnosztikáról, tárgyalásról vagy esetkövetésről. Ugyanakkor ez vezeti be az egyetlen olyan költséget, amely észrevétlenül növekszik: minden körben a teljes előzményt újra elküldjük és újra számlázzák. Tervezz meg从一开始 egy csonkítási vagy időszakos összefoglalási politikát, különben a huszadik kérdés tízszer annyiba kerül, mint az első, miközben a minőség nem javult tízszeresére.

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 összeállítása az előzményekkel
        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

# Használat: technikai támogatás beszélgetés-követéssel
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")

Készség-regiszter

Centralizáld a készségkezelést:

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

# Globális regiszter
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

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

Főbb megállapítások

  • Egy készség kapszulálja az utasításokat, eszközöket és a kontextust egy újrahasználható csomagban
  • Komponálj készségeket több lépésből álló munkafolyamatokhoz
  • Használj állapotot a beszélgetés alapú készségeknél
  • Centralizáld a készségeidet egy regiszterben a felfedezés egyszerűsítése érdekében
  • Az utasításokban szereplő példák javítják a modell pontosságát