Skills: Kapsułkowanie możliwości
Na tej stronie
Lekcja zaktualizowana 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru
container(dodano do wszystkich przykładów), części wejściowe tekstu mają typinput_text, a wyszukiwanie w sieci korzysta z narzędziaweb_search(web_search_previewjest obecnie narzędziem przestarzałym bez filtrów domen). Wygenerowane pliki pobiera się za pomocą funkcjifichiers_generesitelechargerz Lekcji 10. Źródła: Code Interpreter · Wyszukiwanie w sieci.
Skills: Kapsułkowanie możliwości
Skill rozwiązuje problem, na który natrafiasz już w drugim tygodniu: ten sam monit systemowy skopiowany do czterech plików, który zaczyna się różnić, gdy poprawisz tylko jeden z nich. Idea polega na traktowaniu danej możliwości jako pojedynczej jednostki – zawierającej jej instrukcje, narzędzia i dane referencyjne – i wywoływania jej po nazwie, zamiast przepisywania jej za każdym razem.
Korzyść nie polega jedynie na unikaniu powtórzeń. Nazwana możliwość staje się obiektem, którego wersjonowanie, testowanie i przekazywanie innym osobom jest proste. Gdy prawnik poinformuje Cię o zmianie standardowego klauzuli, modyfikujesz jeden skill i zyskują na tym wszystkie wywołania – zamiast szukać miejsc, w których monit został zduplikowany.
Koncepcja Skilla
Skill kapsułkuje wszystko, czego model potrzebuje do wykonania konkretnego zadania. Trzy poniższe elementy nie są wymienne: instrukcje definiują rolę i format, narzędzia określają, co model może pobrać, a kontekst zakotwicza odpowiedzi w Twoich własnych materiałach referencyjnych, a nie w ogólnej wiedzy modelu.
- Instrukcje: Wyspecjalizowany monit systemowy
- Narzędzia: Niezbędne wbudowane funkcje i narzędzia
- Kontekst: Dane referencyjne i przykłady
from openai import OpenAI
client = OpenAI()
# Definicja skilla do analizy finansowej
skill_analyse_financiere = {
"instructions": (
"Jesteś analitykiem finansowym specjalizującym się we francuskich MŚP. "
"Analizujesz dokumenty księgowe i tworzysz ustrukturyzowane raporty "
"z kluczowymi wskaźnikami, trendami i rekomendacjami. "
"Korzystaj z francuskich standardów rachunkowości (PCG). "
"Formatuj kwoty w euro z separatorami tysięcy."
),
"tools": [
{"type": "file_search", "vector_store_ids": ["vs_normes_comptables"]},
{"type": "code_interpreter", "container": {"type": "auto"}}
]
}
# Użycie skilla
response = client.responses.create(
model="gpt-5.6-terra",
instructions=skill_analyse_financiere["instructions"],
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": "Przeanalizuj to bilans i sporządź raport"},
{"type": "input_file", "file_id": fichier_bilan.id}
]
}],
tools=skill_analyse_financiere["tools"]
)
Strukturyzowanie biblioteki Skills
Przejście ze słownika do klasy nie jest tylko zabiegiem kosmetycznym: pozwala dołączyć przykłady do skilla i wstrzykiwać je systematycznie. Dwa lub trzy dobrze dobrane pary wejście/wyjście robią więcej dla spójności formatu niż dodatkowy akapit instrukcji, ponieważ pokazują, a nie tylko opisują. Poniższa implementacja dołącza je do instrukcji przy każdym wywołaniu.
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})
# Dodawanie przykładów do kontekstu
instructions = self.instructions
if self.exemples:
instructions += "\n\nPrzykłady referencyjne:\n"
for ex in self.exemples:
instructions += f"- Wejście: {ex['input']}\n Wyjście: {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
# Definicja skills
skill_redaction_contrat = Skill(
nom="redaction-contrat",
instructions=(
"Jesteś prawnikiem specjalizującym się w prawie umów. "
"Tworzysz jasne, precyzyjne klauzule zgodne z francuskim prawem. "
"Każda klauzula musi być ponumerowana i ustrukturyzowana."
),
tools=[
{"type": "file_search", "vector_store_ids": ["vs_modeles_contrats"]},
{"type": "web_search"}
],
exemples=[
{
"input": "Klauzula poufności dla podwykonawcy",
"output": "Artykuł X - Poufność\nX.1 Wykonawca zobowiązuje się..."
}
]
)
skill_support_technique = Skill(
nom="support-technique",
instructions=(
"Jesteś agentem wsparcia technicznego poziomu 2. "
"Diagnozujesz problemy, zadając ukierunkowane pytania. "
"Przed zaproponowaniem rozwiązań przeszukaj bazę wiedzy. "
"Dokumentuj każde rozwiązanie."
),
tools=[
{"type": "file_search", "vector_store_ids": ["vs_base_connaissances"]},
{
"type": "function",
"name": "creer_ticket_escalade",
"description": "Eskalacja problemu do poziomu 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
}
]
)
Kompozycja Skills
Kompozycja łączy skille w łańcuch, przekazując wynik jednego jako kontekst dla następnego. Jest to potężne narzędzie, ale właśnie tutaj zaczynają się problemy z konkretnego powodu: na każdym kroku przekazywany kontekst to wyjście poprzedniego kroku, a nie oryginalne dane. Wszelkie informacje, które pierwszy skill uznał za drugorzędne, znikają dla wszystkich kolejnych.
Wynikają z tego dwie praktyczne konsekwencje. Uszereguj kroki od najbardziej ogólnych do najbardziej szczegółowych, aby filtrowanie odbywało się jak najpóźniej. Gdy krok downstream potrzebuje surowych danych, przekaż pliki ponownie, zamiast polegać na podsumowaniu – dokładnie to robi parametr fichiers w przykładzie, który jest przekazywany tylko do pierwszego kroku, ale powinien być przekazywany do wszystkich, które od niego zależą.
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\nPoprzedni kontekst: {contexte}"
resultat = skill.executer(self.client, prompt, fichiers)
resultats[etape["nom"]] = resultat
contexte = resultat
fichiers = None # Pliki używane tylko w pierwszym kroku
return resultats
# Przepływ pracy: analiza umowy, a następnie sporządzenie podsumowania
workflow_audit_contrat = SkillComposee(
nom="audit-contrat",
etapes=[
{
"nom": "analyse",
"skill": skill_analyse_financiere,
"instruction": "Przeanalizuj aspekty finansowe tej umowy"
},
{
"nom": "juridique",
"skill": skill_redaction_contrat,
"instruction": "Zidentyfikuj ryzyka prawne i zaproponuj ulepszenia"
}
]
)
Skille ze stanem (Stateful)
Skill, który pamięta swoje poprzednie wywołania, umożliwia prowadzenie długich rozmów – diagnozy technicznej, negocjacji, śledzenia spraw. Wprowadza to jednak jedyny koszt, który rośnie niezauważenie: przy każdym obrocie cała historia jest wysyłana ponownie i ponownie rozliczana. Zaplanuj politykę obcinania lub okresowego podsumowywania od samego początku, inaczej dwudzieste pytanie będzie kosztować dziesięć razy więcej niż pierwsze, przy jakości, która nie wzrosła dziesięciokrotnie.
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:
# Budowanie promptu z historią
instructions = self.skill.instructions
if self.contexte_accumule:
instructions += f"\n\nKontekst z poprzednich interakcji:\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
# Użycie: wsparcie techniczne ze śledzeniem konwersacji
session = SkillAvecEtat(skill_support_technique)
r1 = session.appeler("Moja aplikacja crashuje się przy starcie")
r2 = session.appeler("Mam wersję 3.2.1 na Ubuntu 24.04")
r3 = session.appeler("Log pokazuje błąd połączenia z bazą danych")
Rejestr Skills
Scentralizuj zarządzanie swoimi skillami:
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}' nie znaleziony. "
f"Dostępne: {list(self.skills.keys())}")
return self.skills[nom]
def lister(self) -> list[str]:
return list(self.skills.keys())
# Globalny rejestr
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)
# Użycie
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "Moja drukarka nie działa")
Kluczowe wnioski
- Skill kapsułkuje instrukcje, narzędzia i kontekst w pakiecie wielokrotnego użytku
- Łącz skille w złożone przepływy pracy wieloetapowe
- Używaj stanu dla skills konwersacyjnych
- Scentralizuj swoje skille w rejestrze, aby uprościć ich odnajdowanie
- Przykłady w instrukcjach poprawiają dokładność modelu