Innerhalb von Claude Fähigkeiten: Benutzerdefinierte Module, die Claude erweitern

Claude-Entwicklerplattform (API)

Auf die Claude-Funktionen kann man auch über die Claude-API zugreifen. In diesem Abschnitt schauen wir uns an, wie wir die Benutzeroberfläche der Claude-App über die Claude-API nachmachen können.

Schritt 1: Was du brauchen solltest

Fang damit an, alle Laufzeitabhängigkeiten zu installieren:

• Anthropic für die Claude Messages API

• pandas und openpyxl, um Arbeitszeitnachweise aus Excel zu lesen

• reportlab eine Fallback-PDF-Rechnung lokal erstellen 

!pip -q install anthropic pandas openpyxl reportlab

Jetzt haben wir alle Abhängigkeiten installiert.  Als Nächstes können wir unseren API-Schlüssel einrichten.

Schritt 2: Richte deinen API-Schlüssel ein

Bevor wir die Messages API aufrufen können, müssen wir uns erst mal authentifizieren. Mit diesem Schritt erstellst du einen einzigen, wiederverwendbaren API-Schlüssel namens „ anthropic.Client “. 

import os, json, sys, re
import anthropic
from datetime import datetime, timedelta
API_KEY = "YOUR_ANTHROPIC_API_KEY"
client = anthropic.Client(api_key=API_KEY)

Logge dich bei der Anthropic-Konsole ein und such den Reiter „API-Schlüssel“ unter „Einstellungen“. Klick auf„ “ (API-Schlüssel erstellen) und kopier deinen Anthropic-API-Schlüssel.

Quelle: Anthropic-API

Anmerkung: Wenn du ein privates Notizbuch für deinen persönlichen Gebrauch nutzt, dann füge deinen API-Schlüssel hinzu. Ansonsten solltest du eine sichere Umgebungsvariable verwenden, damit dein Schlüssel nicht im Notizbuch oder in den Protokollen sichtbar ist.

Der obige Code startet den Anthropic SDK-Client und richtet die Umgebung ein. Das Client-Objekt wird dann für alle folgenden Messages-API-Aufrufe wiederverwendet.

Schritt 3: Daten vorbereiten

In diesem Schritt machen wir aus unserem Blatt „ timesheet.xlsx“ ein sauberes, vorhersehbares JSON-Objekt, das die Skill nutzen kann. Das macht die nachgelagerte Logik einfach und vermeidet kompliziertes Parsing von Eingabeaufforderungen.

def load_invoice_from_timesheet(excel_path):
    import pandas as pd
    df = pd.read_excel(excel_path)
    df.columns = df.columns.str.strip()  
    invoice_period = "2025-10"
    if 'Date' in df.columns:
        first_date = str(df['Date'].iloc[0])
        date_match = re.search(r'(\d{2})\s+(\w+)\s+(\d{4})', first_date)
        if date_match:
            month_name = date_match.group(2)
            year = date_match.group(3)
            month_num = datetime.strptime(month_name[:3], '%b').month
            invoice_period = f"{year}-{month_num:02d}"   
    article_col = next((col for col in df.columns if 'article' in col.lower() and 'name' in col.lower()), None)
    amount_col = next((col for col in df.columns if 'amount' in col.lower()), None)
    topic_col = next((col for col in df.columns if 'topic' in col.lower()), None)
    line_items = []
    timesheet_articles = []
    
    for idx, row in df.iterrows():
        if pd.isna(row.get(article_col)) or row.get(article_col) == '':
            continue    
        article_name = str(row[article_col]).strip()
        amount = row.get(amount_col, 0) 
        if isinstance(amount, str):
            amount = float(amount.replace('$', '').replace(',', '').strip())
        line_items.append({
            "title": article_name,
            "rate_type": "flat",
            "qty": 1,
            "rate": float(amount)
        })  
        timesheet_articles.append({
            "title": article_name,
            "topic": str(row.get(topic_col, 'N/A')) if topic_col else 'N/A'
        })
    return {
        "client_name": "Client",
        "billing_contact": "billing@example.com",
        "invoice_period": invoice_period,
        "currency": "USD",
        "payment_terms": "Net-30",
        "line_items": line_items,
        "discount_pct": 0.0,
        "tax_pct": 0.0,
        "timesheet": timesheet_articles
    }

Die Funktion „ load_invoice_from_timesheet ” macht aus einer hochgeladenen Excel-Datei eine normalisierte Rechnungs-JSON-Nutzlast.

• Es liest die Excel-Datei mit Pandas und macht die Spaltenüberschriften normal.

• Der Code ermittelt dann anhand einer regulären Ausdrucks- und Monatsanalyse die „ invoice_period “ aus der ersten „ Date “-Zeile (falls vorhanden).

• Es erkennt endlich Spaltennamen für Artikeltitel, Betrag und Thema, ohne zwischen Groß- und Kleinschreibung zu unterscheiden.

• Das gibt zwei Strukturen aus:

• line_items: Das wird für die Abrechnung benutzt (hier eine Pauschale pro Artikel).

• timesheet: Eine flache Liste mit Einträgen vom Typ „ {title, topic} “ für einen optionalen Anhang.

• Der reguläre Ausdruck „ (\d{2})\s+(\w+)\s+(\d{4}) “ erwartet Formate wie „ 01 Oct 2025“. Passe ihn an, wenn dein Blatt ein anderes Format hat.

• Fehlende Spalten/Werte werden durch Überspringen leerer Zeilen behandelt, oder du kannst den Code bei Bedarf so erweitern, dass er schnell fehlschlägt.

Unser Beitrag ist jetzt fertig. Als Nächstes rufen wir die Claude-Funktion über die API auf, um die bearbeitete Zeiterfassung in eine bearbeitbare Rechnung umzuwandeln.

Schritt 4: Hilfsfunktionen

In diesem Abschnitt machen wir zwei Hilfsfunktionen, die die Tool-Ausführung simulieren, die Claude während eines Skill-Laufs anfordert. 

def execute_bash_tool(command):
    try:
        dangerous = ['rm -rf /', 'sudo', 'chmod', 'mkfs', '> /dev/']
        if any(d in command for d in dangerous):
            return f"Error: Command blocked for safety: {command}"
        result = subprocess.run(
            command, 
            shell=True, 
            capture_output=True, 
            text=True, 
            timeout=30,
            cwd=tempfile.gettempdir()
        )    
        output = result.stdout if result.stdout else result.stderr
        return output if output else "Command executed successfully"
    except subprocess.TimeoutExpired:
        return "Error: Command timed out"
    except Exception as e:
        return f"Error executing command: {str(e)}"
def execute_text_editor_tool(params):
    try:
        command = params.get('command')
        path = params.get('path')   
        if command == 'create':
            file_text = params.get('file_text', '')
            os.makedirs(os.path.dirname(path) if os.path.dirname(path) else '.', exist_ok=True)
            with open(path, 'w') as f:
                f.write(file_text)
            return f"File created: {path}"
        elif command == 'view':
            if os.path.exists(path):
                with open(path, 'r') as f:
                    content = f.read()
                return content[:1000] 
            return f"Error: File not found: {path}"   
        elif command == 'str_replace':
            if os.path.exists(path):
                with open(path, 'r') as f:
                    content = f.read()
                old_str = params.get('old_str', '')
                new_str = params.get('new_str', '')
                content = content.replace(old_str, new_str)
                with open(path, 'w') as f:
                    f.write(content)
                return f"File updated: {path}"
            return f"Error: File not found: {path}"    
        return f"Unknown command: {command}"
    except Exception as e:
        return f"Error: {str(e)}"

Die Funktion „ execute_bash_tool ” macht ein sicheres Bash-Tool für skillbasierte Aktionen. Zuerst blockiert es gefährliche Muster wie rm -rf /, sudo, chmod, mkfs usw. als Sicherheitsmaßnahme und führt den Befehl mit subprocess.run() im temporären Verzeichnis des Betriebssystems mit einer erzwungenen Zeitüberschreitung von 30 Sekunden aus.

Die Funktion „ execute_text_editor_tool “ bietet eine einfache Schnittstelle zum Bearbeiten von Text, die von Skills genutzt wird. Es gibt drei Befehle: „ create “ (um eine neue Datei mit „ file_text “ zu schreiben), „ view “ (um bis zu 1.000 Zeichen einer Datei zurückzugeben) und „ str_replace “ (für „ new_str “ an Ort und Stelle). Außerdem erstellt es automatisch übergeordnete Ordner für „ create “, überprüft, ob die Dateien „ view “ und „ str_replace “ vorhanden sind, und schreibt Aktualisierungen zurück auf die Festplatte.

Mit diesen Helfern kannst du eine Tool-Use-Schleife lokal mit Schutzvorrichtungen abschließen. Jetzt kann Skill während der Rechnungserstellung Dateiänderungen oder shell-Aktionen anfordern, ohne dein System zu gefährden.

Schritt 5: Ruf die Funktion über die API auf 

Dieser Schritt sorgt dafür, dass die Rechnungserstellung komplett über die Claude Messages API läuft. Es schickt eine strukturierte Anfrage, nutzt Tools, geht alle Tool-Aufrufe durch, die Claude anfordert, und sammelt schließlich alle erstellten PDF-Dateien aus den Arbeits- und temporären Verzeichnissen.

def generate_invoice_with_claude(invoice): 
    user_text = f"""Generate a professional PDF invoice with the following data:
Client: {invoice['client_name']}
Period: {invoice['invoice_period']}
Currency: {invoice['currency']}
Payment Terms: {invoice['payment_terms']}
Line Items:
{json.dumps(invoice['line_items'], indent=2)}
Timesheet Articles:
{json.dumps(invoice['timesheet'], indent=2)}
Please create a professional PDF invoice with:
1. Invoice header with invoice number (INV-{invoice['invoice_period'].replace('-', '')}-001)
2. Client billing information
3. Line items table with amounts
4. Subtotal and total calculations
5. Timesheet section showing all articles and topics
Save the PDF as: invoice_{invoice['client_name'].lower()}_{invoice['invoice_period']}.pdf
""" 
    tools = [
        {"type": "bash_20250124", "name": "bash"},
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}
    ]
    messages = [{"role": "user", "content": user_text}]
    iteration = 0
    max_iterations = 15   
    while iteration < max_iterations:
        iteration += 1
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=8192,
            tools=tools,
            messages=messages
        )   
        messages.append({"role": "assistant", "content": response.content}) 
        if response.stop_reason == "end_turn":
            break     
        if response.stop_reason == "tool_use":
            tool_results = []    
            for block in response.content:
                if block.type == "tool_use":
                    tool_name = block.name
                    tool_input = block.input
                    if tool_name == "bash":
                        result = execute_bash_tool(tool_input.get('command', ''))
                    elif tool_name == "str_replace_based_edit_tool":
                        result = execute_text_editor_tool(tool_input)
                    else:
                        result = f"Unknown tool: {tool_name}" 
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            messages.append({"role": "user", "content": tool_results})
        else:
            break
    pdf_files = []
    for file in os.listdir('.'):
        if file.endswith('.pdf') and 'invoice' in file.lower():
            pdf_files.append(file)
    for file in os.listdir(tempfile.gettempdir()):
        if file.endswith('.pdf') and 'invoice' in file.lower():
            temp_path = os.path.join(tempfile.gettempdir(), file)
            import shutil
            dest_path = os.path.join('.', file)
            shutil.copy2(temp_path, dest_path)
            pdf_files.append(file)   
    return pdf_files
def main():
    if len(sys.argv) < 2:
        print("Usage: python app.py <timesheet.xlsx>")
        sys.exit(1)    
    excel_file = sys.argv[1]  
    if not os.path.exists(excel_file):
        print(f"Error: File not found: {excel_file}")
        sys.exit(1)    
    try:
        invoice = load_invoice_from_timesheet(excel_file)
        pdf_files = generate_invoice_with_claude(invoice)    
        if pdf_files:
            for pdf in pdf_files:
                print(f"Invoice generated: {os.path.abspath(pdf)}")
        else:
            print("Error: No PDF file was generated.")     
    except Exception as e:
        print(f"Error: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)
if __name__ == "__main__":
    main()

Die Funktion „ generate_invoice_with_claude ” schickt die bereinigte Rechnung an die Claude-API und sorgt dafür, dass die Ausführung der Skill von Anfang bis Ende läuft. Hier ist, was der Code macht:

• Es erstellt eine klare „ user_text “, die Kunden, Zeitraum, Währung, Bedingungen, Einzelposten und Zeiterfassungseinträge sowie explizite Ausgabevorgaben wie Kopfzeile, Tabellen, Summen und Dateiname enthält.

• Dann macht es die Ausführung des Tools möglich, indem es „ bash_number “ und „ text_editor_number “ mit einer tool-bewussten Nachrichten-Schleife deklariert, die die Anfrage sendet, „ stop_reason “ überprüft und, wenn „ tool_use “ angefordert wird, an lokale Helfer weiterleitet und „ tool_result “-Blöcke zurückgibt, um den Austausch fortzusetzen.

• Schlussendlich hört es bei „ end_turn “ auf oder wenn die Schleifengrenze erreicht ist, und sucht dann im Arbeitsverzeichnis und im temporären Verzeichnis des Betriebssystems nach Dateien, die mit „ invoice*.pdf “ übereinstimmen. Es kopiert alle temporären Dateien zurück in den Projektordner und gibt die Liste der gefundenen PDF-Dateien zurück.

• Die Funktion „ main “ hat einen einfachen CLI-Befehl: „ python app.py “, der den eingegebenen Pfad überprüft und dann die Pipeline „ load_invoice_from_timesheet(...) “ zum Erstellen der Nutzlast und „ generate_invoice_with_claude(...)“ zum Aufrufen der Skill und zum Sammeln von PDFs ausführt.

Damit sollte der API-Aufruf eine für den Kunden fertige PDF-Datei erzeugen. Wenn keine Datei angezeigt wird, check mal die Protokolle „ tool_result “ und die Skill-Konfiguration und versuch's dann nochmal mit einem kleinen Testblatt.

Fazit

Du hast jetzt einen funktionierenden Auto-Rechnungsgenerator, der von Claude Skills betrieben wird, und die API kann aus rohen Tabellen kundenfertige Rechnungen machen. Diese Demo zeigt, was Skills am besten können, also tragbare Einrichtung, automatische Aktivierung, deterministische Codeausführung und konsistente Ergebnisse in der App und API, ohne dass in jedem Thread neue Eingabeaufforderungen erstellt werden müssen. Claude Skills liefert konsequent Ergebnisse in verschiedenen Kontexten, die wiederverwendbares Domänenwissen und durch Code gestützt sind. Auch wenn Skills Code ausführen können, solltest du trotzdem auf Sicherheit achten, indem du nur vertrauenswürdige Skills aktivierst, Kontrollen auf Organisationsebene einsetzt und Updates vor der Einführung überprüfst.

Wenn du noch mehr wissen willst, schau dir die Skills-Dokumente und die Konsole von Anthropic für Versionierung und Upgrades an und fang dann an, mehrere Skills zusammenzustellen, um durchgängige Workflows zu erstellen.