Grok 4 API: चरण-दर-चरण मार्गदर्शिका उदाहरणों सहित

Grok 4 API के साथ शुरुआत

पहला यूज़र अनुरोध करने से पहले, हमें एक API कुंजी और ऐसा Python परिवेश चाहिए जो Grok API से कनेक्ट कर सके।

अपनी API कुंजी बनाना

API के साथ क्लाइंट को प्रमाणित करने के लिए उपयोग की जाने वाली API कुंजी बनाने के लिए, आप ये चरण अपनाएं:

1. आधिकारिक xAI दस्तावेज़ साइट पर जाएं।
2. अपने X, xAI, या Google खाते से लॉगिन करें। यदि आपका खाता नहीं है, तो आप नया xAI खाता बना सकते हैं।
3. “Create an API key” विकल्प ढूंढें। अपनी कुंजी का नाम दर्ज करें और “save” पर क्लिक करें।
4. कुंजी दिखते ही उसे तुरंत कॉपी कर लें। आप बाद में इसे फिर से नहीं देख पाएंगे, हालांकि आवश्यकता होने पर आप नई कुंजी बना सकते हैं।
5. अपने प्रोजेक्ट डायरेक्टरी में .env नाम की एक फ़ाइल बनाएं। अपनी API कुंजी इसमें इस प्रारूप में पेस्ट करें:

XAI_API_KEY=<your_api_key_here>संचालित द्वारा

Grok 4 API मूल्य निर्धारण

API का उपयोग किसी प्रीमियम सदस्यता की तुलना में अधिक किफायती हो सकता है, लेकिन यह निःशुल्क नहीं है। SuperGrok प्लान, जिसकी शुरुआत $30 प्रति माह की फिक्स्ड सदस्यता से होती है, के विपरीत, API लागत पूरी तरह आपकी उपयोग मात्रा पर आधारित होती है। हालांकि, यदि आप Grok 4 Heavy तक पहुंच चाहते हैं, तो नियम अलग हैं: API का उपयोग करते समय भी आपको सक्रिय SuperGrok Heavy सदस्यता ($300 प्रति माह) की आवश्यकता होगी।

संभावित खर्चों के विस्तृत विवरण के लिए, xAI की प्राइसिंग पेज देखें।

स्रोत: xAI

Grok API की कीमत उपयोग-आधारित है, और प्रति मिलियन टोकन मापी जाती है। संदर्भ के लिए, एक मिलियन टोकन लगभग 7,50,000 अंग्रेज़ी शब्दों के बराबर होते हैं—इनपुट या आउटपुट, दोनों में। भले ही इसका कॉन्टेक्स्ट विंडो आकार अपने पूर्ववर्ती की तुलना में लगभग दोगुना हो गया है, Grok 4 की कीमत मानक Grok 3 मॉडल के समान ही है। आपको हर मिलियन इनपुट टोकन के लिए $3 और हर मिलियन आउटपुट टोकन के लिए $15 चुकाने होंगे।

API तक पहुंचने के लिए, आपको क्रेडिट खरीदने होंगे। शुरुआत में, स्वचालित बिलिंग के बजाय प्रीपेड क्रेडिट का उपयोग करना समझदारी है—इससे अप्रत्याशित शुल्क से बचाव होता है। आप xAI कंसोल के Invoices > Credits में टोकन खरीद सकते हैं और अपना उपयोग ट्रैक कर सकते हैं।

Python परिवेश सेटअप

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

• python-dotenv ताकि .env फ़ाइल से API कुंजी को पर्यावरण चर के रूप में लोड किया जा सके।
• Grok 4 API से इंटरैक्ट करने के लिए openai क्लाइंट।

अपनी प्रोजेक्ट निर्भरताओं को साफ रखने के लिए Anaconda का उपयोग करना अच्छा विचार है। Anaconda स्थापित करने के बाद, Python 3.10 के साथ grok4 नामक नया परिवेश इस तरह बनाएं:

conda create -n grok4 python=3.10
conda activate grok4संचालित द्वारा

परिवेश सक्रिय होने पर, आवश्यक पैकेज स्थापित करें:

pip install python-dotenv openaiसंचालित द्वारा

अंतिम तैयारी

आइए अपना पहला स्क्रिप्ट लिखकर शुरुआत करें। स्थापित पैकेजों से आवश्यक फ़ंक्शन इम्पोर्ट करें, साथ में अपनी API कुंजी तक पहुंचने के लिए os भी:

import os
from dotenv import load_dotenv
from openai import OpenAIसंचालित द्वारा

अगले चरण में, dotenv पैकेज के load_dotenv() का उपयोग करके अपने पर्यावरण चर लोड करें, जिससे आपकी API कुंजी स्क्रिप्ट के लिए उपलब्ध हो जाए:

# Load environment variables
load_dotenv()संचालित द्वारा

अब .env फ़ाइल से API कुंजी और Grok सर्वर URL को OpenAI क्लास में पास करके API क्लाइंट इनिशियलाइज़ करें (हम इस ट्यूटोरियल में OpenAI SDK का उपयोग करेंगे, लेकिन Grok 4 का एक नेटिव xAI Python SDK भी है, और यह Anthropic के SDK के साथ भी संगत है)। इसे client वेरिएबल में असाइन करें:

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)संचालित द्वारा

इन चरणों के साथ, आपकी स्क्रिप्ट Grok 4 को अनुरोध भेजने के लिए तैयार है।

Grok 4 के साथ छवि पहचान

अब जब आधार तैयार हो चुका है, तो चलिए छवि पहचान—Grok 4 की नई सुविधाओं में से एक—का परीक्षण करते हैं। हम नीचे दी गई शाकाहारी लज़ान्या की तस्वीर अपलोड करेंगे और Grok से इसमें दिख रहे अवयवों की पहचान करने को कहेंगे।

Grok 4 API के साथ किसी छवि का विश्लेषण करने के लिए, हमें ऐसे अनुरोध की आवश्यकता होती है जिसमें छवि और प्रॉम्प्ट दोनों शामिल हों। अनुशंसित तरीका OpenAI-संगत Python क्लाइंट का उपयोग करना है, मॉडल को grok-4 के रूप में निर्दिष्ट करना, और संदेशों की array में छवि URL तथा आपका प्रश्न शामिल करना। API छवि की सामग्री का विस्तृत विवरण लौटाएगा, जिसे आप response ऑब्जेक्ट में एक्सेस कर सकते हैं।

अनुरोध भेजने से पहले, हमें सुनिश्चित करना होगा कि छवि API आवश्यकताओं को पूरा करती है। केवल JPEG और PNG फ़ॉर्मेट समर्थित हैं, और फ़ाइल आकार 20 MB से अधिक नहीं होना चाहिए। छवि डायरेक्ट लिंक के माध्यम से सुलभ होनी चाहिए, और सर्वर को सही Content-Type हेडर भेजना चाहिए (या तो image/jpeg या image/png)।

आवश्यक पैकेज इम्पोर्ट करने, पर्यावरण चर लोड करने, और क्लाइंट सेटअप करने के बाद, हम अपना प्रश्न इस तरह भेज सकते हैं:

# Sending the query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://shorturl.at/mVDEh",
            "detail": "high"
          }
        },
        {
          "type": "text",
          "text": "Which ingredients do you notice on the picture?"
        }
      ]
    }
  ],
    max_tokens=2000,
    temperature=0.2,  # lower temperature for more deterministic answers
)

# Print the response
print(response.choices[0].message.content)संचालित द्वारा

Based on the picture, it looks like a delicious slice of vegetarian lasagna! Here's what I can clearly see in terms of ingredients (I'm basing this purely on visual cues, so it's not a full recipe—just what's noticeable):
### Main Visible Ingredients:
- **Pasta sheets/lasagna noodles**: The flat, layered pasta that's the base structure of the dish.
- **Tomato sauce**: A red, chunky sauce (likely marinara or similar) that's spread between layers and on top.
- **Cheese**:
  - Melted, bubbly cheese on top (probably mozzarella or Parmesan, given the golden-brown spots).
  - White, creamy cheese in the filling layers (looks like ricotta or cottage cheese).
- **Spinach (or similar greens)**: Dark green leaves mixed into the layers, giving it a veggie-packed look (this seems like a spinach lasagna variant).
- **Basil leaf**: A fresh green leaf garnishing the top for decoration and flavor.
It doesn't appear to have any meat (like ground beef or sausage), so it's likely a vegetarian version. If this is from a specific recipe or if you have more context, I could refine my observations! What do you think it is? 😊संचालित द्वारा

इस मामले में, Grok ने केवल तस्वीर देखकर ही समझ लिया कि यह शाकाहारी संस्करण है—काफी प्रभावशाली!

Grok 4 के साथ तर्क (Reasoning)

Grok 4 उन्नत तर्क के लिए बनाया गया है और जटिल समस्याओं को चरण-दर-चरण हल कर सकता है। हालांकि, कुछ पुराने मॉडलों के विपरीत, Grok 4 अपने आंतरिक तर्क-ट्रेस उजागर नहीं करता, इसलिए आप API प्रतिक्रिया से अलग फ़ील्ड के रूप में विस्तृत "सोच की प्रक्रिया" या chain-of-thought नहीं निकाल सकते। आपको जो आउटपुट मिलता है, वह अंतिम उत्तर होता है—मॉडल के मध्यवर्ती चरण या कच्ची तर्क-सामग्री नहीं।

इसके अलावा, Grok 4 में reasoning_effort पैरामीटर का समर्थन नहीं है, जो उदाहरण के लिए Grok 3 mini में था (उस पैरामीटर का उपयोग कैसे करें, इसके लिए यह Grok 3 API ट्यूटोरियल देखें)। इसका अर्थ है कि आप यह समायोजित नहीं कर सकते कि अंतिम निष्कर्ष पर पहुंचने से पहले मॉडल कितना “सोचे”। इसलिए, कोई भी reasoning क्वेरी ठीक सामान्य क्वेरी की तरह ही बनाई जाती है।

आइए Grok को एक और लज़ान्या-संबंधित reasoning कार्य के साथ परखें और उसे आउटपुट में अपना तर्क दिखाने के लिए प्रेरित करें।

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
        {"role": "user", "content": (
            "You want to cook lasagna for a dinner party, but several guests have dietary restrictions. One is vegetarian, one is lactose-intolerant, and another cannot eat gluten. You have six different lasagna recipes (classic, vegetarian, vegan, gluten-free, cheese-heavy, and meat-based). Which recipe or combination of recipes would best satisfy everyone, and what specific ingredient substitutions would you need to make? Explain your reasoning step by step."
        )}
    ],
    max_tokens=5000,
    temperature=0.2,  # lower randomness
)
# Print the final answer
print(response.choices[0].message.content)संचालित द्वारा

Below, I'll explain my reasoning step by step for selecting the best recipe (or combination of recipes) to satisfy all guests at your dinner party, including the vegetarian, the lactose-intolerant person, the gluten-intolerant person, and everyone else (who presumably have no restrictions). I'll base this on logical inferences about what each recipe likely contains, since the problem doesn't provide exact ingredient lists. Then, I'll recommend specific ingredient substitutions and why this approach works.
(...)
### Step 3: Selecting the Best Recipe or Combination
- **Recommended approach**: Use a **combination of the vegan and gluten-free recipes** to create a single modified lasagna that everyone can eat. Start with the vegan recipe as your base (it already handles no meat and no lactose/dairy), then incorporate elements from the gluten-free recipe (e.g., ingredient swaps to eliminate gluten). This results in a **vegan, gluten-free lasagna**.
  - Why not multiple lasagnas? Preparing separate dishes (e.g., one vegetarian, one gluten-free) could work but might not fully satisfy everyone in a shared meal—e.g., the lactose-intolerant guest couldn't eat a dairy-based vegetarian version. A single inclusive dish promotes unity at the party and simplifies cooking/serving. If you have time and oven space, you could make a small "classic" version on the side for unrestricted guests who prefer meat and cheese, but the modified vegan/gluten-free one would still be the core option.
  - Why this combination over others? Vegan + gluten-free covers all restrictions without needing to add meat or dairy (which would violate rules). Starting with gluten-free and making it vegan would require more substitutions (e.g., removing meat and cheese), while vegan is already "80% there." Other combos (e.g., vegetarian + gluten-free) would still need dairy removals for lactose intolerance, making them less efficient.
This approach ensures:
- The vegetarian can eat it (no meat).
- The lactose-intolerant can eat it (no dairy/lactose).
- The gluten-intolerant can eat it (no gluten).
- Others can eat it (it's still a flavorful lasagna, though it won't have "real" meat or cheese—unrestricted guests might find it less indulgent, but it's a fair compromise).
(...)संचालित द्वारा

मैंने Grok की प्रतिक्रिया को मुख्य बिंदुओं तक सीमित किया है, लेकिन इस संक्षिप्त संस्करण में भी साफ़ है कि मॉडल ने अच्छा काम किया। Grok ने चरण-दर-चरण

• आहार संबंधी प्रतिबंधों को समझा
• उपलब्ध रेसिपीज़ का मूल्यांकन किया
• सर्वश्रेष्ठ रेसिपी संयोजन चुना
• विशिष्ट सामग्री-प्रतिस्थापन सुझाए
• संशोधित रेसिपी का पूरा खाका दिया
• यह क्यों सभी को संतुष्ट करता है, इस पर पुनः ध्यान दिलाया
• संभावित कमियों और विकल्पों पर चर्चा की

Grok 4 के साथ फ़ंक्शन कॉलिंग

अपने पूर्ववर्ती की तरह, Grok 4 फ़ंक्शन कॉलिंग का समर्थन करता है। यह मॉडल को बाहरी टूल्स और सेवाओं के साथ सीधे इंटरैक्ट करने देता है। इसका अर्थ है कि Grok केवल पाठ जनरेशन तक सीमित नहीं है—यह मौसम अपडेट लाना, इवेंट समय जांचना, डेटाबेस रिकॉर्ड का विश्लेषण करना, या स्मार्ट होम डिवाइस चलाना जैसे कार्य भी कर सकता है।

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

तैयारी

फ़ंक्शन कॉलिंग के साथ काम करने के लिए, हमें json पैकेज इम्पोर्ट करना होगा, जो Grok द्वारा कॉल किए गए किसी भी फ़ंक्शन के आर्ग्युमेंट स्ट्रक्चर तक पहुंचने देता है। इसके बाद, हम एक कॉलबैक फ़ंक्शन परिभाषित करते हैं, जिसे Grok विशिष्ट डेटा माँगे जाने पर इनवोक करेगा।

इस उदाहरण में, suggest_lasagna_recipe एक सरल Python फ़ंक्शन है जो एक निश्चित रेसिपी सुझाव लौटाता है। यह हार्ड-कोडेड तरीका डेमो को सरल रखता है और बाहरी सेवाओं पर निर्भरता से बचाता है।

import json

# Define the callback function
def suggest_lasagna_recipe(ingredients: list) -> dict:
    # Very simplified logic for demo purposes
    if "zucchini" in ingredients:
        return {"recipe": "Vegetarian Zucchini Lasagna"}
    if "beef" in ingredients:
        return {"recipe": "Classic Beef Lasagna"}
    if "tofu" in ingredients:
        return {"recipe": "Vegan Tofu Lasagna"}
    return {"recipe": "Basic Cheese Lasagna"}संचालित द्वारा

हमें वह टूल भी परिभाषित करना होगा जिसे Grok कॉल कर सकता है। इसमें टूल का नाम, उद्देश्य, और आवश्यक पैरामीटर JSON स्कीमा में निर्दिष्ट करना शामिल है। यह स्कीमा अनुरोध के साथ Grok को भेजा जाता है, जो उसे सूचित करता है कि अतिरिक्त जानकारी की आवश्यकता होने पर वह इस टूल को कॉल कर सकता है।

# Define the JSON schema for the tool
tools = [
    {
        "type": "function",
        "function": {
            "name": "suggest_lasagna_recipe",
            "description": "Suggests a lasagna recipe based on available ingredients.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ingredients": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of available ingredients"
                    }
                },
                "required": ["ingredients"]
            }
        }
    }
]संचालित द्वारा

अंत में, tools_map डिक्शनरी, Grok द्वारा उपयोग किए जाने वाले फ़ंक्शन नामों को आपके कोड में वास्तविक Python फ़ंक्शनों से जोड़ती है। यह मैपिंग क्लाइंट को अनुरोधित फ़ंक्शन कॉल सही ढंग से निष्पादित करने देती है।

# link the function names to the functions
tools_map = {
    "suggest_lasagna_recipe": suggest_lasagna_recipe
}संचालित द्वारा

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

निष्पादन

आइए देखें कि जब लज़ान्या रेसिपी पूछी जाती है तो क्या Grok हमारा फ़ंक्शन उपयोग करता है। फ़ंक्शन कॉलिंग वर्कफ़्लो इस प्रकार आगे बढ़ता है:

1. पहले, हम उपयोगकर्ता का प्रश्न—“मेरे पास कौन-सी सामग्री है, उसके आधार पर मैं कौन-सी लज़ान्या बना सकता/सकती हूँ?”—Grok को उपलब्ध tools के साथ भेजते हैं। 
2. इसके बाद Grok अनुरोध की समीक्षा करता है और यदि उसे लगता है कि फ़ंक्शन कॉल आवश्यक है, तो वह हमारे लोकल फ़ंक्शन को ट्रिगर करके रेसिपी मांगता है। यदि कोई टूल कॉल नहीं होती, तो हम सीधे Grok का प्रारंभिक उत्तर उपयोग करते हैं।
3. जब टूल कॉल अनुरोधित होती है, तो हम संबंधित लोकल फ़ंक्शन चलाते हैं और परिणाम को चल रही संदेश-इतिहास में जोड़ते हैं।
4. यह अद्यतन इतिहास फिर से Grok को भेजा जाता है, जिससे वह अपना तर्क पूरा कर एक अंतिम, संदर्भ-संगत उत्तर दे सके।

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "I have beef, ricotta, and tomato sauce. Which lasagna can I make?"}
]

response = client.chat.completions.create(
    model="grok-4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])


if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        print(f"{function_name} successfully called")
        function_args = json.loads(tool_call.function.arguments)

        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)

            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Assistant's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
            })

            # Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-4",
                messages=messages,
                tools=tools,
                tool_choice="auto"
            )

            # Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
   
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)संचालित द्वारा

suggest_lasagna_recipe successfully called

Final Answer:
Based on your available ingredients (beef, ricotta, and tomato sauce), you can make a **Classic Beef Lasagna**! (...)संचालित द्वारा

जैसा कि हम देख सकते हैं, Grok ने हमारा फ़ंक्शन कॉल किया और संबंधित रेसिपी सुझाई।

आपने प्रारंभिक अनुरोध में tool_choice आर्ग्युमेंट भी नोट किया होगा। डिफ़ॉल्ट “auto” Grok को यह तय करने देता है कि किस फ़ंक्शन को कॉल करना है और करना है या नहीं। यदि आप अधिक नियंत्रण चाहते हैं, तो किसी विशिष्ट फ़ंक्शन कॉल को बाध्य कर सकते हैं, ठीक वही फ़ंक्शन निर्दिष्ट कर सकते हैं, या इस पैरामीटर को बदलकर फ़ंक्शन कॉलिंग को पूरी तरह बंद कर सकते हैं।

Grok 4 के साथ संरचित आउटपुट

फ़ंक्शन कॉलिंग की तरह, संरचित आउटपुट Grok 3 के साथ पेश की गई सुविधा है। यह Grok को सादे पाठ के बजाय JSON जैसे सख्त प्रारूप में उत्तर देने देती है। यह तरीका आपके अनुप्रयोगों या वर्कफ़्लो में मॉडल की प्रतिक्रियाओं को पार्स, वैलिडेट और उपयोग करना काफी आसान बना देता है।

पहले से स्कीमा सेट करके, आप सुनिश्चित कर सकते हैं कि Grok के आउटपुट हमेशा सुसंगत, मशीन-पठनीय, और आगे की प्रोसेसिंग के लिए तैयार हों। यह तब विशेष रूप से उपयोगी है जब आपको दस्तावेज़ों से संरचित डेटा निकालना हो या AI-जनित सामग्री को सीधे डेटाबेस, डैशबोर्ड, या ऑटोमेशन टूल्स में भेजना हो—बिना अविश्वसनीय टेक्स्ट पार्सिंग की चिंता किए।

आउटपुट स्कीमा परिभाषित करने के लिए, हम Pydantic का उपयोग करते हैं, जो जटिल डेटा की संरचना को सरल और पठनीय बनाता है (यह Pydantic ट्यूटोरियल आपको और सीखने में मदद करेगा)। इसके लिए, आपको pydantic से BaseModel और Field—दोनों इम्पोर्ट करने होंगे। चूंकि हमारे आउटपुट में अवयवों की सूची है, हम Python के typing मॉड्यूल से List भी इम्पोर्ट करते हैं ताकि सूची के प्रत्येक तत्व का प्रकार स्पष्ट रहे।

हालांकि हम साधारण JSON से भी स्कीमा सेट कर सकते हैं, लेकिन कभी-कभी Grok ऐसा आउटपुट लौटाता है जो अपेक्षित संरचना से बिल्कुल मेल नहीं खाता। अर्थ भले ही वही हो, पर स्कीमा अलग हो सकता है—जो आपकी एप्लिकेशन को समस्या में डाल सकता है यदि उसे किसी विशिष्ट फ़ॉर्मेट की आवश्यकता हो। यह विशेष रूप से सूची जैसी नेस्टेड इकाइयों के लिए सही है। इसलिए मैं Pydantic की सिफारिश करता/करती हूँ—यह सुनिश्चित करने में मदद करता है कि संरचित आउटपुट हर बार विश्वसनीय रूप से वैलिडेट और पार्स हो।

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

# import additionally needed packages
from pydantic import BaseModel, Field
from typing import List

# Define the schema for the structured output
class Ingredient(BaseModel):
    name: str = Field(description="Name of the ingredient")
    amount: int = Field(description="Amount in g needed for recipe")
    is_at_home: bool = Field(description="Is the item already at home?")
    price: float = Field(description="Price of the ingredient in USD per kg")
    is_vegetarian: bool = Field(description="Is the ingredient vegetarian?")
    is_vegan: bool = Field(description="Is the ingredient vegan?")
    is_gluten_free: bool = Field(description="Is the ingredient gluten-free?")

class Recipe(BaseModel):
    name: str = Field(description="The name of the recipe")
    portions: int = Field(default=4, description="Amount of portions")
    ingredients: List[Ingredient] = Field(description="List of ingredients for the recipe")संचालित द्वारा

अनुरोध करते समय कुछ बातों का ध्यान रखना होता है। client.chat.completions.create() के बजाय, हमें client.beta.chat.completions.parse() कॉल करना चाहिए। यह Grok को संकेत देता है कि हम आउटपुट एक विशिष्ट फ़ॉर्मेट में अपेक्षित कर रहे हैं, और हमारा Recipe स्कीमा response_format आर्ग्युमेंट के रूप में पास किया जाता है।

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

उदाहरण के लिए, आप Grok को एक इटालियन शेफ़ की भूमिका दे सकते हैं, जिससे यह सुनिश्चित हो कि वह जो भी रेसिपी सुझाए, वे प्रामाणिक रूप से इटालियन हों—ताकि आपकी पिज्ज़ा पर अनानास छुपकर न आ जाए!

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-4",
    messages=[
        {"role": "system", "content": (
        "You are a master chef specialized in italian cuisine."
        "When asked about recipes, return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "I have beef, ricotta, and tomato sauce, and want to cook for 4 persons. Which lasagna can I make?"
        )}
    ],
    response_format=Recipe,
)संचालित द्वारा

एक बार जब हम Grok 4 के संरचित आउटपुट को पार्स कर लेते हैं, तो इसके plain text पर फायदे स्पष्ट हो जाते हैं। हम जानकारी को अपनी ज़रूरत के हिसाब से आसानी से पुन: व्यवस्थित और अनुकूलित कर सकते हैं, या विशिष्ट डेटा-पॉइंट्स को सीधे ऑटोमेटेड वर्कफ़्लोज़ में भेज सकते हैं। हमारे उदाहरण में, इसका मतलब है कि हम प्रति किलोग्राम अवयव कीमतों को आवश्यक मात्राओं से गुणा कर सकते हैं, पेंट्री में पहले से मौजूद वस्तुओं के आधार पर लागत जोड़ सकते हैं, और कुछ ही चरणों में प्रति सर्विंग अंतिम कीमत की गणना कर सकते हैं।

# Access the parsed result
recipe = completion.choices[0].message.parsed


price = 0 # initialize price variable
print(f"Recipe: {recipe.name}")
print("Ingredients:")
for i in recipe.ingredients:
    print("- " + i.name + " " + str(i.amount) + " g")
    if not i.is_at_home:
        price += (i.price * i.amount / 1000)
print(f"Price per portion: USD {round((price/recipe.portions), 2)}")संचालित द्वारा

Recipe: Classic Beef Lasagna
Ingredients:
- Ground beef 500 g
- Ricotta cheese 400 g
- Tomato sauce 800 g
- Lasagna noodles 300 g
- Mozzarella cheese 300 g
- Parmesan cheese 100 g
- Onion 200 g
- Garlic 20 g
- Olive oil 30 g
- Egg 50 g
Price per portion: USD 1.7625संचालित द्वारा

निष्कर्ष

Grok 4 बड़े कॉन्टेक्स्ट विंडो और बेहतर तर्क क्षमता जैसी नई सुविधाएँ लाता है। इसकी छवि पहचान और फ़ंक्शन कॉलिंग, वास्तविक दुनिया के डेटा और क्रियाओं के साथ AI को जोड़ने के रोमांचक अवसर खोलती हैं, जबकि संरचित आउटपुट विश्वसनीय, मशीन-पठनीय प्रतिक्रियाएँ सुनिश्चित करते हैं। API सेटअप सीधा है, और केवल कुछ निर्भरताओं के साथ आपके Python प्रोजेक्ट्स में त्वरित इंटीग्रेशन संभव बनाता है।

और यदि सारे लज़ान्या उदाहरणों ने आपको भी भूखा कर दिया हो, तो आप अकेले नहीं हैं—मुझे भी शायद एक स्लाइस ले ही लेना चाहिए!