Du möchtest mit Qwen3 von Alibaba Aufgaben automatisieren, bei denen das KI-Modell externe Werkzeuge nutzen kann? Dann bist du hier genau richtig. In diesem Tutorial zeige ich dir Schritt für Schritt, wie du die leistungsstarke Tool-Use-Funktion von Qwen3 nutzt – und zwar im selben Format wie bei OpenAI. Das bedeutet: Du kannst dein bestehendes Wissen zu OpenAI direkt anwenden.

Als ich vor zwei Jahren das erste Mal mit Funktionsaufrufen arbeitete, dachte ich, das wäre extrem kompliziert. Spoiler: Ist es nicht. Nach diesem Tutorial wirst du deine ersten Funktionsaufrufe implementieren können – versprochen.

Was sind Tool Use (Funktionsaufrufe) eigentlich?

Bevor wir in den Code eintauchen, lass mich kurz erklären, was wir hier eigentlich bauen:

Normale KI-Chatbots können nur Text antworten. Mit Tool Use kann die KI jedoch richtig handeln:

Stell dir vor: Du fragst die KI „Wie ist das Wetter in Berlin morgen?" – anstatt eine falsche Antwort zu erfinden, ruft sie automatisch eine Wetter-API auf und gibt dir die echten Daten zurück. Das ist der Kern von Tool Use.

Das OpenAI-kompatible Format verstehen

Qwen3 unterstützt das OpenAI-Format. Das ist fantastisch, weil:

Ein Funktionsaufruf besteht aus drei Teilen:

  1. tools – Die Liste aller verfügbaren Funktionen
  2. function_call – Welche Funktion die KI aufrufen möchte
  3. function_response – Das Ergebnis der Funktion

Vorbereitung: HolySheep AI einrichten

Bevor wir starten, brauchst du einen API-Zugang. Ich empfehle HolySheep AI aus folgenden Gründen:

Schritt 1: Die Basis-Verbindung aufbauen

Zuerst installieren wir das benötigte Paket und richten die Verbindung ein:

# Installation der benötigten Bibliothek
pip install openai


Python-Code für die Verbindung zu HolySheep AI

from openai import OpenAI


API-Client erstellen

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # Ersetze mit deinem echten Key
    base_url="https://api.holysheep.ai/v1"  # WICHTIG: HolySheep-Endpunkt
)


Einfacher Test: Ist die Verbindung erfolgreich?

response = client.chat.completions.create(
    model="qwen3-32b",
    messages=[{"role": "user", "content": "Sag hallo!"}]
)
print(response.choices[0].message.content)

Wichtig: Ersetze YOUR_HOLYSHEEP_API_KEY mit deinem echten API-Schlüssel von HolySheep. Falls du noch keinen hast, registriere dich jetzt kostenlos.

Schritt 2: Werkzeuge (Tools) definieren

Jetzt definieren wir die Funktionen, die Qwen3 nutzen darf. Wir erstellen drei praktische Beispiele:

# Definition der verfügbaren Werkzeuge im OpenAI-Format
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Erfährt das aktuelle Wetter für einen bestimmten Ort",
            "parameters": {
                "type": "object",
                "properties": {
                    "ort": {
                        "type": "string",
                        "description": "Der Stadtname, z.B. 'Berlin' oder 'München'"
                    },
                    "einheit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperaturausgabe in Celsius oder Fahrenheit"
                    }
                },
                "required": ["ort"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "rechne",
            "description": "Führt mathematische Berechnungen durch",
            "parameters": {
                "type": "object",
                "properties": {
                    "ausdruck": {
                        "type": "string",
                        "description": "Der mathematische Ausdruck, z.B. '15 * 8 + 42'"
                    }
                },
                "required": ["ausdruck"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Gibt das aktuelle Datum und die Uhrzeit zurück",
            "parameters": {
                "type": "object",
                "properties": {}
            }
        }
    }
]

Sieh dir die Struktur genau an:

Schritt 3: Die Funktionen tatsächlich implementieren

Jetzt brauchen wir den Code, der ausgeführt wird, wenn Qwen3 eine Funktion aufruft:

import random
from datetime import datetime


Die tatsächliche Implementierung unserer Werkzeuge

def get_weather(ort: str, einheit: str = "celsius") -> str:
    """Simuliert eine Wetter-API Abfrage"""
    # In echtem Code: Hier eine echte Wetter-API aufrufen
    temperatur = random.randint(15, 30)
    wetterlagen = ["sonnig", "wolkig", "regnerisch", "bewölkt"]
    
    if einheit == "fahrenheit":
        temperatur = temperatur * 9/5 + 32
    
    wetter = random.choice(wetterlagen)
    return f"In {ort} ist es {temperatur}°C und {wetter}."

def rechne(ausdruck: str) -> str:
    """Führt sichere mathematische Berechnungen durch"""
    try:
        # WICHTIG: In Produktion niemals eval() verwenden!
        # Hier nur für Demo-Zwecke
        erlaubte_zeichen = set("0123456789+-*/(). "))
        if all(c in erlaubte_zeichen for c in ausdruck):
            ergebnis = eval(ausdruck)
            return f"Das Ergebnis von '{ausdruck}' ist {ergebnis}"
        else:
            return "Fehler: Nur grundlegende Mathematik erlaubt"
    except Exception as e:
        return f"Rechenfehler: {str(e)}"

def get_current_time() -> str:
    """Gibt die aktuelle Zeit zurück"""
    jetzt = datetime.now()
    return f"Es ist {jetzt.strftime('%H:%M:%S')} Uhr am {jetzt.strftime('%d.%m.%Y')}."


Mapping von Funktionsnamen zu tatsächlichen Funktionen

funktion_map = {
    "get_weather": get_weather,
    "rechne": rechne,
    "get_current_time": get_current_time
}

Schritt 4: Das vollständige Konversationssystem

Hier ist das Herzstück – der komplette Code, der alles zusammensetzt:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

def kommuniziere_mit_ki(nachricht: str):
    """Führt eine Konversation mit Tool-Nutzung durch"""
    
    nachrichten = [{"role": "user", "content": nachricht}]
    
    while True:
        # Anfrage an Qwen3 senden
        antwort = client.chat.completions.create(
            model="qwen3-32b",
            messages=nachrichten,
            tools=tools,  # Unsere definierten Werkzeuge
            tool_choice="auto"  # KI entscheidet selbst, ob Werkzeug nötig
        )
        
        ergebnis = antwort.choices[0].message
        
        # Hat die KI eine Funktion aufgerufen?
        if ergebnis.tool_calls:
            # Alle Funktionsaufrufe verarbeiten
            for call in ergebnis.tool_calls:
                funktions_name = call.function.name
                argumente = call.function.arguments
                
                print(f"\n🔧 KI möchte '{funktions_name}' aufrufen...")
                print(f"   Argumente: {argumente}")
                
                # Argumente parsen
                import json
                args = json.loads(argumente)
                
                # Funktion ausführen
                funktion = funktion_map[funktions_name]
                resultat = funktion(**args)
                
                print(f"   Ergebnis: {resultat}")
                
                # Ergebnis zur Konversation hinzufügen
                nachrichten.append({
                    "role": "assistant",
                    "content": None,
                    "tool_calls": [call]
                })
                nachrichten.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": resultat
                })
        else:
            # Keine Funktion – normale Antwort
            print(f"\n💬 KI antwortet: {ergebnis.content}")
            nachrichten.append({"role": "assistant", "content": ergebnis.content})
            break
    
    return ergebnis.content


Beispiel-Gespräche zum Testen

if __name__ == "__main__":
    print("=== Qwen3 Tool Use Demo ===\n")
    
    # Test 1: Wetterabfrage
    print("\n--- Test 1: Wetter ---")
    kommuniziere_mit_ki("Wie ist das Wetter in Tokio?")
    
    # Test 2: Berechnung
    print("\n--- Test 2: Mathematik ---")
    kommuniziere_mit_ki("Was ist 125 geteilt durch 5 plus 17?")
    
    # Test 3: Zeitabfrage
    print("\n--- Test 3: Uhrzeit ---")
    kommuniziere_mit_ki("Welche Zeit ist es gerade?")

Schritt 5: Die JSON-Format-Konvertierung verstehen

Manchmal brauchst du die Daten im JSON-Format für eigene Verarbeitung:

import json

def konvertiere_funktionsaufruf_zu_json(werkzeug_aufruf):
    """Konvertiert das HolySheep/OpenAI-Format zu sauberem JSON"""
    return {
        "funktions_name": werkzeug_aufruf.function.name,
        "argumente": json.loads(werkzeug_aufruf.function.arguments),
        "aufruf_id": werkzeug_aufruf.id
    }

def parse_rohes_json_format():
    """Zeigt, wie das Rohformat aussieht"""
    rohes_format = {
        "type": "function",
        "function": {
            "name": "get_weather",
            "arguments": '{"ort": "Berlin", "einheit": "celsius"}'
        }
    }
    
    # Konvertierung zu Python-Objekt
    name = rohes_format["function"]["name"]
    argumente = json.loads(rohes_format["function"]["arguments"])
    
    print(f"Funktion: {name}")
    print(f"Parameter: {argumente}")
    return {"name": name, "args": argumente}

Praxisbeispiel: Eigene Tool-Funktion erstellen

Lass uns eine nützliche Funktion für die不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问不问问问问问不问不不不不不不不问问问问问-Industrie erstellen:

# Erweiterte Werkzeug-Definition für Finanzdaten
finanz_tools = [
    {
        "type": "function",
        "function": {
            "name": "währungs_umrechner",
            "description": "Rechnet Geldbeträge zwischen verschiedenen Währungen um",
            "parameters": {
                "type": "object",
                "properties": {
                    "betrag": {"type": "number", "description": "Der zu umrechnende Betrag"},
                    "von_währung": {"type": "string", "description": "Ausgangswährung, z.B. 'USD'"},
                    "zu_währung": {"type": "string", "description": "Zielwährung, z.B. 'CNY'"}
                },
                "required": ["betrag", "von_währung", "zu_währung"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "kurs_check",
            "description": "Zeigt aktuelle Wechselkurse an",
            "parameters": {
                "type": "object",
                "properties": {
                    "basis_währung": {"type": "string", "description": "Basiswährung, z.B. 'USD'"}
                },
                "required": ["basis_währung"]
            }
        }
    }
]

def währungs_umrechner(betrag: float, von_währung: str, zu_währung: str) -> str:
    """Konvertiert Währungen (vereinfachtes Demo-Modell)"""
    wechselkurse_usd = {
        "USD": 1.0,
        "CNY": 7.25,  # Demo-Kurse, nicht real!
        "EUR": 0.92,
        "JPY": 149.50
    }
    
    if von_währung not in wechselkurse_usd or zu_währung not in wechselkurse_usd:
        return f"Währung nicht unterstützt: {von_währung} oder {zu_währung}"
    
    # Umrechnung über USD als Zwischenwährung
    in_usd = betrag / wechselkurse_usd[von_währung]
    ergebnis = in_usd * wechselkurse_usd[zu_währung]
    
    return f"{betrag} {von_währung} = {ergebnis:.2f} {zu_währung}"

def kurs_check(basis_währung: str) -> str:
    """Gibt alle Kurse relativ zur Basiswährung aus"""
    wechselkurse_usd = {"USD": 1.0, "CNY": 7.25, "EUR": 0.92, "JPY": 149.50}
    
    if basis_währung not in wechselkurse_usd:
        return f"Währung nicht gefunden: {basis_währung}"
    
    basis_kurs = wechselkurse_usd[basis_währung]
    ergebnisse = []
    
    for währung, kurs in wechselkurse_usd.items():
        if währung != basis_währung:
            relativer_kurs = kurs / basis_kurs
            ergebnisse.append(f"1 {basis_währung} = {relativer_kurs:.4f} {währung}")
    
    return "\n".join(ergebnisse)


Test

print(währungs_umrechner(100, "EUR", "CNY"))
print(kurs_check("USD"))

Häufige Fehler und Lösungen

Fehler 1: "tool_calls is None" – Die KI ruft keine Funktion auf

Symptom: Du sendest eine Anfrage mit Tools, aber die KI antwortet nur mit Text, anstatt die Funktion aufzurufen.

Mögliche Ursachen:

Lösung:

# Fehlerhafter Code
response = client.chat.completions.create(
    model="qwen3-32b",  # Richtig, aber manchmal braucht man Parameter
    messages=[{"role": "user", "content": "Wetter?"}],  # Zu vage!
    tools=tools
)


Lösung: Klarere Anfrage + tool_choice erzwingen

response = client.chat.completions.create(
    model="qwen3-32b",
    messages=[{
        "role": "user", 
        "content": "Ich möchte wissen, wie das Wetter morgen in Hamburg wird. 
                    Könntest du dafür die Wettern-API nutzen?"
    }],
    tools=tools,
    tool_choice="auto"  # Oder "required" wenn Funktion zwingend sein soll
)


Prüfen ob tatsächlich Tool Call kam

if response.choices[0].message.tool_calls:
    print("✓ Funktion wurde aufgerufen!")
else:
    print("✗ Kein Funktionsaufruf - Anfrage präziser formulieren")

Fehler 2: JSONParseError bei function.arguments

Symptom: json.loads(antwort.tool_calls[0].function.arguments) wirft einen Fehler.

Lösung:

import json

def sicher_parsen(argumente):
    """Parse-Fehler abfangen und beheben"""
    try:
        return json.loads(argumente)
    except json.JSONDecodeError as e:
        # Manchmal sind die Argumente schon ein Dict
        if isinstance(argumente, dict):
            return argumente
        
        # Oder es gibt Encoding-Probleme
        if isinstance(argumente, str):
            # Versuche verschiedene Encodings
            for enc in ['utf-8', 'latin-1', 'cp1252']:
                try:
                    return json.loads(argumente.encode(enc))
                except:
                    continue
        
        raise ValueError(f"Konnte Argumente nicht parsen: {argumente}")

Fehler 3: Authentication Error – Falscher API-Key

Symptom: AuthenticationError oder 401 Unauthorized

Lösung:

import os

def erstelle_client():
    """Sicherer Client-Setup mit Fehlerbehandlung"""
    api_key = os.environ.get("HOLYSHEEP_API_KEY")
    
    if not api_key:
        raise ValueError(
            "API-Key nicht gefunden! "
            "Setze die Umgebungsvariable: "
            "export HOLYSHEEP_API_KEY='dein-key-hier'"
        )
    
    if api_key == "YOUR_HOLYSHEEP_API_KEY":
        raise ValueError(
            "Bitte ersetze 'YOUR_HOLYSHEEP_API_KEY' mit deinem echten Key! "
            "Hole ihn dir kostenlos bei https://www.holysheep.ai/register"
        )
    
    return OpenAI(
        api_key=api_key,
        base_url="https://api.holysheep.ai/v1"
    )


Verwendung

try:
    client = erstelle_client()
except ValueError as e:
    print(f"Fehler: {e}")

Fehler 4: Rate Limit erreicht

Symptom: RateLimitError bei vielen An

Verwandte Ressourcen

Verwandte Artikel