Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Prasmes: iespēju kapsulēšana

Nodarbība 17 no 20 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Prasmes: iespēju kapsulēšana
  2. Prasmes jēdziens
  3. Prasmju bibliotēkas strukturēšana
  4. Prasmju komponēšana
  5. Prasmes ar stāvokli
  6. Prasmju reģistrs
  7. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 2. novembrī, pamatojoties uz OpenAI dokumentāciju: Code Interpreter rīkam tagad ir nepieciešams container parametrs (pievienots visiem piemēriem), teksta ievades daļas ir tipa input_text, un tīmekļa meklēšana izmanto web_search rīku (web_search_preview tagad ir novecojis rīks bez domēna filtriem). Ģenerētie faili tiek iegūti, izmantojot fichiers_generes un telecharger funkcijas no 10. nodarbības. Avoti: Code Interpreter · Tīmekļa meklēšana.

Prasmes: iespēju kapsulēšana

Prasme atrisina problēmu, ar kuru saskaras ikviens jau otrajā nedēļā: viens un tas pats sistēmas uzvednis tiek nokopēts četros dažādos failos un sāk atšķirties tiklīdz uzlabo tikai vienu no tiem. Ideja ir uzskatīt iespēju par vienotu veselu — tās instrukcijas, rīkus un atsauces datus — un izsaukt to pēc nosaukuma, nevis pārrakstīt katru reizi no jauna.

Ieguvums nav tikai atkārtojumu novēršana. Nosaukta iespēja kļūst par objektu, kuru vari versijot, testēt un nodot tālāk citiem. Kad jurists paziņo, ka standarta klauzula ir mainījusies, tu modificē vienu prasmi, un labums ir visiem izsaukumiem, nevis tev jāmeklē, kur uzvednis bija dublēts.

Prasmes jēdziens

Prasme kapsulē visu, kas modelim nepieciešams konkrēta uzdevuma veikšanai. Turpmāk minētie trīs elementi nav savstarpēji aizvietojami: instrukcijas definē lomu un formātu, rīki nosaka, ko modelis var iegūt, bet konteksts sidrina atbildes tavos pašu atsauces materiālos, nevis modeļa vispārīgajās zināšanās.

  • Instrukcijas: Specializēts sistēmas uzvednis
  • Rīki: Nepieciešamās iebūvētās funkcijas un rīki
  • Konteksts: Atsauces dati un piemēri
from openai import OpenAI

client = OpenAI()

# Definējam finanšu analīzes prasmi
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"}}
    ]
}

# Izmantojam prasmi
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"]
)

Prasmju bibliotēkas strukturēšana

Pāreja no vārdnīcas uz klasi nav tikai kosmētiska: tā ļauj piesaistīt prasmei piemērus un sistemātiski tos ievadīt. Divi vai trīs labi izvēlēti ievades/izvades pāri nodrošina lielāku formāta konsekvenci nekā papildu instrukciju rindkopa, jo tie parāda, nevis tikai apraksta. Tālāk redzamā implementācija katrā izsaukumā tos pievieno instrukcijām.

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

        # Pievienojam piemērus kontekstam
        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


# Definējam prasmes
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
        }
    ]
)

Prasmju komponēšana

Komponēšana savieno prasmes ķēdē, nododot vienas prasmes rezultātu kā kontekstu nākamajai. Tas ir spēcīgi, un tieši šeit sākas problēmas konkrēta iemesla dēļ: katrā solī pārraidītais konteksts ir iepriekšējā soļa izvade, nevis sākotnējie dati. Jebkura informācija, ko pirmā prasme uzskatīja par sekundāru, pazūd visiem turpmākajiem soļiem.

No tā izriet divas praktiskas sekas. Kārto soļus no vispārīgākā uz specifiskāko, lai filtrēšana notiktu pēc iespējas vēlāk. Un, ja lejupplūsmas solim ir nepieciešami izejdati, pārraidi failus atkārtoti, nevis paļaujies uz kopsavilkumu — tieši to dara fichiers parametrs piemērā, kas tiek nodots tikai pirmajam solim, bet būtu jānodod visiem, kas no tā ir atkarīgi.

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  # Faili tiek izmantoti tikai pirmajā solī

        return resultats


# Darbplūsma: līguma analīze, kam seko kopsavilkuma sagatavošana
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"
        }
    ]
)

Prasmes ar stāvokli

Prasme, kas atceras iepriekšējos izsaukumus, ļauj veikt garas sarunas — tehnisko diagnostiku, sarunu vedību, lietu izsekošanu. Taču tā ievieš vienīgās izmaksas, kas pieaug nemanot: katrā pagriezienā tiek nosūtīta un apmaksāta visa vēsture. No paša sākuma ieplāno apgriešanas vai periodiskas kopsavilkuma veidošanas politiku, pretējā gadījumā divdesmitais jautājums maksās desmitreiz vairāk nekā pirmais, lai gan kvalitāte nebūs uzlabojusies desmitkārtīgi.

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:
        # Veidojam uzvedni ar vēsturi
        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

# Lietojums: tehniskais atbalsts ar sarunu izsekošanu
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")

Prasmju reģistrs

Centralizē savu prasmju pārvaldību:

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ālais reģistrs
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

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

Galvenās atziņas

  • Prasme kapsulē instrukcijas, rīkus un kontekstu atkārtoti izmantojamā paketē
  • Komponē prasmes daudzu soļu darbplūsmām
  • Izmanto stāvokli sarunu prasmēm
  • Centralizē prasmes reģistrā, lai vienkāršotu to atrašanu
  • Piemēri instrukcijās uzlabo modeļa precizitāti