Claude Agent SDK ट्यूटोरियल: Python और TypeScript के उदाहरण

Claude Agent SDK आपको वही एजेंट लूप अपने Python या TypeScript प्रोग्राम के अंदर से चलाने देता है, जो Claude Code को चलाता है। आप एक प्रॉम्प्ट भेजते हैं, और जब तक काम पूरा नहीं होता, Claude फ़ाइलें पढ़ता है, कमांड चलाता है, कोड एडिट करता है और आपके अपने फ़ंक्शन कॉल करता है। वह हर कदम काम करते हुए आपको स्ट्रीम करके लौटाता रहता है। यह ट्यूटोरियल SDK को परतों में बनाता है: हर भाषा में पहली क्वेरी, कस्टम टूल्स, सबएजेंट्स, हुक्स, खर्च की सीमा और फिर से शुरू होने वाले सेशन। हर स्निपेट मौजूदा डॉक्यूमेंटेशन के अनुसार है, इसलिए आप उसे पेस्ट कर सकते हैं, एक एनवायरनमेंट वेरिएबल सेट कर सकते हैं और चला सकते हैं।

Agent SDK क्या करता है

एजेंट एक ऐसा प्रोग्राम है जो अपना अगला कदम खुद तय करता है। वह अनुरोध पढ़ता है, कोई टूल चुनता है, नतीजा देखता है और तब तक आगे बढ़ता रहता है जब तक काम पूरा न हो जाए। Agent SDK यह लूप आपको पहले से तैयार देता है: वही बिल्ट-इन टूल्स, परमिशन सिस्टम, कॉन्टेक्स्ट हैंडलिंग और हुक्स, जो Claude Code के अंदर चलते हैं, Python और TypeScript के लिए लाइब्रेरी के रूप में।

रॉ API को कॉल करने से असली फ़र्क यह है कि लूप कौन लिखता है। Client SDK के साथ आप एक मैसेज भेजते हैं, जाँचते हैं कि Claude ने कोई टूल माँगा है या नहीं, उसे चलाते हैं, नतीजा वापस भेजते हैं और दोहराते हैं। Agent SDK के साथ आप query() को एक बार कॉल करते हैं और Claude काम करते समय जो मैसेज स्ट्रीम करता है, उन पर इटरेट करते हैं।

लूप का हर चक्र एक ही लय में चलता है। Claude प्रॉम्प्ट और टूल की परिभाषाएँ पाता है, फिर तय करता है कि जवाब दे या कोई टूल कॉल करे। SDK टूल चलाता है और नतीजा वापस देता है, और यह चक्र तब तक दोहराया जाता है जब तक Claude के पास करने को कुछ न बचे या कोई सीमा उसे रोक न दे। हर कदम आपके कोड तक एक मैसेज के रूप में पहुँचता है, इसीलिए नीचे के उदाहरण एक ही रिक्वेस्ट-और-रिस्पॉन्स की बजाय स्ट्रीम प्रोसेसिंग जैसे दिखते हैं। इसका मतलब है कि आप यूज़र को प्रगति दिखा सकते हैं, हर टूल कॉल लॉग कर सकते हैं या बीच में रोक सकते हैं।

SDK, Client SDK या CLI

चार विकल्प एक-जैसे लगते हैं, इसलिए यह टेबल उन्हें इस आधार पर छाँटती है कि एजेंट कौन चलाता है।

💡 टिप: उसी लूप को किसी दूसरी भाषा से चलाने के लिए CLI को -p फ़्लैग और --output-format json के साथ सबप्रोसेस के रूप में चलाएँ।

पहले क्या चाहिए

पहली लाइन कोड लिखने से पहले तीन चीज़ें तैयार होनी चाहिए:

• Python 3.10+ या Node.js 18+
• एक Anthropic अकाउंट, जिसके लिए Claude Console से API क्रेडेंशियल मिला हो
• कोड का एक फ़ोल्डर जिस पर एजेंट काम करेगा, क्योंकि डिफ़ॉल्ट रूप से वह अपनी वर्किंग डायरेक्टरी और उसके सबडायरेक्टरी की फ़ाइलें पढ़ सकता है

दोनों पैकेज एक नेटिव Claude Code बाइनरी साथ लेकर आते हैं, इसलिए सामान्य इंस्टॉल में कुछ और नहीं चाहिए। दो स्थितियाँ इसे तोड़ती हैं: pip का source distribution पर वापस आ जाना (आम तौर पर ARM64 Windows पर) और npm इंस्टॉल का optional dependencies छोड़ देना। दोनों में Claude Code को नेटिव रूप से इंस्टॉल करें, तब SDK उसे खुद ढूँढ लेगा।

इंस्टॉल और ऑथेंटिकेट करें

पैकेज इंस्टॉल करें

Python के लिए, एक वर्चुअल एनवायरनमेंट बनाएँ और पैकेज इंस्टॉल करें:

python3 -m venv .venv
source .venv/bin/activate
pip install claude-agent-sdk

प्रॉम्प्ट कॉपी करें

Windows PowerShell पर एक्टिवेशन लाइन .venv\Scripts\Activate.ps1 है। TypeScript के लिए, एक प्रोजेक्ट शुरू करें और पैकेज के साथ tsx जोड़ें:

npm init -y
npm pkg set type=module
npm install @anthropic-ai/claude-agent-sdk
npm install --save-dev tsx

प्रॉम्प्ट कॉपी करें

"type": "module" सेट करने से आपकी स्क्रिप्ट में टॉप-लेवल await की अनुमति मिलती है, और tsx TypeScript फ़ाइलों को बिना बिल्ड स्टेप के चलाता है।

अपने क्रेडेंशियल सेट करें

SDK आपका क्रेडेंशियल उस शेल के एनवायरनमेंट वेरिएबल से पढ़ता है जिसमें एजेंट चलता है:

export ANTHROPIC_API_KEY=your-api-key

प्रॉम्प्ट कॉपी करें

$env:ANTHROPIC_API_KEY = "your-api-key"

प्रॉम्प्ट कॉपी करें

SDK अपने आप .env फ़ाइलें लोड नहीं करता। अगर आपका क्रेडेंशियल किसी ऐसी फ़ाइल में है, तो पहले उसे python-dotenv से या dotenv पैकेज से लोड करें। क्लाउड प्रोवाइडर भी काम करते हैं: Amazon Bedrock के लिए CLAUDE_CODE_USE_BEDROCK=1, Google Cloud के लिए CLAUDE_CODE_USE_VERTEX=1 या Microsoft Foundry के लिए CLAUDE_CODE_USE_FOUNDRY=1 सेट करें, फिर उस प्रोवाइडर के क्रेडेंशियल कॉन्फ़िगर करें।

💡 पॉलिसी नोट: Anthropic की पूर्व स्वीकृति के बिना, SDK पर बने थर्ड-पार्टी प्रोडक्ट claude.ai लॉगिन या उसकी रेट लिमिट न दे सकते हैं। जो भी आप शिप करें, उसके लिए API क्रेडेंशियल इस्तेमाल करें।

दो भाषाओं में आपका पहला एजेंट

utils.py नाम की एक फ़ाइल बनाएँ जिसमें दो जानबूझकर किए गए बग हों। खाली सूची औसत को क्रैश करती है, और गायब यूज़र के लिए नाम लुकअप को क्रैश करता है:

def calculate_average(numbers):
    total = 0
    for num in numbers:
        total += num
    return total / len(numbers)


def get_user_name(user):
    return user["name"].upper()

प्रॉम्प्ट कॉपी करें

नीचे का एजेंट केवल-पढ़ने वाला है। वह फ़ाइल देख सकता है, लेकिन उसे कुछ बदलने की परमिशन नहीं है।

Python वर्ज़न

import asyncio
from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    AssistantMessage,
    ResultMessage,
    TextBlock,
)


async def main():
    options = ClaudeAgentOptions(
        system_prompt="You review Python code and report crash risks in plain language.",
        allowed_tools=["Read", "Glob", "Grep"],
        max_turns=8,
    )

    async for message in query(
        prompt="Look at utils.py and list every input that would crash it.",
        options=options,
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    print(block.text)
        elif isinstance(message, ResultMessage):
            print(f"Finished: {message.subtype}, cost: ${message.total_cost_usd}")


asyncio.run(main())

प्रॉम्प्ट कॉपी करें

हर हिस्सा क्या करता है, वह इस तरह है:

• query() एक async iterator लौटाता है, इसलिए Claude के सोचने, टूल कॉल करने और नतीजे पढ़ने के दौरान आप async for से लूप चलाते हैं
• allowed_tools Read, Glob और Grep को पहले से मंज़ूरी देता है, ये तीन टूल्स फ़ाइलों की जाँच कर सकते हैं पर उन्हें कभी बदल नहीं सकते
• AssistantMessage ब्लॉक में Claude का टेक्स्ट और उसकी टूल कॉल होती हैं, इसलिए TextBlock के लिए फ़िल्टर करने से पढ़ने लायक आउटपुट मिलता है
• ResultMessage आख़िर में आता है, उसके साथ subtype, total_cost_usd, num_turns और session_id होते हैं

TypeScript वर्ज़न

इसे agent.ts के नाम से सेव करें और npx tsx agent.ts से चलाएँ:

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "Look at utils.py and list every input that would crash it.",
  options: {
    systemPrompt: "You review Python code and report crash risks in plain language.",
    allowedTools: ["Read", "Glob", "Grep"],
    maxTurns: 8
  }
})) {
  if (message.type === "assistant" && message.message?.content) {
    for (const block of message.message.content) {
      if ("text" in block) console.log(block.text);
    }
  } else if (message.type === "result") {
    console.log(`Finished: ${message.subtype}, cost: $${message.total_cost_usd}`);
  }
}

प्रॉम्प्ट कॉपी करें

दोनों में से कोई भी स्क्रिप्ट चलाएँ, और आपको दिखना चाहिए कि Claude utils.py पढ़ता है, दोनों क्रैश बताता है (खाली सूची पर शून्य से भाग और गायब यूज़र पर TypeError) और Finished: success जैसी लाइन के साथ खत्म करता है। अगर Not logged in जैसी ऑथेंटिकेशन एरर आए, तो मतलब है कि एनवायरनमेंट वेरिएबल उस शेल में नहीं है जिसने स्क्रिप्ट शुरू की, और यही पहली बार चलाने की सबसे आम गड़बड़ी है।

दोनों भाषाओं का लॉजिक एक जैसा है, पर विकल्पों के नाम के केस बदलते हैं। यह टेबल पास रखें, क्योंकि जब आप दोनों SDK के बीच कोड पोर्ट करते हैं, तो ज़्यादातर "यह काम क्यों नहीं कर रहा" वाले पल इसी से समझ आते हैं।

टूल्स की सूची से ही आप ऑटोनॉमी को बढ़ाते या घटाते हैं:

💡 दो व्यवहार जिनकी उम्मीद रखें: एक-बार वाला query() एरर नतीजा देने के बाद एक exception उठाता है, जैसे टर्न सीमा तक पहुँचने पर, इसलिए जब स्क्रिप्ट को चलते रहना हो तो लूप को try/except या try/catch में लपेटें। और डिफ़ॉल्ट रूप से SDK आपके प्रोजेक्ट का .claude/ फ़ोल्डर और ~/.claude/ पढ़ता है, ठीक वैसे जैसे CLI पढ़ता है, इसलिए वहाँ परिभाषित सेटिंग्स, स्किल्स और हुक्स आपके एजेंट पर भी लागू होते हैं।

कस्टम टूल्स बनाएँ

बिल्ट-इन टूल्स फ़ाइलें और शेल संभालते हैं। आपका अपना लॉजिक, जैसे डेटाबेस लुकअप या किसी इंटरनल API कॉल, एक कस्टम टूल में जाता है: एक फ़ंक्शन जो in-process MCP सर्वर में लिपटा होता है और आपके ऐप के अंदर चलता है, अलग प्रोसेस के रूप में नहीं।

एक टूल के चार हिस्से होते हैं: एक name, एक description जिसे Claude पढ़ता है ताकि तय कर सके कि उसे कब कॉल करना है, एक input schema, और एक async handler जो content ऐरे लौटाता है। विवरण ऐसे लिखें जैसे आप किसी नए सहकर्मी को काम समझा रहे हों।

सर्वर को mcp_servers के ज़रिए रजिस्टर करते हैं (TypeScript में mcpServers)। उस डिक्शनरी में आप सर्वर को जो नाम देते हैं, वह टूल के पूरे नाम का हिस्सा बन जाता है, और पैटर्न होता है mcp__{server}__{tool}। उस पूरे नाम को अपने allowed tools में डालें, तो कॉल बिना परमिशन प्रॉम्प्ट के चलती है।

एक Python टूल

import asyncio
from typing import Any
from claude_agent_sdk import (
    tool,
    create_sdk_mcp_server,
    query,
    ClaudeAgentOptions,
    ResultMessage,
)

ORDERS = {"A100": "shipped", "A101": "packing"}


@tool("get_order_status", "Look up the status of an order by its id", {"order_id": str})
async def get_order_status(args: dict[str, Any]) -> dict[str, Any]:
    status = ORDERS.get(args["order_id"])
    if status is None:
        return {
            "content": [{"type": "text", "text": f"No order {args['order_id']}"}],
            "is_error": True,
        }
    return {"content": [{"type": "text", "text": f"Order {args['order_id']}: {status}"}]}


shop_server = create_sdk_mcp_server(
    name="shop", version="1.0.0", tools=[get_order_status]
)


async def main():
    options = ClaudeAgentOptions(
        mcp_servers={"shop": shop_server},
        allowed_tools=["mcp__shop__get_order_status"],
    )
    async for message in query(prompt="Where is order A100?", options=options):
        if isinstance(message, ResultMessage) and message.subtype == "success":
            print(message.result)


asyncio.run(main())

प्रॉम्प्ट कॉपी करें

एक TypeScript टूल

TypeScript टूल इनपुट का वर्णन Zod से करता है, इसलिए पहले npm install zod चलाएँ:

import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const orders: Record<string, string> = { A100: "shipped", A101: "packing" };

const getOrderStatus = tool(
  "get_order_status",
  "Look up the status of an order by its id",
  { order_id: z.string().describe("Order id such as A100") },
  async (args) => {
    const status = orders[args.order_id];
    if (!status) {
      return {
        content: [{ type: "text", text: `No order ${args.order_id}` }],
        isError: true
      };
    }
    return { content: [{ type: "text", text: `Order ${args.order_id}: ${status}` }] };
  }
);

const shopServer = createSdkMcpServer({
  name: "shop",
  version: "1.0.0",
  tools: [getOrderStatus]
});

for await (const message of query({
  prompt: "Where is order A100?",
  options: {
    mcpServers: { shop: shopServer },
    allowedTools: ["mcp__shop__get_order_status"]
  }
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

प्रॉम्प्ट कॉपी करें

💡 टिप: किसी अपेक्षित विफलता के लिए, जैसे अज्ञात ऑर्डर आईडी, अपने संदेश के साथ is_error: True (isError: true TypeScript में) लौटाएँ। Claude वह संदेश पढ़ता है और दोबारा कोशिश कर सकता है या समझा सकता है, बजाय इसके कि उसे बस एक कच्ची एक्सेप्शन स्ट्रिंग मिले।

सबएजेंट्स, हुक्स और सीमाएँ

एक काम करने वाला एजेंट एक शुरुआत है। तीन फ़ीचर एक बड़े एजेंट को अनुमानित बनाए रखते हैं: सबएजेंट्स काम बाँटते हैं, हुक्स हर टूल कॉल पर नज़र रखते हैं, और सीमाएँ बेकाबू सेशन को रोकती हैं।

सबएजेंट्स को काम सौंपें

सबएजेंट एक अलग एजेंट इंस्टेंस है जिसे आपका मुख्य एजेंट किसी केंद्रित काम के लिए शुरू करता है। हर एक नए कॉन्टेक्स्ट से शुरू होता है, इसलिए एक रिव्यूअर मुख्य बातचीत को भारी किए बिना दर्जनों फ़ाइलें पढ़ सकता है, और पैरेंट तक केवल उसका आख़िरी मैसेज लौटता है। आप उन्हें agents विकल्प से परिभाषित करते हैं और allowed tools में Agent जोड़ते हैं।

हर परिभाषा में एक description (Claude को कब इसका इस्तेमाल करना चाहिए) और एक prompt (उसका व्यवहार) होना चाहिए। वैकल्पिक फ़ील्ड्स में tools शामिल है, जिससे तय होता है कि वह किन चीज़ों को छू सकता है, और model है, जो sonnet, opus, haiku, fable और inherit उपनाम स्वीकार करता है, या पूरा मॉडल ID।

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition


async def main():
    options = ClaudeAgentOptions(
        allowed_tools=["Read", "Grep", "Glob", "Agent"],
        agents={
            "code-reviewer": AgentDefinition(
                description="Reviews code for security and maintainability problems.",
                prompt="You are a careful reviewer. Report concrete problems with file names.",
                tools=["Read", "Grep", "Glob"],
                model="sonnet",
            ),
            "test-runner": AgentDefinition(
                description="Runs the test suite and summarizes failures.",
                prompt="Run the tests, then list each failing test with its error.",
                tools=["Bash", "Read", "Grep"],
            ),
        },
    )
    async for message in query(
        prompt="Use the code-reviewer agent to check the auth module",
        options=options,
    ):
        if hasattr(message, "result"):
            print(message.result)


asyncio.run(main())

प्रॉम्प्ट कॉपी करें

TypeScript वर्ज़न सादे ऑब्जेक्ट्स का इस्तेमाल करता है:

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "Use the code-reviewer agent to check the auth module",
  options: {
    allowedTools: ["Read", "Grep", "Glob", "Agent"],
    agents: {
      "code-reviewer": {
        description: "Reviews code for security and maintainability problems.",
        prompt: "You are a careful reviewer. Report concrete problems with file names.",
        tools: ["Read", "Grep", "Glob"],
        model: "sonnet"
      }
    }
  }
})) {
  if ("result" in message) console.log(message.result);
}

प्रॉम्प्ट कॉपी करें

जैसा ऊपर है, सबएजेंट का नाम अपने प्रॉम्प्ट में लेने से गारंटी होती है कि Claude उसका इस्तेमाल करेगा। उसके बिना Claude हर description से काम का मिलान करता है, इसलिए अस्पष्ट विवरण का मतलब है कि काम सौंपा ही नहीं जाएगा।

💡 वर्ज़न नोट: टूल यूज़ ब्लॉक में यह टूल Agent के नाम से दिखता है। पुराने वर्ज़न इसे Task कहते थे, और init मैसेज की टूल सूची अब भी यही नाम रखती है, इसलिए मैसेज स्ट्रीम में सबएजेंट कॉल पहचानते समय दोनों नाम मिलाएँ।

जोखिम भरी कॉल्स को हुक्स से रोकें

हुक्स वे कॉलबैक हैं जो एजेंट लूप के तय बिंदुओं पर चलते हैं। सबसे उपयोगी है PreToolUse, जो टूल चलने से पहले फ़ायर होता है और उसे मना कर सकता है। matcher टूल के नाम से फ़िल्टर करता है, जैसे Bash या Write|Edit। कॉल की अनुमति देने के लिए {} लौटाएँ।

यह Python हुक किसी भी ऐसे शेल कमांड को रोकता है जिसमें रिकर्सिव डिलीट हो:

import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, HookMatcher


async def block_destructive_bash(input_data, tool_use_id, context):
    command = input_data["tool_input"].get("command", "")
    if "rm -rf" in command:
        return {
            "hookSpecificOutput": {
                "hookEventName": input_data["hook_event_name"],
                "permissionDecision": "deny",
                "permissionDecisionReason": "Recursive deletes are blocked",
            }
        }
    return {}


async def main():
    options = ClaudeAgentOptions(
        allowed_tools=["Bash", "Read"],
        hooks={
            "PreToolUse": [HookMatcher(matcher="Bash", hooks=[block_destructive_bash])]
        },
    )

    async with ClaudeSDKClient(options=options) as client:
        await client.query("Clean up the build folder")
        async for message in client.receive_response():
            print(message)


asyncio.run(main())

प्रॉम्प्ट कॉपी करें

और TypeScript में वही गार्ड:

import { query, HookCallback, PreToolUseHookInput } from "@anthropic-ai/claude-agent-sdk";

const blockDestructiveBash: HookCallback = async (input) => {
  const pre = input as PreToolUseHookInput;
  const toolInput = pre.tool_input as Record<string, unknown>;
  const command = String(toolInput?.command ?? "");

  if (command.includes("rm -rf")) {
    return {
      hookSpecificOutput: {
        hookEventName: pre.hook_event_name,
        permissionDecision: "deny",
        permissionDecisionReason: "Recursive deletes are blocked"
      }
    };
  }
  return {};
};

for await (const message of query({
  prompt: "Clean up the build folder",
  options: {
    allowedTools: ["Bash", "Read"],
    hooks: { PreToolUse: [{ matcher: "Bash", hooks: [blockDestructiveBash] }] }
  }
})) {
  if (message.type === "result") console.log(message.subtype);
}

प्रॉम्प्ट कॉपी करें

जब कई हुक मेल खाते हैं, तो वे समानांतर चलते हैं और सबसे सख़्त जवाब जीतता है। एक भी deny दूसरों के जो भी लौटाएँ, कॉल को रोक देता है, इसलिए हर हुक को अकेले काम करने लायक लिखें।

टर्न और खर्च की सीमा तय करें

परमिशन मोड डिफ़ॉल्ट भरोसे का स्तर तय करते हैं। permission_mode या permissionMode से एक चुनें:

दो संख्यात्मक सीमाएँ आपके बजट की रक्षा करती हैं। max_turns (maxTurns) एजेंटिक टर्न को सीमित करता है, और max_budget_usd (maxBudgetUsd) अनुमानित खर्च को सीमित करता है। इन सीमाओं तक पहुँचने पर क्वेरी error_max_turns या error_max_budget_usd रिज़ल्ट सबटाइप के साथ खत्म होती है। सबएजेंट के अनुरोध उसी total_cost_usd में गिने जाते हैं, इसलिए जो प्रॉम्प्ट कई सबएजेंट्स में बँटता है, वह भी उसी सीमा से बँधा रहता है।

💡 बिना निगरानी वाले कामों के लिए टिप: dontAsk को स्पष्ट allowed-tools सूची के साथ इस्तेमाल करें। सूची से बाहर की कोई भी चीज़ तुरंत अस्वीकार हो जाती है, किसी ऐसे इंसान का इंतज़ार नहीं करती जो वहाँ है ही नहीं।

पहले एजेंट्स में तीन गलतियाँ बार-बार दिखती हैं:

• Bash को बहुत जल्दी दे देना। केवल-पढ़ने वाले टूल्स से शुरू करें और Edit या Bash तभी जोड़ें जब काम की ज़रूरत हो।
• सबएजेंट्स के अस्पष्ट विवरण। Claude description टेक्स्ट के आधार पर काम सौंपता है, इसलिए "helper agent" नज़रअंदाज़ हो जाता है, जबकि "Reviews code for security problems" इस्तेमाल हो जाता है।
• पहली बार चलाते समय कोई सीमा नहीं। किसी बड़े रिपॉज़िटरी पर एजेंट को भेजने से पहले max_turns और max_budget_usd सेट करें।

सेशन के बीच कॉन्टेक्स्ट बनाए रखें

हर query() कॉल एक नया सेशन शुरू करती है। जब फ़ॉलो-अप को याद रखना हो कि एजेंट ने पहले क्या पढ़ा और तय किया, तब सेशन को आगे ले जाने का तरीका चाहिए।

Python में मल्टी-टर्न

ClaudeSDKClient सेशन को आपके लिए ट्रैक करता है। हर client.query() उसी बातचीत को आगे बढ़ाता है:

import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions


async def main():
    options = ClaudeAgentOptions(allowed_tools=["Read", "Edit", "Glob", "Grep"])

    async with ClaudeSDKClient(options=options) as client:
        await client.query("Inspect the auth module")
        async for message in client.receive_response():
            print(message)

        # Same session, so the agent remembers the first answer
        await client.query("Now refactor it to use JWT")
        async for message in client.receive_response():
            print(message)


asyncio.run(main())

प्रॉम्प्ट कॉपी करें

TypeScript में फिर से शुरू करना

TypeScript में कोई क्लाइंट ऑब्जेक्ट नहीं है, इसलिए आप रिज़ल्ट मैसेज से session_id लेते हैं और उसे resume से वापस पास करते हैं:

import { query } from "@anthropic-ai/claude-agent-sdk";

let sessionId: string | undefined;

for await (const message of query({
  prompt: "Inspect the auth module",
  options: { allowedTools: ["Read", "Glob", "Grep"] }
})) {
  if (message.type === "result") sessionId = message.session_id;
}

for await (const message of query({
  prompt: "Now propose a refactor based on what you found",
  options: { resume: sessionId, allowedTools: ["Read", "Glob", "Grep"] }
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

प्रॉम्प्ट कॉपी करें

Python में वही विचार resume=session_id के रूप में आता है। दोनों भाषाएँ continue_conversation=True / continue: true भी सपोर्ट करती हैं, जो फ़ोल्डर के सबसे हाल के सेशन को उठाते हैं, और fork_session=True / forkSession: true भी, जो इतिहास की एक कॉपी को ब्रांच करते हैं ताकि आप मूल को खोए बिना कोई दूसरा तरीका आज़मा सकें।

व्यवहार में दो सीमाएँ मायने रखती हैं। सेशन बातचीत को स्टोर करते हैं, आपकी फ़ाइलों को नहीं, इसलिए ब्रांच किया गया एजेंट जो कोड एडिट करता है, वह असली फ़ाइलें बदल देता है। और सेशन फ़ाइलें उसी मशीन पर रहती हैं जिसने उन्हें बनाया, इसलिए किसी दूसरे होस्ट पर फिर से शुरू करने के लिए सेशन स्टोर एडैप्टर या कॉपी किया गया ट्रांसस्क्रिप्ट चाहिए।

PicassoIA पर Claude Sonnet 5 का इस्तेमाल

Agent SDK आपकी अपनी मशीन पर आपके अपने क्रेडेंशियल से चलता है, इसलिए PicassoIA उसकी जगह नहीं लेता। PicassoIA वहाँ मदद करता है जहाँ ड्राफ़्टिंग होती है। सिस्टम प्रॉम्प्ट, सबएजेंट विवरण या टूल विवरण के शब्द ही तय करते हैं कि एजेंट कितना अच्छा व्यवहार करेगा, और चैट फ़ॉर्म में शब्दों को आज़माना स्क्रिप्ट को दस बार चलाने से तेज़ है।

कोड लिखने से पहले प्रॉम्प्ट ड्राफ़्ट करें

Claude Sonnet 5 मल्टी-स्टेप कोडिंग और टूल-यूज़ कामों के लिए बना है, इसलिए एजेंट के निर्देशों को परखने के लिए यह एक उचित विकल्प है। इन चरणों का पालन करें:

1. PicassoIA पर Claude Sonnet 5 पेज खोलें।
2. अपने एजेंट निर्देशों का ड्राफ़्ट System Prompt फ़ील्ड में पेस्ट करें।
3. Prompt में एक वास्तविक काम लिखें, उदाहरण के लिए utils.py की सामग्री प्लस "हर ऐसा इनपुट बताएँ जिससे यह क्रैश हो सकता है"।
4. effort सेट करें। डिफ़ॉल्ट low है, जो सबसे तेज़ और सस्ता जवाब देने के लिए थिंकिंग बंद रखता है। कई फ़ाइलों में फैले बगों के लिए इसे high या max पर ले जाएँ।
5. max_tokens को डिफ़ॉल्ट 8192 पर छोड़ें, जो एक जवाब में विस्तृत कोड या टेक्स्ट के लिए काफ़ी है।
6. चाहें तो image इनपुट से किसी एरर का स्क्रीनशॉट जोड़ें, क्योंकि मॉडल उसे पढ़ सकता है।
7. चलाएँ, शब्दों को तब तक कसें जब तक जवाब आपकी चाहत से मेल न खाए, फिर अंतिम टेक्स्ट को system_prompt या सबएजेंट के prompt में कॉपी करें।

💡 याद रखें: यह केवल शब्दों को परखता है। फ़ाइल टूल्स, हुक्स और एजेंट लूप अब भी आपकी मशीन पर SDK से ही आते हैं।

सही Claude मॉडल चुनें

PicassoIA पर कई Claude मॉडल हैं, और हर एक अलग ड्राफ़्टिंग काम के लिए ठीक है:

SDK में खुद model फ़ील्ड ऊपर बताए उपनाम लेता है, इसलिए आप रूटीन सबएजेंट्स के लिए सस्ता मॉडल और मुख्य थ्रेड के लिए ज़्यादा मज़बूत मॉडल चला सकते हैं।

PicassoIA के साथ अपनी इमेज बनाएँ

अब आपके पास एक काम करने वाला एजेंट है, और हर हिस्से को शिप करने से पहले परखने की आदत भी। यही आदत इमेज जनरेशन को भी बेहतर बनाती है, और PicassoIA उसे आज़माने की एक तेज़ जगह है।

Seedream 4.5 या GPT Image 2 खोलें और इस लेख की फ़ोटो में इस्तेमाल हुई उसी संरचना में प्रॉम्प्ट लिखें: सब्जेक्ट और उसकी क्रिया, सेटिंग, रोशनी की दिशा, लेंस, और एक या दो सतह की बनावटें। "hands typing at a wooden desk, soft window light from the right, 85mm lens, shallow depth of field, visible dust on the wood grain" जैसी लाइन मॉडल को "टाइप करता प्रोग्रामर" से कहीं ज़्यादा सामग्री देती है।

इसे अगले ब्लॉग हेडर, प्रोडक्ट शॉट या डॉक्यूमेंटेशन बैनर पर आज़माएँ जिसकी आपको ज़रूरत हो। हर बार एक ही विवरण बदलें, नतीजों की साथ-साथ तुलना करें और जो प्रॉम्प्ट काम करे उसे रखें। जब आप देखना चाहें कि और क्या उपलब्ध है, तो picassoia.com/en/all-models पर हर मॉडल ब्राउज़ करें और आज ही अपनी पहली जनरेशन शुरू करें।