Inside Claude Skills: Custom Modules That Extend Claude

Claude डेवलपर प्लेटफ़ॉर्म (API)

Claude Skills तक Claude API के माध्यम से भी पहुँचा जा सकता है। इस खंड में, हम देखेंगे कि Claude API के जरिए Claude ऐप इंटरफ़ेस जैसा व्यवहार कैसे किया जा सकता है।

चरण 1: पूर्वापेक्षाएँ

सभी रनटाइम डिपेंडेंसियाँ इंस्टॉल करके शुरू करें:

• Anthropic Claude Messages API के लिए

• pandas और openpyxl Excel से टाइमशीट पढ़ने के लिए

• reportlab लोकली एक फ़ॉलबैक PDF इनवॉइस बनाने के लिए 

!pip -q install anthropic pandas openpyxl reportlabसंचालित द्वारा

अब हमारी सभी डिपेंडेंसियाँ इंस्टॉल हो गई हैं। अगला कदम है हमारी API कुंजी को कॉन्फ़िगर करना।

चरण 2: अपनी API कुंजी कॉन्फ़िगर करें

Messages API कॉल करने से पहले, हमें प्रमाणीकरण करना होगा। यह चरण API कुंजी के साथ एक एकल, पुन: उपयोग योग्य 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)संचालित द्वारा

Anthropic Console में लॉगिन करें और Settings के अंतर्गत API keys टैब ढूँढें। Create Key पर क्लिक करें और अपनी Anthropic API कुंजी कॉपी करें।

स्रोत: Anthropic API

ध्यान दें: यदि आप व्यक्तिगत उपयोग के लिए कोई निजी नोटबुक इस्तेमाल कर रहे हैं, तो वहाँ अपनी API कुंजी जोड़ें। अन्यथा, किसी सुरक्षित environment variable का उपयोग करें ताकि आपकी कुंजी नोटबुक या लॉग्स में उजागर न हो।

ऊपर दिया कोड Anthropic SDK क्लाइंट को इनिशियलाइज़ करता है और वातावरण सेट करता है। यह क्लाइंट ऑब्जेक्ट आगे होने वाली सभी Messages API कॉल्स के लिए पुन: उपयोग किया जाता है।

चरण 3: डेटा का प्रीप्रोसेसिंग

इस चरण में, हम अपनी timesheet.xlsx शीट को एक साफ़-सुथरे, अनुमानित JSON ऑब्जेक्ट में बदलेंगे जिसे Skill उपभोग कर सके। इससे डाउनस्ट्रीम लॉजिक सरल रहता है और नाज़ुक प्रॉम्प्ट पार्सिंग से बचा जा सकता है।

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": "[email protected]",
        "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
    }संचालित द्वारा

load_invoice_from_timesheet फ़ंक्शन अपलोड की गई Excel फ़ाइल को एक सामान्यीकृत इनवॉइस JSON पेलोड में बदल देता है।

• यह pandas से Excel पढ़ता है और कॉलम हेडर सामान्यीकृत करता है।

• इसके बाद कोड एक regex और माह पार्सिंग का उपयोग कर पहली Date पंक्ति (यदि हो) से invoice_period निकालता है।

• अंत में यह केस-इनसेंसिटिव ढंग से आर्टिकल टाइटल, अमाउंट और टॉपिक के कॉलम नामों का पता लगाता है।

• यह दो स्ट्रक्चर्स एमिट करता है:

• line_items: बिलिंग गणना के लिए (यहाँ प्रति आर्टिकल फ्लैट रेट)।

• timesheet: एक समतल सूची {title, topic} प्रविष्टियों की, वैकल्पिक परिशिष्ट के लिए।

• regex (\d{2})\s+(\w+)\s+(\d{4}) जैसे फ़ॉर्मैट की अपेक्षा करता है: 01 Oct 2025—अगर आपकी शीट में दूसरा फ़ॉर्मैट है, तो उसे अनुसार समायोजित करें।

• मिसिंग कॉलम/मान खाली पंक्तियाँ छोड़कर संभाले जाते हैं, या आवश्यकता हो तो आप कोड को फेल-फास्ट करने के लिए बढ़ा सकते हैं।

अब हमारा इनपुट तैयार है। अगला कदम, हम API के जरिए Claude Skill को कॉल करेंगे ताकि प्रोसेस की गई टाइमशीट को एडिटेबल इनवॉइस में बदला जा सके।

चरण 4: सहायक फ़ंक्शंस

इस खंड में, हम दो हेल्पर फ़ंक्शंस परिभाषित करते हैं जो Skill रन के दौरान Claude द्वारा अनुरोधित टूल निष्पादन का सिमुलेशन करते हैं। 

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)}"संचालित द्वारा

execute_bash_tool फ़ंक्शन Skill-चालित क्रियाओं के लिए एक सुरक्षित bash टूल का सिमुलेशन करता है। यह पहले rm -rf /, sudo, chmod, mkfs आदि जैसे खतरनाक पैटर्न को ब्लॉक करता है और फिर subprocess.run() के साथ OS के टेम्प डायरेक्टरी में 30 सेकंड की टाइमआउट सीमा के साथ कमांड चलाता है।

execute_text_editor_tool फ़ंक्शन Skills द्वारा उपयोग किया जाने वाला एक न्यूनतम टेक्स्ट-एडिटिंग इंटरफ़ेस उपलब्ध कराता है। यह तीन कमांड सपोर्ट करता है: create (नई फ़ाइल को file_text के साथ लिखना), view (किसी फ़ाइल के अधिकतम 1,000 अक्षर लौटाना), और str_replace (स्थान पर new_str)। यह create के लिए पैरेंट फोल्डर्स ऑटो-क्रिएट करता है, view और str_replace के लिए फ़ाइल का अस्तित्व जाँचता है, और अपडेट्स को डिस्क पर लिखता है।

ये हेल्पर्स आपको गार्डरेल्स के साथ लोकली टूल-यूज़ लूप पूरा करने देते हैं। अब Skill इनवॉइस जेनरेशन के दौरान फ़ाइल एडिट्स या शेल एक्शंस का अनुरोध कर सकता है, बिना आपकी सिस्टम सुरक्षा से समझौता किए।

चरण 5: API के माध्यम से Skill इनवोक करें 

यह चरण Claude Messages API के माध्यम से एंड-टू-एंड इनवॉइस जेनरेशन कराता है। यह एक संरचित अनुरोध भेजता है, टूल उपयोग को सक्षम करता है, Claude द्वारा अनुरोधित किसी भी टूल कॉल पर इटरेट करता है, और अंत में वर्किंग व टेम्प डायरेक्टरी से जेनरेटेड PDF फ़ाइलें इकट्ठा करता है।

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()संचालित द्वारा

generate_invoice_with_claude फ़ंक्शन सामान्यीकृत इनवॉइस को Claude API को भेजता है और Skill निष्पादन को एंड-टू-एंड चलाता है। कोड यह करता है:

• एक स्पष्ट user_text बनाता है जो क्लाइंट, पीरियड, करेंसी, टर्म्स, लाइन आइटम्स और टाइमशीट प्रविष्टियों को एम्बेड करता है, साथ ही हैडर, टेबल्स, टोटल्स और फ़ाइलनाम जैसे आउटपुट आवश्यकताएँ भी स्पष्ट करता है।

• फिर यह टूल निष्पादन सक्षम करता है—एक bash_number और text_editor_number घोषित करके—और टूल-अवेयर मैसेज लूप के साथ अनुरोध पोस्ट करता है, stop_reason देखता है, और जब tool_use माँगा जाता है तो लोकल हेल्पर्स को डिस्पैच कर tool_result ब्लॉक्स लौटाकर विनिमय जारी रखता है।

• अंततः, यह end_turn पर या लूप लिमिट पहुँचने पर रुकता है, फिर वर्किंग डायरेक्टरी और OS टेम्प डायरेक्टरी में invoice*.pdf से मेल खाती फ़ाइलें स्कैन करता है। यह किसी भी टेम्प आर्टिफैक्ट को प्रोजेक्ट फोल्डर में कॉपी करता है और मिली PDFs की सूची लौटाता है।

• main फ़ंक्शन एक सरल CLI कमांड देता है: python app.py <timesheet.xlsx>—जो इनपुट पाथ मान्य करता है, फिर पाइपलाइन चलाता है: पेलोड बनाने के लिए load_invoice_from_timesheet(...), और Skill इनवोक कर PDFs इकट्ठा करने के लिए generate_invoice_with_claude(...)।

इसके साथ, API कॉल को क्लाइंट-रेडी PDF तैयार करना चाहिए। यदि कोई फ़ाइल न दिखे, तो tool_result लॉग्स और Skill कॉन्फ़िगरेशन की जाँच करें, फिर किसी छोटी टेस्ट शीट के साथ पुनः प्रयास करें।

निष्कर्ष

अब आपके पास Claude Skills द्वारा संचालित एक कार्यशील ऑटो-इनवॉइस जेनरेटर है, और API कच्ची स्प्रेडशीट्स को क्लाइंट-रेडी इनवॉइस में बदलने में सक्षम है। यह डेमो Skills की ताकत दर्शाता है—पोर्टेबल सेटअप, ऑटो-एक्टिवेशन, निर्धारक कोड निष्पादन, और ऐप व API में सुसंगत नतीजे—बिना हर थ्रेड में प्रॉम्प्ट दोहराए। Claude Skills संदर्भों के पार सुसंगत आउटपुट लौटाते हैं—जो पुन: प्रयोज्य डोमेन नॉलेज और कोड-बैक्ड होते हैं। भले ही Skills कोड चला सकती हैं, फिर भी आपको केवल भरोसेमंद Skills सक्षम करके, संगठन-स्तरीय नियंत्रणों का उपयोग करके, और रोलआउट से पहले अपडेट की समीक्षा करके सुरक्षा लागू करनी चाहिए।

आगे बढ़ने के लिए, Anthropic के Skills दस्तावेज़ और Console में वर्ज़निंग व अपग्रेड्स देखें, फिर कई Skills को जोड़कर एंड-टू-एंड वर्कफ़्लो बनाना शुरू करें।