Przejdź do głównej treści
Polski— Wybierz język
Menu

Skills: Kapsułkowanie możliwości

Lekcja 17 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Skills: Kapsułkowanie możliwości
  2. Koncepcja Skilla
  3. Strukturyzowanie biblioteki Skills
  4. Kompozycja Skills
  5. Skille ze stanem (Stateful)
  6. Rejestr Skills
  7. Kluczowe wnioski

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ą typ input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview jest obecnie narzędziem przestarzałym bez filtrów domen). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z 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