Премини към основното съдържание
Български— Изберете език
Меню

Компетенции: Опаковане на възможности

Урок 17 от 20 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Компетенции: Опаковане на възможности
  2. Концепцията за компетенция
  3. Структуриране на библиотека с компетенции
  4. Композиране на компетенции
  5. Компетенции със състояние
  6. Регистър на компетенциите
  7. Ключови изводи

Урокът е актуализиран на 2 ноември 2026 г. въз основа на документацията на OpenAI: инструментът Code Interpreter вече изисква параметър container (добавен към всички примери), текстовите входни части са от тип input_text, а уеб търсенето използва инструмента web_search (web_search_preview вече е остарял инструмент без филтри за домейни). Генерираните файлове се извличат чрез функциите fichiers_generes и telecharger от Урок 10. Източници: Code Interpreter · Уеб търсене.

Компетенции: Опаковане на възможности

Една компетенция (Skill) решава проблем, с който всеки се сблъсква до втората седмица: един и същ системен промпт, копиран в четири файла, който започва да се разминава веднага щом подобрите само един от тях. Идеята е да третирате дадена възможност като единна единица – нейните инструкции, нейните инструменти, нейните справочни данни – и да я извиквате по име, вместо да я преписвате.

Ползата не е просто избягване на повторенията. Именуваната възможност се превръща в обект, който можете да версионирате, тествате и предавате на някой друг. Когато адвокат Ви каже, че стандартна клауза е променена, Вие модифицирате една компетенция и всяко извикване се възползва от това – вместо да търсите къде е дублиран промптът.

Концепцията за компетенция

Една компетенция обединява всичко, от което моделът се нуждае, за да изпълни конкретна задача. Трите елемента по-долу не са взаимозаменяеми: инструкциите дефинират ролята и формата, инструментите определят какво може моделът да извлече, а контекстът закрепва отговорите във Вашите собствени справки, а не в общите знания на модела.

  • Инструкции: Специализираният системен промпт
  • Инструменти: Необходимите вградени функции и инструменти
  • Контекст: Справочни данни и примери
from openai import OpenAI

client = OpenAI()

# Дефиниране на компетенция за финансов анализ
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"}}
    ]
}

# Използване на компетенцията
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"]
)

Структуриране на библиотека с компетенции

Преминаването от речник към клас не е просто козметична промяна: то Ви позволява да прикачите примери към дадена компетенция и да ги инжектирате систематично. Два или три добре подбрани чифта вход/изход правят повече за консистентността на формата, отколкото един допълнителен параграф с инструкции, защото те показват, вместо да описват. Реализацията по-долу ги конкатенира към инструкциите при всяко извикване.

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

        # Добавяне на примери към контекста
        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


# Дефиниране на компетенции
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
        }
    ]
)

Композиране на компетенции

Композицията свързва компетенции в верига, като предава резултата от едната като контекст на следващата. Това е мощно, но точно тук започват проблемите поради една специфична причина: на всяка стъпка предаваният контекст е изходът от предишната стъпка, а не оригиналните данни. Всяка информация, която първата компетенция е сметнала за второстепенна, изчезва за всички последващи.

Две практически последствия. Подредете стъпките от най-общите към най-специфичните, така че филтрирането да се случи възможно най-късно. И когато низходяща стъпка се нуждае от сурови данни, предайте файловете отново, вместо да разчитате на обобщението – точно това прави параметърът fichiers в примера, който се предава само на първата стъпка, но трябва да се предава на всички, които зависят от него.

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  # Файловете се използват само на първата стъпка

        return resultats


# Работен поток: анализ на договор, последван от изготвяне на обобщение
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"
        }
    ]
)

Компетенции със състояние

Компетенция, която помни предишните си извиквания, позволява дълги разговори – техническа диагностика, преговори, проследяване на случаи. Тя обаче въвежда и единствените разходи, които растат незабелязано: при всеки завой цялата история се изпраща отново и се таксува повторно. Планирайте политика за съкращаване или периодично обобщаване от самото начало, иначе двадесетият въпрос ще струва десет пъти повече от първия за качество, което не се е подобрило десетократно.

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:
        # Изграждане на промпт с история
        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

# Използване: техническа поддръжка с проследяване на разговора
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")

Регистър на компетенциите

Централизирайте управлението на Вашите компетенции:

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 = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

# Използване
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "My printer isn't working")

Ключови изводи

  • Една компетенция обединява инструкции, инструменти и контекст в пакет за многократна употреба
  • Композирайте компетенции за работни потоци с няколко стъпки
  • Използвайте състояние за разговорни компетенции
  • Централизирайте Вашите компетенции в регистър, за да опростите откриването им
  • Примерите в инструкциите подобряват точността на модела