Grok 4.6 API: पहली कॉल से टूल‑यूज़िंग एजेंट तक

Python में Grok 4.6 API कैसे सेटअप करें?

शुरू करने के लिए, आपको SpaceXAI API कुंजी चाहिए और xai-sdk इंस्टॉल करनी होगी।

console.x.ai से API कुंजी प्राप्त करना

Grok 4.6 API कुंजी बनाने के लिए, हम SpaceX AI कंसोल API कुंजी निर्माण पेज पर जाते हैं। फिर, ऊपर दाईं ओर Create API Key बटन पर क्लिक करते हैं।

API कुंजी निर्माण फॉर्म सरल है। हम कुंजी को एक नाम देते हैं ताकि पता रहे कि यह किस प्रोजेक्ट की है। मैं यह भी सलाह दूंगा कि API कुंजियों के लिए हमेशा एक्सपायरी डेट सेट करें, ताकि उनके समझौता होने पर अतिरिक्त सुरक्षा बनी रहे।

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

.env फाइल में निम्न सामग्री होनी चाहिए:

XAI_API_KEY=replace_with_the_api_key

xai-sdk इंस्टॉल करना और SpaceXAI API कुंजी लोड करना

API कुंजी के साथ SpaceXAI से कनेक्ट करने के लिए हम xai-sdk पैकेज का उपयोग करते हैं। यह अच्छा अभ्यास है कि हर प्रोजेक्ट के लिए अलग एनवायरनमेंट बनाएं ताकि Python पैकेज अन्य प्रोजेक्ट्स के पैकेजों से न टकराएं। ऐसा करने के लिए, हम Anaconda के साथ निम्न कमांड का उपयोग करेंगे:

conda create -yn grok-46 python=3.10
``` 
This creates an environment named grok-46 that we can activate using:
```bash
conda activate grok-46

एक्टिव होने के बाद, हम इच्छित पैकेज इंस्टॉल कर सकते हैं। फिलहाल, शुरुआत करते हैं:

• xai-sdk: उनका आधिकारिक SpaceXAI पैकेज जिससे उनकी API को रिक्वेस्ट भेजी जाती हैं।

• python-dotenv: एक यूटिलिटी पैकेज जो .env फाइल से API कुंजी लोड करना आसान बनाता है।

इन्हें इंस्टॉल करने के लिए, कमांड चलाएं:

pip install xai-sdk python-dotenv

यहाँ देखें कि API कुंजी कैसे लोड करें और Python में SpaceXAI Client कैसे बनाएं:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

ध्यान दें कि यह कोड अभी कोई रिक्वेस्ट नहीं भेजता। हम आगे सीखेंगे कि यह कैसे किया जाता है।

SpaceXAI API क्रेडिट्स खरीदना

Grok 4.6 API का उपयोग करने के लिए, हमें उनके API प्लेटफ़ॉर्म पर क्रेडिट्स भी खरीदने होंगे। इनके बिना, API रिक्वेस्ट्स अस्वीकार हो जाएंगी। ऐसा करने के लिए, साइडबार के नीचे Credits पर जाएँ, Add credits पर क्लिक करें, और अपनी पसंद की राशि जोड़ें।

API के जरिए Grok 4.6 कितना महंगा है?

Grok 4.6 पर रिक्वेस्ट्स की बिलिंग प्रति टोकन होती है। बेस प्राइसिंग 1 मिलियन इनपुट टोकन पर $2 और 1 मिलियन आउटपुट टोकन पर $6 है।

यह ध्यान रखना महत्वपूर्ण है कि Grok 4.6 एक रीजनिंग मॉडल है। रीजनिंग स्वयं‑संवाद के रूप में होती है और टोकन खर्च करती है, जिनकी बिलिंग आउटपुट टोकन के रूप में होती है। हम आगे सीखेंगे कि किसी रिक्वेस्ट के लिए मॉडल जितना रीजनिंग करता है, उसे कैसे नियंत्रित करें।

कैश्ड टोकन काफी सस्ते होते हैं—केवल $0.5 प्रति मिलियन टोकन।

जैसा कि हम जानेंगे, Grok में तीन बिल्ट‑इन टूल्स हैं जिनकी बिलिंग टोकन्स से अलग से होती है: वेब सर्च, X सर्च, और कोड एक्ज़िक्यूशन। इन सबकी कीमत $5.00 प्रति 1,000 कॉल्स है।

लंबे कॉन्टेक्स्ट के लिए, यह ध्यान देने योग्य है कि 200K सीमा से अधिक प्रॉम्प्ट्स के सभी टोकन डबल रेट पर बिल किए जाते हैं।

अपनी पहली Grok 4.6 API कॉल कैसे करें?

आइए पिछले कोड पर आगे बढ़ते हुए SpaceXAI क्लाइंट का उपयोग करके Grok 4.6 को रिक्वेस्ट भेजें।

Grok 4.6 को रिक्वेस्ट भेजने के लिए, हम client.chat.create() से grok-4.6 लक्षित करते हुए एक चैट सेशन इनिशियलाइज़ करते हैं और chat.append(user()) से अपना प्रॉम्प्ट बातचीत के इतिहास में जोड़ते हैं।

अंत में, chat.sample() कॉल करने से बातचीत मॉडल को भेजी जाती है ताकि वह उत्तर जेनरेट करे, जिसे हम response.content प्रिंट करके दिखाते हैं।

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import user

load_dotenv()

client = Client()

chat = client.chat.create(model="grok-4.6")
chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

response = chat.sample()
print(response.content)

इस तरह Grok का उपयोग करने पर, हमें पूरा उत्तर एक साथ मिलता है, इसलिए तब तक इंतजार करना पड़ता है जब तक Grok पूरा उत्तर जेनरेट नहीं कर लेता। शब्द‑दर‑शब्द उत्तर पाने के लिए हम स्ट्रीमिंग का उपयोग कर सकते हैं। 

रिस्पॉन्स स्ट्रीमिंग

पूरे उत्तर का इंतजार करने के लिए chat.sample() की बजाय, हम chat.stream() का उपयोग कर सकते हैं ताकि मॉडल का आउटपुट रीयल‑टाइम में मिले।

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

यह कोड स्ट्रीम पर इटरेट करता है, इन्क्रीमेंटल चंक ऑब्जेक्ट्स देता है और जैसे ही नया टेक्स्ट (chunk.content) आता है, उसे कंसोल पर प्रिंट कर देता है—जिससे उत्तर का टोकन‑दर‑टोकन स्ट्रीमिंग अनुभव बनता है।

यह कोड चलाने पर हम नोटिस करते हैं कि मॉडल को टोकन प्रोड्यूस करना शुरू करने में कुछ समय लगता है। कारण यह है कि Grok 4.6 एक रीजनिंग मॉडल है। डिफ़ॉल्ट रूप से, अंतिम उत्तर का पहला दिखने योग्य शब्द जेनरेट करने से पहले, मॉडल एक आंतरिक "chain-of-thought" रीजनिंग चरण से गुजरता है।

हम ऊपर के कोड को अपडेट करके मॉडल की रीजनिंग प्रक्रिया भी दिखा सकते हैं, इस तरह:

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

print("--- Reasoning ---")
is_first_content = True

for response, chunk in chat.stream():
    if chunk.reasoning_content:
        print(chunk.reasoning_content, end="", flush=True)
    if chunk.content:
        if is_first_content:
            print("\n\n--- Response ---")
            is_first_content = False
        print(chunk.content, end="", flush=True)

print()

इस स्निपेट के बाद Grok 4.6 स्ट्रीम दो प्रकार के टोकन देती है:

• मॉडल की आंतरिक chain‑of‑thought टोकन
• अंतिम उत्तर

यह स्क्रिप्ट chunk.reasoning_content चेक करके दोनों के बीच फर्क करती है—पहले Grok की स्टेप‑बाय‑स्टेप सोच को स्ट्रीम करती है, और फिर जैसे ही अंतिम उत्तर शुरू होता है, chunk.content प्रिंट करती है।

Grok 4.6 में रीजनिंग प्रयास कैसे सेट करें?

जैसा कि हमने ऊपर देखा, अन्य फ्रंटियर AI मॉडलों की तरह, Grok 4.6 छिपी हुई chain of thought पर निर्भर करता है। अंतिम उत्तर का पहला शब्द आउटपुट करने से पहले, यह समाधान तलाशने, लॉजिक डबल‑चेक करने, और अपनी गलतियाँ सुधारने के लिए हजारों रीजनिंग टोकन जेनरेट करता है।

reasoning_effort पैरामीटर हमें यह नियंत्रित करने देता है कि मॉडल इस रीजनिंग प्रक्रिया में कितना प्रयास लगाए। क्योंकि हम केवल अंतिम उत्तर नहीं, बल्कि रीजनिंग टोकन के लिए भी भुगतान करते हैं, इसलिए लागत घटाने के लिए यह एक महत्वपूर्ण पैरामीटर है।

Grok 3 mini पहले से डेवलपर्स को reasoning_effort ट्यून करने देता था, लेकिन Grok 4 ने यह नियंत्रण हटा दिया था। इसकी रीजनिंग हमेशा ऑन रहती थी और समायोज्य नहीं थी। SpaceXAI ने Grok 4.x लाइन (4.3 और 4.5) में इसे फिर से जोड़ा, और Grok 4.6 भी इसे सपोर्ट करता है—low, medium, high (डिफ़ॉल्ट), और xhigh के साथ।

रीजनिंग प्रयास सेट करने के लिए, हम client.chat.create() से चैट इनिशियलाइज़ करते समय reasoning_effort पैरामीटर का उपयोग करते हैं। मान स्ट्रिंग होता है जिसमें वांछित प्रयास स्तर दर्ज करते हैं। डिफ़ॉल्ट मान "high" है। यहाँ एक उदाहरण है कि इसे "low" कैसे सेट करें:

chat = client.chat.create(
    model="grok-4.6",
    reasoning_effort="low"
)

एक ही प्रॉम्प्ट पर low बनाम high की तुलना

मैंने low और high दोनों रीजनिंग का उपयोग करके कई कार्य आजमाए, जैसे एक छोटा गेम बनाना, कई गलत फॉर्मेट वाली करेंसी के साथ पेरोल डेटा का विश्लेषण करने के लिए स्क्रिप्ट बनाना, और लॉजिक पहेलियाँ सुलझाना।

इन सभी मामलों में, मॉडल दोनों स्तरों पर समान समाधान देने में सक्षम था।

अंतर दिखाने के लिए हमें ऐसा कार्य चाहिए जहाँ बीच में रीजनिंग रुकने से असफलता हो। इसलिए मैंने कई समाधानों वाली एक पहेली चुनी। यह रहा प्रयुक्त प्रॉम्प्ट:

Solve the following alphametic puzzle, in which each letter represents a unique digit from 0 to 9. The leading digits cannot be zero.

GROK + DATA = CAMP

Provide a list of all solutions. For each solution, show a single line with the final addition to prove it works.

दोनों रीजनिंग स्तरों पर, Grok 4.6 ने सही समाधान ढूंढे। लेकिन low पर, कार्य पूरा करने से पहले उसका रीजनिंग बजट समाप्त हो गया। इसलिए उत्तर अधूरा रहा। उच्च स्तर की रीजनिंग पर, Grok 4.6 ने सभी 264 समाधान ढूंढ लिए।

तुलना के लिए, low रीजनिंग पर 16,422 रीजनिंग टोकन उपयोग हुए, जबकि high पर 56,455 टोकन।

xhigh अतिरिक्त टोकन्स कब वसूल है?

यदि हाई सेटिंग जटिल लॉजिक पहेलियाँ और डेटा‑पार्सिंग स्क्रिप्ट्स को ब्रूट‑फोर्स कर सकती है, तो कोई xhigh के विशाल टोकन उपभोग के लिए क्यों भुगतान करेगा?

मेरा मानना है कि रोज़मर्रा की 99% प्रोग्रामिंग और डेटा साइंस कार्यों के लिए xhigh आवश्यकता से अधिक है और केवल आपका API बजट तेजी से खर्च करेगा।

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

मेरी सलाह होगी कि low से शुरू करें और केवल तब बढ़ाएँ जब मॉडल किसी कार्य में व्यवस्थित रूप से असफल हो रहा हो। यह सही है कि कुछ मामलों में इसका मतलब एक ही समस्या के लिए कई बार भुगतान होगा, पर अधिकांश समय हम कम लागत में ही अच्छा समाधान पा लेंगे।

Grok 4.6 API को इमेजेज़ कैसे भेजें?

Grok 4.6 मल्टीमॉडल है और इसलिए इमेज डेटा संभाल सकता है। 

URL के जरिए इमेज भेजना

मॉडल को इमेज देने का सबसे आसान तरीका URL का उपयोग है। हम इसे यूज़र मैसेज में दूसरे आर्ग्युमेंट के रूप में दे सकते हैं:

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import image, user

load_dotenv()
client = Client()

chat = client.chat.create(model="grok-4.6")

image_url = "https://images.pexels.com/photos/25810993/pexels-photo-25810993.jpeg"

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=image_url),
    )
)

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

फाइल अपलोड के जरिए इमेज भेजना

अक्सर हम URLs के बजाय लोकल इमेज का उपयोग करना चाहते हैं। यह इमेज को base64 स्ट्रिंग के रूप में लोड करके किया जा सकता है। फ़ंक्शन encode_image() हमारे लिए यह कर सकता है:

import base64
import mimetypes

def encode_image(image_path: str) -> str:
    mime_type, _ = mimetypes.guess_type(image_path)
    if not mime_type:
        mime_type = "image/jpeg"
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return f"data:{mime_type};base64,{encoded_string}"

इमेज एन्कोड होने के बाद, हम उसे उसी तरह मॉडल को देते हैं:

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=encode_image("image.png")),
    )
)

इमेज इनपुट सपोर्ट होने के बावजूद, Grok 4.6 केवल टेक्स्ट आउटपुट देता है। यदि आप SpaceXAI इमेज जेनरेशन के बारे में और जानना चाहते हैं, तो हमारा Grok Imagine API ट्यूटोरियल पढ़ें।

Grok 4.6 एजेंट्स के साथ टूल्स कैसे सक्षम करूँ?

Grok 4.6 तीन उपयोगी सर्वर‑साइड टूल्स तक पहुँच देता है और कस्टम टूल्स बनाने की सुविधा भी देता है।

सर्वर‑साइड टूल्स कॉल करना (वेब सर्च, X सर्च, कोड एक्ज़िक्यूशन)

Grok 4.6 तीन सर्वर टूल्स के साथ आता है:

• वेब सर्च: एजेंट को उत्तर को ग्राउंड करने के लिए वेब सर्च करने देता है।
• X सर्च: X से रीयल‑टाइम प्लेटफ़ॉर्म डेटा क्वेरी करता है।
• कोड एक्ज़िक्यूशन: क्वेरी का उत्तर देने में मदद के लिए सैंडबॉक्स में कोड चलाता है।

ये टूल्स SpaceXAI सर्वर्स पर चलते हैं, और हर टूल कॉल की बिलिंग टोकन्स से स्वतंत्र रूप से होती है।

इन्हें सक्षम करने के लिए, हमें इन्हें इम्पोर्ट करना होगा और client.chat.create() के साथ चैट इंस्टैंस बनाते समय पास करना होगा:

from xai_sdk.tools import code_execution, web_search, x_search
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution()],
)

रिस्पॉन्सेस को स्ट्रीम करते समय, हम chunk.tool_calls फ्लैग चेक करके जान सकते हैं कि एजेंट कोई टूल उपयोग कर रहा है या नहीं।

यह रहा एक स्निपेट जो स्ट्रीमिंग रिस्पॉन्स को इस तरह प्रोसेस करता है कि यूज़र को पता चले एजेंट कब कोई टूल इस्तेमाल कर रहा है:

for response, chunk in chat.stream():
    for tool_call in chunk.tool_calls:
        print(f"\n--> Agent is calling tool: {tool_call.function.name}\n", flush=True)
    if chunk.content:
        print(chunk.content, end="", flush=True)

सर्वर टूल्स के साथ एक पूरा उदाहरण स्क्रिप्ट मेरे साथ वाले GitHub रेपो में मिल सकता है।

कस्टम लोकल टूल्स इम्प्लीमेंट करना

ऊपर दिए गए सर्वर टूल्स के अलावा, हम अपने Grok 4.6 एजेंट को कस्टम टूल्स भी दे सकते हैं। आइए देखें कि एजेंट को लोकल फाइलें पढ़ने और लिखने देने वाले टूल्स कैसे इम्प्लीमेंट करें।

कस्टम टूल इम्प्लीमेंट करने के लिए हमें दो चीजें चाहिए:

1. SpaceXAI SDK के आधिकारिक tool() ऑब्जेक्ट का उपयोग करके एक टूल स्पेसिफिकेशन।

2. टूल का Python इम्प्लीमेंटेशन—अर्थात, जब टूल कॉल हो तो चलाया जाने वाला कोड।

एक टूल स्पेसिफिकेशन में शामिल होते हैं:

• कॉल की जाने वाली Python फ़ंक्शन का नाम।
• विवरण, जो बताता है टूल क्या करता है। यह अहम है क्योंकि यह तय करता है कि एजेंट कब टूल कॉल करेगा।
• फ़ंक्शन का पैरामीटर स्पेसिफिकेशन।

नीचे एक फ़ंक्शन है जिससे हम लोकल फाइल पढ़ने वाला टूल इम्प्लीमेंट कर सकते हैं:

def execute_read_file(file_path: str) -> str:
    print(f"\n🔒 [Permission Request] Grok wants to read local file: '{file_path}'")
    confirm = input("Allow access? [y/N]: ").strip().lower()
    if confirm not in ("y", "yes"):
        print(f"❌ Denied access to '{file_path}'")
        return f"Permission denied by user. Access to file '{file_path}' was not granted."

    if not os.path.exists(file_path):
        return f"Error: File '{file_path}' does not exist."

    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        print(f"✅ Read {len(content)} characters from '{file_path}'\n")
        return content
    except Exception as e:
        return f"Error reading file '{file_path}': {e}"

सुरक्षा कारणों से, हमने टूल को इस तरह इम्प्लीमेंट किया है कि फाइल पढ़ने से पहले हमेशा यूज़र से अनुमति मांगे। यह गलती से निजी डेटा एजेंट को देने से बचाता है।

इस फ़ंक्शन के लिए टूल स्पेसिफिकेशन इस प्रकार है:

from xai_sdk.chat import tool
read_file_tool = tool(
    name="read_local_file",
    description="Reads the text contents of a local file given its relative or absolute path. Use this whenever the user asks to inspect, summarize, or analyze a local file.",
    parameters={
        "type": "object",
        "properties": {
            "file_path": {
                "type": "string",
                "description": "The path to the local file to read.",
            }
        },
        "required": ["file_path"],
    },
)

फाइल में लिखने का कोड इससे मिलता‑जुलता है और रेपोजिटरी के tools.py फाइल में मिल जाएगा।

Grok 4.6 के साथ टूल‑यूज़िंग एजेंट लूप कैसे चलाएँ?

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

एजेंट नीचे दिए गए आरेख की तरह काम करेगा। यूज़र एक प्रॉम्प्ट भेजता है, फिर एजेंट ज़रूरत होने पर टूल्स का उपयोग करके उत्तर देता है। फिर उत्तर यूज़र को भेज दिया जाता है, और यूज़र एजेंट के साथ बातचीत जारी रख सकता है। 

एजेंट पूरी बातचीत का ट्रैक chat.append() फ़ंक्शन का उपयोग करके रखता है—यूज़र प्रॉम्प्ट्स, उत्तर, और टूल परिणाम जोड़कर। टूल परिणाम को tool_result() के इंस्टैंस में रैप करना आवश्यक है।

यह रहा एजेंट का पूरा इम्प्लीमेंटेशन:

import json
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user
from xai_sdk.tools import code_execution, web_search, x_search
from tools import (
    execute_read_file,
    execute_write_file,
    read_file_tool,
    write_file_tool,
)

load_dotenv()

# 1. Initialize the chat client with both server-side and client-side tools
client = Client()
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution(), read_file_tool, write_file_tool],
)

# 2. Interactive chat loop
while True:
    try:
        prompt = input("> ")
    except (EOFError, KeyboardInterrupt):
        print()
        break

    if not prompt.strip():
        continue
    if prompt.strip().lower() in ("exit", "quit"):
        break

    # Append the user prompt to the conversation
    chat.append(user(prompt))

    # Agent loop: keeps running until Grok finishes (no further client tool calls)
    print("How can I help you?\n")
    while True:
        response = None
        announced_tools = set()
        started_content = False

        for response, chunk in chat.stream():
            # Announce tool calls
            if chunk.tool_calls:
                for tc in chunk.tool_calls:
                    name = getattr(tc.function, "name", "")
                    tc_id = getattr(tc, "id", None) or name
                    if tc_id and tc_id not in announced_tools:
                        announced_tools.add(tc_id)
                        display_name = name or "tool"
                        print(f"\n⚙️  [Agent Tool] Calling: {display_name}...", flush=True)

            # Stream generated content
            if chunk.content:
                if not started_content:
                    print("\nGrok > ", end="", flush=True)
                    started_content = True
                print(chunk.content, end="", flush=True)

        if response:
            chat.append(response)

        # Check if Grok triggered client-side tools
        client_tool_executed = False
        if response and response.tool_calls:
            for tool_call in response.tool_calls:
                fn_name = tool_call.function.name
                if fn_name == "read_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                    except Exception:
                        file_path = tool_call.function.arguments or ""
                    
                    result = execute_read_file(file_path)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

                elif fn_name == "write_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                        content = args.get("content", "")
                    except Exception:
                        file_path = ""
                        content = ""
                    
                    result = execute_write_file(file_path, content)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

        # If Grok called a client-side tool, re-enter the loop so Grok processes the tool result
        if client_tool_executed:
            continue
        
        break

    print("\n")

स्टॉक पोर्टफोलियो विश्लेषण करवाने के लिए Grok 4.6 एजेंट का परीक्षण

एजेंट का परीक्षण करने के लिए, मैंने एक सैंपल स्टॉक पोर्टफोलियो CSV फाइल बनाई। फाइल काफी सरल है और स्टॉक्स सूचीबद्ध करती है—विशेष रूप से खरीद तारीख और खरीद मूल्य दिखाते हुए। 

विचार यह है कि एजेंट से निम्नलिखित करने को कहें:

1. CSV फाइल लोड करें।
2. हर स्टॉक की मौजूदा कीमत पाने के लिए वेब सर्च करें।
3. मौजूदा कीमतों के साथ नया कॉलम जोड़कर CSV अपडेट करें।
4. अपने सेक्टर्स में नवीनतम घटनाक्रम दिखाते हुए हमारे पोर्टफोलियो पर एक रिपोर्ट तैयार करें।

नीचे चरण 1 से 3 तक एजेंट के साथ इंटरेक्शन का स्क्रीनशॉट है।

हम देखते हैं कि इसने वेब सर्च, कोड एक्ज़िक्यूशन, और हमारे बनाए कस्टम टूल्स (लोकल फाइलें पढ़ना/लिखना) का उपयोग किया। अंत में, इसने मौजूदा स्टॉक कीमतों के साथ नया कॉलम जोड़कर CSV फाइल अपडेट कर दी।

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

यदि आप इसकी बनाई रिपोर्ट के बारे में जानना चाहते हैं, तो वह GitHub रेपोजिटरी में है।

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

प्रॉम्प्ट कैशिंग और 200k प्राइसिंग क्लिफ

मल्टी‑टर्न एजेंट लागू करते समय, हमें सुनिश्चित करना चाहिए कि बातचीत कैश हो ताकि मॉडल हर इंटरेक्शन पर पूरी हिस्ट्री को फिर से प्रोसेस न करे। ऐसा न करने से भारी लागत आ सकती है।

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

• xai-sdk (gRPC): x-grok-conv-id, जिसे क्लाइंट इनिशियलाइज़ करते समय gRPC मेटाडेटा के रूप में पास करते हैं

• OpenAI Responses API: prompt_cache_key, जिसे रिक्वेस्ट बॉडी में सेट करते हैं

नीचे दिया स्निपेट दिखाता है कि यह कैसे करें:

import uuid
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user

load_dotenv()

# 1. Generate a unique ID for the conversation loop
conv_id = str(uuid.uuid4()) 

# 2. Pass the ID when initializing the Client
client = Client(
    metadata=(("x-grok-conv-id", conv_id),)
)

# ... [the rest of the code remains the same]

एक महत्वपूर्ण बात यह है कि अत्यधिक लंबी बातचीतों के लिए वित्तीय दंड विशेष रूप से कठोर हो जाता है। एक बार आपका कुल प्रॉम्प्ट 200k टोकन तक पहुँच या उसे पार कर ले, तो API 2x गुणक लागू करती है और पूरी रिक्वेस्ट की बिलिंग मानक दर से दोगुनी हो जाती है।

मल्टी‑टर्न लूप्स को 200k सीमा से आगे जाने से रोकने के लिए, कॉन्टेक्स्ट कंप्रेशन लागू करना अत्यधिक अनुशंसित है। यह समय‑समय पर पुरानी बातचीत की टर्न्स का सारांश बनाकर या कॉन्टेक्स्ट विंडो स्लाइड करके किया जाता है। यह रणनीति सुनिश्चित करती है कि आप अपनी मुख्य इंस्ट्रक्शंस पर सस्ते कैश हिट्स से लाभ उठाते रहें और लगातार बढ़ती कॉन्टेक्स्ट विंडो की भारी आर्थिक सज़ा से बचें।

निष्कर्ष

इस ट्यूटोरियल में, हमने Python के साथ SpaceXAI API का उपयोग करके Grok 4.6 से इंटरैक्ट करना सीखा। हमने टेक्स्ट और इमेज प्रॉम्प्ट भेजने की बुनियादी बातें और आउटपुट को इस तरह हैंडल करना सीखा कि यूज़र को पता रहे मॉडल क्या कर रहा है। 

AI मॉडल को टूल्स देना सीखकर, हमने सबको मिलाकर ऐसा AI एजेंट बनाया जो Grok 4.6 का उपयोग करके वास्तविक कार्य कर सके—जैसे स्टॉक मार्केट पोर्टफोलियो का विश्लेषण। अंत में, हमने सीखा कि लंबे कॉन्टेक्स्ट वाले कार्य अत्यधिक महंगे हो सकते हैं, खासकर यदि हम कैशिंग का उपयोग न करें।

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

यदि आप APIs के साथ AI एजेंट्स बनाना और गहराई से सीखना चाहते हैं, तो हमारा Working with the OpenAI API कोर्स देखें। AI एजेंट्स पर गहराई से जाने की सबसे अच्छी जगह है AI Agent Fundamentals स्किल ट्रैक।