Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Kompetence: Zajemanje zmožnosti

Lekcija 17 od 20 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Kompetence: Zajemanje zmožnosti
  2. Koncept kompetence
  3. Strukturiranje knjižnice kompetenc
  4. Sestavljanje kompetenc
  5. Kompetence s stanjem
  6. Register kompetenc
  7. Ključne ugotovitve

Lekcija posodobljena 2. novembra 2026 na podlagi dokumentacije OpenAI: orodje Code Interpreter zdaj zahteva parameter container (dodan vsem primerom), deli besedilnega vnosa so tipa input_text, spletno iskanje pa uporablja orodje web_search (web_search_preview je zdaj zastarelo orodje brez filtrov domen). Ustvarjene datoteke se pridobijo s funkcijama fichiers_generes in telecharger iz lekcije 10. Viri: Code Interpreter · Spletno iskanje.

Kompetence: Zajemanje zmožnosti

Kompetenca rešuje težavo, na katero naletiš že v drugem tednu: isti sistemski poziv, kopiran v štiri datoteke, ki se začnejo razhajati takoj, ko izboljšaš le eno od njih. Ideja je obravnavati zmožnost kot enotno celoto – njena navodila, orodja in referenčni podatki – ter jo klicati po imenu, namesto da bi jo prepisoval.

Prednost ni le izogibanje ponavljanju. Poimenovana zmožnost postane predmet, ki ga lahko verzioniraš, testiraš in predash drugemu. Ko ti odvetnik pove, da se je standardna klavzula spremenila, spremeniš eno kompetenco in vsak klic ima od tega korist – namesto da bi lovil, kje vse je bil poziv podvojen.

Koncept kompetence

Kompetenca zajema vse, kar model potrebuje za opravljanje določene naloge. Trije spodnji elementi niso zamenljivi: navodila opredeljujejo vlogo in format, orodja določajo, kaj lahko model pridobi, kontekst pa sidra odgovore v tvojih referencah in ne v splošnem znanju modela.

  • Navodila: Specializirani sistemski poziv
  • Orodja: Potrebne vgrajene funkcije in orodja
  • Kontekst: Referenčni podatki in primeri
from openai import OpenAI

client = OpenAI()

# Define a financial analysis skill
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"}}
    ]
}

# Use the skill
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"]
)

Strukturiranje knjižnice kompetenc

Prehod iz slovarja na razred ni le kozmetičen: omogoča ti, da h kompetenci pripneš primere in jih sistematično vstaviš. Dva ali trije dobro izbrani pari vhod/izhod naredijo več za doslednost formatiranja kot dodaten odstavek navodil, ker kažejo namesto opisovanja. Spodnja implementacija jih ob vsakem klicu združi z navodili.

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

        # Add examples to context
        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


# Define skills
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
        }
    ]
)

Sestavljanje kompetenc

Sestavljanje povezuje kompetence tako, da rezultat ene posreduje kot kontekst naslednji. To je močno, a prav tu se začnejo težave iz specifičnega razloga: v vsakem koraku je posredovani kontekst izhod prejšnjega koraka, ne izvirnih podatkov. Vsaka informacija, ki jo je prva kompetenca štela za drugotno, za vse naslednje izgine.

Dve praktični posledici. Korake razporedi od najbolj splošnih k najbolj specifičnim, da se filtriranje zgodi čim pozneje. In ko spodnji korak potrebuje surove podatke, ponovno posreduj datoteke, namesto da bi se zanašal na povzetek – točno to počne parameter fichiers v primeru, ki se posreduje le prvemu koraku, posredovati pa bi ga bilo treba vsem, ki so od njega odvisni.

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


# Workflow: contract analysis followed by summary drafting
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"
        }
    ]
)

Kompetence s stanjem

Kompetenca, ki si zapomni svoje prejšnje klice, omogoča dolge pogovore – tehnično diagnostiko, pogajanja, sledenje primerom. Vendar uvaja tudi edini strošek, ki neopazno narašča: ob vsakem obratu se celotna zgodovina ponovno pošlje in zaračuna. Že na začetku načrtuj politiko obrezovanja ali periodičnega povzemanja, sicer bo dvajseto vprašanje stalo desetkrat več kot prvo, kakovost pa se ne bo desetkrat izboljšala.

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:
        # Build prompt with history
        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

# Usage: technical support with conversation tracking
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")

Register kompetenc

Centraliziraj upravljanje svojih kompetenc:

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

# Global registry
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

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

Ključne ugotovitve

  • Kompetenca zajema navodila, orodja in kontekst v ponovno uporabnem paketu
  • Sestavljaj kompetence za večstopenjske delovne tokove
  • Uporabi stanje za konverzacijske kompetence
  • Centraliziraj svoje kompetence v registru za poenostavitev odkrivanja
  • Primeri v navodilih izboljšajo natančnost modela