Компетенции: Опаковане на възможности
На тази страница
Урокът е актуализиран на 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")
Ключови изводи
- Една компетенция обединява инструкции, инструменти и контекст в пакет за многократна употреба
- Композирайте компетенции за работни потоци с няколко стъпки
- Използвайте състояние за разговорни компетенции
- Централизирайте Вашите компетенции в регистър, за да опростите откриването им
- Примерите в инструкциите подобряват точността на модела