Fähigkeiten: Fähigkeiten kapseln

Lektion aktualisiert am 2. November 2026 basierend auf der OpenAI-Dokumentation: Das Code-Interpreter-Tool erfordert nun einen container-Parameter (in allen Beispielen hinzugefügt), Texteingabeteile sind vom Typ input_text, und die Websuche verwendet das web_search-Tool (web_search_preview ist nun ein veraltetes Tool ohne Domänenfilter). Generierte Dateien werden mit den Funktionen fichiers_generes und telecharger aus Lektion 10 abgerufen. Quellen: Code Interpreter · Websuche.

Eine Fähigkeit (Skill) löst ein Problem, das fast jeder in der zweiten Woche trifft: Der gleiche Systemprompt wird in vier Dateien kopiert und divergiert sofort, sobald man nur eine davon verbessert. Die Idee besteht darin, eine Fähigkeit als einzelne Einheit zu behandeln – ihre Anweisungen, ihre Werkzeuge und ihre Referenzdaten – und sie nach Name anzurufen, anstatt sie neu zu schreiben.

Der Vorteil beschränkt sich nicht nur auf die Vermeidung von Wiederholungen. Eine benannte Fähigkeit wird zu einem Objekt, das Sie versionieren, testen und an andere übergeben können. Wenn Ihnen ein Anwalt mitteilt, dass sich eine Standardklausel geändert hat, ändern Sie eine einzige Fähigkeit, und jeder Aufruf profitiert davon – anstatt zu suchen, wo der Prompt dupliziert wurde.

Das Konzept der Fähigkeit

Eine Fähigkeit kapselt alles, was ein Modell benötigt, um eine bestimmte Aufgabe zu erfüllen. Die drei untenstehenden Elemente sind nicht austauschbar: Anweisungen definieren die Rolle und das Format, Werkzeuge bestimmen, was das Modell abrufen kann, und der Kontext verankert die Antworten in Ihren eigenen Referenzen anstatt des allgemeinen Wissens des Modells.

Anweisungen: Der spezialisierte Systemprompt
Werkzeuge: Die erforderlichen integrierten Funktionen und Tools
Kontext: Referenzdaten und Beispiele

from openai import OpenAI

client = OpenAI()

# Definition einer Fähigkeit zur Finanzanalyse
skill_analyse_financiere = {
    "instructions": (
        "Sie sind ein Finanzanalyst, der sich auf französische KMUs spezialisiert hat. "
        "Sie analysieren Buchhaltungsunterlagen und erstellen strukturierte Berichte "
        "mit Schlüsselindikatoren, Trends und Empfehlungen. "
        "Verwenden Sie französische Buchhaltungsstandards (PCG). "
        "Formatieren Sie Beträge in Euro mit Tausendertrennzeichen."
    ),
    "tools": [
        {"type": "file_search", "vector_store_ids": ["vs_normes_comptables"]},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
}

# Nutzung der Fähigkeit
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=skill_analyse_financiere["instructions"],
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Analysieren Sie diese Bilanz und erstellen Sie einen Bericht"},
            {"type": "input_file", "file_id": fichier_bilan.id}
        ]
    }],
    tools=skill_analyse_financiere["tools"]
)

Strukturierung einer Fähigkeitenbibliothek

Der Übergang von einem Dictionary zu einer Klasse ist nicht nur kosmetisch: Er ermöglicht es Ihnen, Beispiele einer Fähigkeit zuzuordnen und sie systematisch einzubinden. Zwei oder drei gut gewählte Input/Output-Paare leisten mehr für die Formatkonsistenz als ein zusätzlicher Absatz Anweisungen, da sie zeigen, statt zu beschreiben. Die folgende Implementierung fügt sie bei jedem Aufruf den Anweisungen hinzu.

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

        # Beispiele zum Kontext hinzufügen
        instructions = self.instructions
        if self.exemples:
            instructions += "\n\nReferenzbeispiele:\n"
            for ex in self.exemples:
                instructions += f"- Eingabe: {ex['input']}\n  Ausgabe: {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


# Definition von Fähigkeiten
skill_redaction_contrat = Skill(
    nom="redaction-contrat",
    instructions=(
        "Sie sind ein Anwalt, der sich auf Vertragsrecht spezialisiert hat. "
        "Sie verfassen klare, präzise Klauseln, die mit dem französischen Recht übereinstimmen. "
        "Jede Klausel muss nummeriert und strukturiert sein."
    ),
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_modeles_contrats"]},
        {"type": "web_search"}
    ],
    exemples=[
        {
            "input": "Vertraulichkeitsklausel für einen Auftragnehmer",
            "output": "Artikel X - Vertraulichkeit\nX.1 Der Auftragnehmer verpflichtet sich..."
        }
    ]
)

skill_support_technique = Skill(
    nom="support-technique",
    instructions=(
        "Sie sind ein technischer Support-Mitarbeiter der Stufe 2. "
        "Sie diagnostizieren Probleme durch gezielte Fragen. "
        "Suchen Sie zuerst in der Wissensdatenbank, bevor Sie Lösungen vorschlagen. "
        "Dokumentieren Sie jede Lösung."
    ),
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_base_connaissances"]},
        {
            "type": "function",
            "name": "creer_ticket_escalade",
            "description": "Ein Problem auf Stufe 3 eskalieren",
            "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
        }
    ]
)

Zusammensetzung von Fähigkeiten

Die Komposition verknüpft Fähigkeiten, indem das Ergebnis einer als Kontext für die nächste übergeben wird. Das ist mächtig, und genau dort beginnt das Problem, und zwar aus einem spezifischen Grund: In jedem Schritt ist der übertragene Kontext die Ausgabe des vorherigen Schritts, nicht die ursprünglichen Daten. Jede Information, die die erste Fähigkeit als sekundär eingestuft hat, geht für alle nachfolgenden verloren.

Zwei praktische Konsequenzen. Ordnen Sie die Schritte von den allgemeinsten zu den spezifischsten an, sodass das Filtern so spät wie möglich erfolgt. Und wenn ein nachgelagerter Schritt auf Rohdaten angewiesen ist, übergeben Sie die Dateien erneut, anstatt auf die Zusammenfassung zu vertrauen – das ist genau, wofür der Parameter fichiers im Beispiel dient, der nur dem ersten Schritt übergeben wird, aber an alle übergeben werden sollte, die von ihm abhängen.

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\nVorheriger Kontext: {contexte}"

            resultat = skill.executer(self.client, prompt, fichiers)
            resultats[etape["nom"]] = resultat
            contexte = resultat
            fichiers = None  # Dateien werden nur im ersten Schritt verwendet

        return resultats


# Workflow: Vertragsanalyse gefolgt von der Zusammenfassungsredaktion
workflow_audit_contrat = SkillComposee(
    nom="audit-contrat",
    etapes=[
        {
            "nom": "analyse",
            "skill": skill_analyse_financiere,
            "instruction": "Analysieren Sie die finanziellen Aspekte dieses Vertrags"
        },
        {
            "nom": "juridique",
            "skill": skill_redaction_contrat,
            "instruction": "Identifizieren Sie rechtliche Risiken und schlagen Sie Verbesserungen vor"
        }
    ]
)

Zustandsfähigkeiten

Eine Fähigkeit, die ihre vorherigen Aufrufe im Gedächtnis behält, ermöglicht lange Gespräche – eine technische Diagnose, eine Verhandlung, die Verfolgung eines Falls. Sie führt auch die einzige Kostenstelle ein, die unbemerkt wächst: Bei jedem Zug wird die gesamte Historie erneut gesendet und erneut abgerechnet. Planen Sie von Anfang an eine Trunkierungs- oder periodische Zusammenfassungspolitik, oder die zwanzigste Frage kostet das Zehnfache der ersten für eine Qualität, die nicht das Zehnfache verbessert hat.

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:
        # Prompt mit Historie erstellen
        instructions = self.skill.instructions
        if self.contexte_accumule:
            instructions += f"\n\nKontext aus vorherigen Interaktionen:\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

# Nutzung: Technischer Support mit Gesprächsverfolgung
session = SkillAvecEtat(skill_support_technique)
r1 = session.appeler("Meine Anwendung stürzt beim Start ab")
r2 = session.appeler("Ich habe Version 3.2.1 auf Ubuntu 24.04")
r3 = session.appeler("Das Protokoll zeigt einen Fehler bei der Datenbankverbindung")

Fähigkeitenregister

Zentralisieren Sie das Management Ihrer Fähigkeiten:

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"Fähigkeit '{nom}' nicht gefunden. "
                          f"Verfügbar: {list(self.skills.keys())}")
        return self.skills[nom]

    def lister(self) -> list[str]:
        return list(self.skills.keys())

# Globales Register
registre = RegistreSkills()
registre.enregistrer(skill_analyse_financiere_obj)
registre.enregistrer(skill_redaction_contrat)
registre.enregistrer(skill_support_technique)

# Nutzung
skill = registre.obtenir("support-technique")
resultat = skill.executer(client, "Mein Drucker funktioniert nicht")

Kernaussagen

Eine Fähigkeit kapselt Anweisungen, Werkzeuge und Kontext in einer wiederverwendbaren Einheit
Kombinieren Sie Fähigkeiten für mehrstufige Workflows
Nutzen Sie Zustände für konversationelle Fähigkeiten
Zentralisieren Sie Ihre Fähigkeiten in einem Register, um die Entdeckung zu vereinfachen
Beispiele in Anweisungen verbessern die Genauigkeit des Modells