Skills

Was ist überhaupt ein Skill

Ein AI Skill ist eine klar abgegrenzte Fähigkeit, die einer künstlichen Intelligenz beigebracht wird, damit sie eine bestimmte Aufgabe zuverlässig und wiederholbar ausführen kann. Man kann sich einen solchen Skill wie ein kleines Wissensmodul vorstellen, das der KI eine neue Kompetenz verleiht.
Ein Skill bündelt das notwendige Wissen, die passenden Regeln und die logischen Schritte, die für die jeweilige Aufgabe gebraucht werden. Er sorgt dafür, dass die KI nicht nur frei formuliert, sondern zielgerichtet handelt. Wenn ein Nutzer eine Frage stellt oder eine Aufgabe übergibt, erkennt der Skill die Absicht, sammelt die relevanten Informationen, führt die nötigen Aktionen aus und liefert eine verständliche Antwort zurück.
Diese Kompetenz kann darin bestehen, Fragen zu einem Produkt zu beantworten, Informationen aus Dokumenten zu ziehen, Termine zu planen oder mit einem externen System zu kommunizieren. Beispiel Fragen zu einem Produkt beantworten, Termine planen, Support‑Tickets anlegen.

Wichtige Merkmale eines AI Skills:

1. Zweckgebunden: Löst ein klar definiertes Nutzerproblem
2. Modular: Lässt sich in größere Systemen (Chatbots, ....) einbinden
3. Kontextbewusst: Nutzt Session- und Nutzerdaten für Multi-Turn-Dialoge
4. Interaktionsarten: Unterstützt Text, Sprache, manchmal Bilder oder Dateien

Woraus besteht ein Skill ?

1. intent- und Entity-Erkennung: der Skill versteht, was der Nutzer will
2. Dialogmanager / Orchestrator: der Skill steuert Gesprächsfluss und Fallbacks
3. Wissenquelle: Zugriff auf FAQs, RAG/Vector-DB oder andere Art von Datenbanken für faktenbasierte Antworten
4. Action Layer: führt Aktionen aus (API, CRM, Datenbakzugriff)

Beispielskill ohne LLM Anbindung:

1. Intent Erkennung
   

   class IntentDetector:
       def detect(self, text):
           text = text.lower()
   
           if "was ist" in text or "erkläre" in text:
               return "describe"
   
           if "details" in text or "mehr information" in text:
               return "details"
   
           return "unknown"
   

2. Entity Extraktion
   

   class EntityExtractor:
       def __init__(self):
           self.entities = ["laptop", "smartphone", "tablet", "kopfhörer"]
   
       def extract(self, text):
           text = text.lower()
           for entity in self.entities:
               if entity in text:
                   return entity
           return None
   

3. Wissensbasis
   

   class KnowledgeBase:
       def __init__(self):
           self.data = {
               "laptop": {
                   "description": "Ein tragbares Gerät zum Arbeiten und Spielen.",
                   "details": "Ein Laptop besitzt eine Tastatur, ein Display und einen Akku."
               },
               "smartphone": {
                   "description": "Ein mobiles Gerät für Kommunikation und Medien.",
                   "details": "Ein Smartphone bietet Kamera, Apps und mobile Daten."
               },
               "tablet": {
                   "description": "Ein flaches Gerät für Medien und leichte Arbeit.",
                   "details": "Ein Tablet hat einen Touchscreen und ist leicht transportierbar."
               },
               "kopfhörer": {
                   "description": "Ein Gerät zum Hören von Musik oder Gesprächen.",
                   "details": "Kopfhörer gibt es als In Ear, On Ear und Over Ear."
               }
           }
   
       def get(self, entity, field):
           if entity in self.data and field in self.data[entity]:
               return self.data[entity][field]
           return None
   

4. Skill Logik
   

   class ProductSkill:
       def __init__(self):
           self.intent_detector = IntentDetector()
           self.entity_extractor = EntityExtractor()
           self.knowledge = KnowledgeBase()
   
       def handle(self, user_input):
           intent = self.intent_detector.detect(user_input)
           entity = self.entity_extractor.extract(user_input)
   
           if intent == "unknown":
               return "Ich bin mir nicht sicher, was du meinst."
   
           if entity is None:
               return "Ich kenne dieses Gerät nicht."
   
           if intent == "describe":
               result = self.knowledge.get(entity, "description")
               if result:
                   return result
               return "Ich habe keine Beschreibung für dieses Gerät."
   
           if intent == "details":
               result = self.knowledge.get(entity, "details")
               if result:
                   return result
               return "Ich habe keine weiteren Informationen zu diesem Gerät."
   
           return "Ich konnte die Anfrage nicht verarbeiten."
   

5. Orchestrator
   

   class SkillOrchestrator:
       def __init__(self):
           self.skills = {
               "product": ProductSkill()
           }
   
       def process(self, user_input):
           return self.skills["product"].handle(user_input)
   

6. Beispielhafte Nutzung
   

   orchestrator = SkillOrchestrator()
   
   print(orchestrator.process("Was ist ein Laptop"))
   print(orchestrator.process("Gib mir mehr Information über ein Smartphone"))
   print(orchestrator.process("Erkläre mir ein Toaster"))
   print(orchestrator.process("Ich brauche Details zu einem Tablet"))
   
   

Beispielskill mit LLM Anbindung:

Hier werden die Intent Erkennung, Entity Extraktion und wie Wissensbasis erstmal übernommen 
Dann wird ein Promptgenerator eingeführt:

class PromptBuilder:
    def build(self, intent, entity, knowledge):
        system_prompt = (
            "Du bist ein hilfreicher Assistent. "
            "Nutze das gegebene Wissen und antworte klar und verständlich."
        )

        user_prompt = (
            f"Intent: {intent}\n"
            f"Entity: {entity}\n"
            f"Wissen: {knowledge}\n"
            f"Erzeuge eine passende Antwort."
        )

        return system_prompt, user_prompt

Anschließen muss der Skill das LLM über die API Aufrufen .  Das geschieht über einen LLM Client.

import requests

class LLMClient:
    def __init__(self, api_url, api_key):
        self.api_url = api_url
        self.api_key = api_key

    def call(self, system_prompt, user_prompt):
        payload = {
            "model": "generic-llm",
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_prompt}
            ]
        }

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        response = requests.post(self.api_url, json=payload, headers=headers)
        data = response.json()

        return data["choices"][0]["message"]["content"]

Zuletzt muss der Skill Logik mitgeteilt werden , dass sie das LLM aufrufen soll :

class ProductSkill:
    def __init__(self, llm_client):
        self.intent_detector = IntentDetector()
        self.entity_extractor = EntityExtractor()
        self.knowledge = KnowledgeBase()
        self.prompt_builder = PromptBuilder()
        self.llm = llm_client

    def handle(self, user_input):
        intent = self.intent_detector.detect(user_input)
        entity = self.entity_extractor.extract(user_input)

        if intent == "unknown":
            return "Ich bin mir nicht sicher, was du meinst."

        if entity is None:
            return "Ich kenne dieses Gerät nicht."

        field = "description" if intent == "describe" else "details"
        knowledge = self.knowledge.get(entity, field)

        system_prompt, user_prompt = self.prompt_builder.build(intent, entity, knowledge)

        return self.llm.call(system_prompt, user_prompt)

Der Orchestrator kann 1:1 übernommen werden. 

Beispielhafte Nutzung :

llm = LLMClient(
    api_url="https://api.meinmodell.de/v1/chat",
    api_key="DEIN_API_SCHLUESSEL"
)

orchestrator = SkillOrchestrator(llm)

print(orchestrator.process("Was ist ein Laptop"))
print(orchestrator.process("Gib mir mehr Information über ein Smartphone"))
print(orchestrator.process("Ich brauche Details zu einem Tablet"))