Mengenal Claude Skills: Modul Kustom yang Memperluas Claude

Claude Developer Platform (API)

Claude Skills juga dapat diakses melalui Claude API. Di bagian ini, kita akan melihat bagaimana kita bisa meniru antarmuka aplikasi Claude melalui Claude API.

Langkah 1: Prasyarat

Mulailah dengan memasang semua dependensi runtime:

• Anthropic untuk Claude Messages API

• pandas dan openpyxl untuk membaca timesheet dari Excel

• reportlab untuk membuat faktur PDF cadangan secara lokal 

!pip -q install anthropic pandas openpyxl reportlab

Sekarang semua dependensi telah terpasang. Selanjutnya, kita dapat mengonfigurasi kunci API kita.

Langkah 2: Konfigurasikan kunci API Anda

Sebelum memanggil Messages API, kita perlu melakukan autentikasi. Langkah ini membuat satu anthropic.Client yang dapat digunakan kembali dengan kunci API.

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)

Masuk ke Anthropic Console dan temukan tab API keys di bawah Settings. Klik Create Key dan salin kunci API Anthropic Anda.

Sumber: Anthropic API

Catatan: Jika Anda menggunakan notebook pribadi untuk penggunaan personal, maka tambahkan Kunci API Anda. Jika tidak, gunakan variabel lingkungan yang aman agar kunci Anda tidak terekspos di notebook atau log.

Kode di atas menginisialisasi klien SDK Anthropic dan menyiapkan lingkungan. Objek klien kemudian digunakan kembali untuk semua panggilan Messages API berikutnya.

Langkah 3: Prapemrosesan data

Pada langkah ini, kita akan mengubah lembar timesheet.xlsx menjadi objek JSON yang bersih dan terprediksi yang dapat dikonsumsi oleh Skill. Ini menjaga logika hilir tetap sederhana dan menghindari parsing prompt yang rapuh.

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
    }

Fungsi load_invoice_from_timesheet mengonversi file Excel yang diunggah menjadi payload JSON faktur yang dinormalisasi.

• Membaca Excel dengan pandas dan menormalkan header kolom.

• Kode kemudian menyimpulkan invoice_period dari baris Date pertama (jika ada) menggunakan regex dan parsing bulan.

• Terakhir, kode mendeteksi nama kolom untuk judul artikel, jumlah, dan topik tanpa membedakan huruf besar/kecil.

• Ini mengeluarkan dua struktur:

• line_items: Digunakan untuk perhitungan penagihan (tarif flat per artikel di sini).

• timesheet: Daftar datar entri {title, topic} untuk lampiran opsional.

• Regex (\d{2})\s+(\w+)\s+(\d{4}) mengharapkan format seperti 01 Oct 2025; sesuaikan jika lembar Anda menggunakan format lain.

• Kolom/nilai yang hilang ditangani dengan melewati baris kosong, atau Anda dapat memperluas kode untuk gagal lebih awal jika diperlukan.

Input kita sekarang siap. Selanjutnya, kita akan memanggil Claude Skill melalui API untuk mengubah timesheet yang telah diproses menjadi faktur yang dapat diedit.

Langkah 4: Fungsi pembantu

Di bagian ini, kita mendefinisikan dua fungsi pembantu yang mensimulasikan eksekusi tool yang diminta Claude selama menjalankan Skill.

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

Fungsi execute_bash_tool mensimulasikan tool bash yang aman untuk aksi yang didorong Skill. Fungsi ini terlebih dahulu memblokir pola berbahaya seperti rm -rf /, sudo, chmod, mkfs, dan sebagainya sebagai gerbang keamanan dan menjalankan perintah dengan subprocess.run() di direktori temp OS dengan batas waktu 30 detik.

Fungsi execute_text_editor_tool menyediakan antarmuka pengeditan teks minimal yang digunakan oleh Skills. Fungsi ini mendukung tiga perintah, yaitu create (untuk menulis file baru dengan file_text), view (untuk mengembalikan hingga 1.000 karakter dari sebuah file), dan str_replace (untuk mengganti dengan new_str di tempat). Fungsi ini juga otomatis membuat folder induk untuk create, memeriksa keberadaan file untuk view dan str_replace, serta menulis pembaruan kembali ke disk.

Fungsi pembantu ini memungkinkan Anda menyelesaikan loop penggunaan tool secara lokal dengan pagar pengaman. Kini, Skill dapat meminta pengeditan file atau aksi shell selama pembuatan faktur tanpa membahayakan sistem Anda.

Langkah 5: Memanggil Skill via API 

Langkah ini menjalankan pembuatan faktur ujung ke ujung melalui Claude Messages API. Kode mengirim permintaan terstruktur, mengaktifkan penggunaan tool, melakukan iterasi atas panggilan tool yang diminta Claude, dan akhirnya mengumpulkan berkas PDF yang dihasilkan dari direktori kerja dan direktori temp.

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

Fungsi generate_invoice_with_claude mengirim faktur yang telah dinormalisasi ke Claude API dan menjalankan Skill hingga selesai. Berikut yang dilakukan kode:

• Membangun user_text yang jelas berisi klien, periode, mata uang, syarat, line item, dan entri timesheet, plus persyaratan keluaran eksplisit seperti header, tabel, total, dan nama berkas.

• Lalu mengaktifkan eksekusi tool dengan mendeklarasikan bash_number dan text_editor_number dengan loop pesan yang sadar tool: mengirim permintaan, memeriksa stop_reason, dan saat tool_use diminta, meneruskan ke pembantu lokal dan mengembalikan blok tool_result untuk melanjutkan pertukaran.

• Terakhir, berhenti pada end_turn atau ketika batas loop tercapai, lalu memindai direktori kerja dan direktori temp OS untuk berkas yang cocok dengan invoice*.pdf. Kode menyalin artefak temp kembali ke folder proyek dan mengembalikan daftar PDF yang ditemukan.

• Fungsi main menyediakan perintah CLI sederhana: python app.py <timesheet.xlsx>, yang memvalidasi path input, lalu menjalankan pipeline: load_invoice_from_timesheet(...) untuk membangun payload, dan generate_invoice_with_claude(...) untuk memanggil Skill dan mengumpulkan PDF.

Dengan ini, panggilan API seharusnya menghasilkan PDF yang siap untuk klien. Jika tidak ada berkas yang muncul, tinjau log tool_result dan konfigurasi Skill, lalu coba lagi dengan lembar uji kecil.

Kesimpulan

Sekarang Anda memiliki Auto-Invoice Generator yang berfungsi dengan daya Claude Skills, dan API mampu mengubah spreadsheet mentah menjadi faktur siap untuk klien. Demo ini menampilkan keunggulan Skills: penyiapan portabel, aktivasi otomatis, eksekusi kode yang deterministik, dan hasil yang konsisten di aplikasi dan API tanpa perlu membuat ulang prompt di setiap thread. Claude Skills menghasilkan keluaran yang konsisten lintas konteks, yaitu pengetahuan domain yang dapat digunakan kembali dan didukung kode. Meskipun Skills dapat mengeksekusi kode, Anda tetap harus menegakkan keamanan dengan hanya mengaktifkan Skills tepercaya, menggunakan kontrol tingkat organisasi, dan meninjau pembaruan sebelum peluncuran.

Untuk melangkah lebih jauh, jelajahi dokumentasi Skills Anthropic dan Console untuk versi dan peningkatan, lalu mulailah mengomposisi beberapa Skills untuk membangun alur kerja ujung ke ujung.