मुख्य सामग्री पर जाएँ

Grok 4.7 API ट्यूटोरियल: AI सर्किट डिज़ाइन रिव्यूअर बनाएँ

इस Grok 4.7 API ट्यूटोरियल में जानें कि इमेज, डेटाशीट्स, कोड निष्पादन, वेब सर्च, और लोकल वेरिफिकेशन के साथ Python सर्किट रिव्यूअर कैसे बनाएँ।
· 15 मि॰ पढ़ें

AI के साथ खोजें

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

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

प्रयोग के लिए, मैंने EnviroNode Rev A, एक छोटा USB-समर्थित सेंसर बोर्ड बनाया, और उसके डिज़ाइन में तीन दोष जानबूझकर डाले। Grok को यह नहीं बताया गया कि कितने दोष हैं। उसे उन्हें खोजना है, हर निष्कर्ष को कंपोनेंट डॉक्यूमेंटेशन से समर्थन देना है, सुधार सुझाने हैं, और सुधारे गए मानों को Python चेक्स में सबमिट करना है।

साथ चलने के लिए आपको विद्युत अभियांत्रिकी की पृष्ठभूमि की आवश्यकता नहीं है। मैं हर सर्किट नियम को पहली बार आने पर समझाता हूँ। आप सीखेंगे कि कैसे:

  • Responses API के माध्यम से Grok 4.7 को स्कीमैटिक की इमेज भेजें

  • Files API के साथ डेटाशीट्स संलग्न करें और Grok को उन्हें खोजने दें

  • code execution से गणनाएँ जाँचें और web search से सीमाएँ जाँचें

  • Grok को एक लोकल verify_design() फ़ंक्शन दें जो पास या फेल तय करे

  • लंबी, दस्तावेज़-प्रधान बातचीत को मॉडल के कॉन्टेक्स्ट लिमिट के भीतर रखें

  • एक सुसंगत रिव्यू फ़ॉर्मेट लौटाएँ, फिर तर्क स्तरों की तुलना करें

पहली इमेज रिव्यू से लेकर अंतिम Python चेक तक वही बोर्ड नज़र में रहता है।

सारांश

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

  • दस्तावेज़ों के बिना, Grok ने अनुमान लगाने से इनकार किया: केवल इमेज से एक पुष्ट खामी मिली, और रेग्युलेटर व एनालॉग-टू-डिजिटल कन्वर्टर (ADC) सीमाएँ "साक्ष्य चाहिए" में रहीं।
  • डेटाशीट्स ने शंका को साक्ष्य में बदला: हर निष्कर्ष ने एक दस्तावेज़ी मान का हवाला दिया, और किसी सही पार्ट को फ्लैग नहीं किया।
  • फ़ाइल-भारी टर्न लंबे कॉन्टेक्स्ट को खत्म कर सकते हैं: बार-बार PDF सर्च के बाद, एक कंटिन्युएशन 500K विंडो से ऊपर चला गया; सुधरा हुआ लूप अगले टर्न से पहले कॉम्पैक्ट करता है।
  • Low ने वेरिफ़ायर पास किया पर एक ब्लाइंड स्पॉट दिखाया: इसके फ़िल्टर मान लिखे गए चेक्स से मेल खाते थे पर कैपेसिटिव-लोड और सेटलिंग व्यवहार अनटेस्टेड रहे।

यह एक छोटा सा बोर्ड है, कोई बेंचमार्क नहीं। दर्जन भर डेटाशीट्स वाले बोर्ड में बड़ा कॉन्टेक्स्ट बनेगा और नतीजे अलग हो सकते हैं।

Grok 4.7 API क्या है?

Grok 4.7 API Python ऐप्स को टेक्स्ट और इमेज इनपुट, टेक्स्ट आउटपुट, और 500,000-टोकन का कॉन्टेक्स्ट विंडो मॉडल ID grok-4.7 के साथ देता है। आधिकारिक गाइड में low, medium, high (डिफ़ॉल्ट), और xhigh तर्क स्तर सूचीबद्ध हैं; तर्क को बंद नहीं किया जा सकता। API फ़ंक्शन कॉलिंग, स्ट्रक्चर्ड आउटपुट, वेब सर्च, X सर्च, और कोड निष्पादन को भी सपोर्ट करता है।

हमारा Grok 4.7 अवलोकन लॉन्च और बेंचमार्क को कवर करता है। SpaceXAI Chat Completions को लेगेसी लेबल करता है, इसलिए यहाँ हर उदाहरण Responses API का उपयोग करता है।

Grok 4.7 की कीमत कितनी है?

200,000 प्रॉम्प्ट टोकन से कम पर, Grok 4.7 की कीमत प्रति मिलियन इनपुट टोकन $2, प्रति मिलियन कैश्ड इनपुट टोकन $0.50, और प्रति मिलियन आउटपुट टोकन $6 है। जैसे ही प्रॉम्प्ट 200,000 टोकन तक पहुँचता है, उस रिक्वेस्ट के हर टोकन का बिल $4, $1, और $12 पर होता है।

सर्वर-साइड टूल्स की अलग फीस है: प्राइसिंग पेज प्रति 1,000 वेब सर्च या कोड निष्पादन कॉल पर $5 चार्ज करता है। संलग्न दस्तावेज़ों की खोज प्रत्येक पर एक सेंट लगती है, और स्टोर किए गए दस्तावेज़ों पर प्रति GiB दैनिक चार्ज भी होता है। संबंधित रिक्वेस्ट्स के लिए एक स्थिर prompt_cache_key का उपयोग करें, लेकिन अनकैश्ड इनपुट के लिए बजट रखें।

बिल्ड लागत को usage.cost_in_usd_ticks से पढ़ें। कॉस्ट ट्रैकिंग दस्तावेज़ कहते हैं कि इसमें कैशिंग और टूल चार्ज शामिल हैं। डॉलर के लिए मान को 10^10 से विभाजित करें।

सर्किट डिज़ाइन पर Grok 4.7 का परीक्षण क्यों?

सर्किट डिज़ाइन एक ही कार्य में दस्तावेज़ पढ़ना, गणनाएँ, टूल उपयोग, और वेरिफिकेशन की जाँच करता है। SpaceXAI 64.0% रिपोर्ट करता है Grok 4.7 के लिए EEBench पर। EEBench पद्धति बड़े भाषा मॉडल (LLM) जज की जगह सिमुलेशन और बिल ऑफ मटेरियल (BOM) चेक्स का उपयोग करती है, और EnviroNode उसी नियम का पालन करता है।

हम क्या बनाएँगे: EnviroNode Rev A सर्किट रिव्यू

EnviroNode Rev A एक USB-समर्थित सेंसर नोड है। आप पूरा प्रोजेक्ट यहाँ से डाउनलोड कर सकते हैं: GitHub।

स्कीमैटिक में हर वह कंपोनेंट मान है जिसकी Grok को रिव्यू के लिए आवश्यकता है। प्रत्येक आवश्यकता का एक ID है जैसे PWR-002 या BW-001, ताकि हर निष्कर्ष एक नियम की ओर इशारा कर सके।

EnviroNode Rev A स्कीमैटिक जिसमें USB इनपुट, TLV70033 रेग्युलेटर, ESP32-C3, MCP6001 गेन स्टेज, और RC फ़िल्टर के कंपोनेंट मान दिखाए गए हैं

EnviroNode Rev A स्कीमैटिक व मानों के साथ। इमेज: लेखक द्वारा।

Grok द्वारा बोर्ड का रिव्यू करने से पहले, वे सब नियम उजागर करें जिनका वेरिफायर उपयोग करेगा। यह फ़ंक्शन इन आठ आवश्यकताओं से बने पाँच पास-या-फेल चेक्स लौटाता है:

  • PWR-001: USB इनपुट 4.75 V और 5.25 V के बीच रहता है
  • PWR-002: रेग्युलेटर पीक लोड को कवर करता है
  • PWR-003: MCU के अलावा लोड्स 10 mA बजट उपयोग करते हैं
  • SIG-001: सेंसर फुल स्केल 1.0 V है
  • ADC-001: ADC इनपुट 2,250 mV पर या उससे नीचे रहता है
  • ADC-002: ADC इनपुट कम से कम 1,500 mV तक पहुँचता है
  • BW-001: 100 Hz तक के सिग्नल्स में 1 dB से कम हानि
  • BW-002: फ़िल्टर कटऑफ 500 Hz पर या उससे नीचे रहता है

मॉडल को भी वही आवश्यकताओं का सेट मिलता है। कोई वेरिफायर सीमा केवल तब प्रकट होती है जब Grok कोई सुधार प्रस्तावित करता है।

तीन डाले गए दोष क्या हैं?

तीन दोष नंबरों से जाँचे जा सकते हैं। उनकी संख्या प्रॉम्प्ट से बाहर रहती है।

  • रेग्युलेटर बहुत छोटा (PWR-002): TI TLV700 200 mA के लिए रेटेड है, जबकि ESP32-C3 डेटाशीट 335 mA Wi‑Fi ट्रांसमिट पीक सूचीबद्ध करती है और Espressif की स्कीमैटिक चेकलिस्ट कम से कम 500 mA मांगती है।

  • ADC ओवर रेंज (ADC-001): 3 के गेन से ADC पर 3.0 V आता है, पर डेटाशीट की प्रभावी रेंज 2,500 mV पर समाप्त होती है, और आवश्यकता उसका 90% अनुमति देती है।

  • फ़िल्टर बहुत धीमा (BW-001): 10 kΩ और 1 µF 15.9 Hz कटऑफ देते हैं, जबकि 100 Hz तक के सिग्नल्स में अधिकतम 1 dB हानि की अनुमति है।

ADC दोष मापन रेंज से संबंधित है, पिन डैमेज से नहीं। सही चुनाव, जैसे LED रेसिस्टर और CHIP_EN डिले, फ़ॉल्स पॉज़िटिव्स को मापने योग्य बनाते हैं।

रिव्यू लूप कैसे काम करता है?

रिव्यू को एक स्पष्ट सीमा चाहिए: Grok परिवर्तन प्रस्तावित करता है, जबकि Python पास या फेल का मालिक है। आरेख दिखाता है कि दस्तावेज़ और टूल्स उस लूप में कहाँ प्रवेश करते हैं।

Grok 4.7 रिव्यू लूप का आरेख: साक्ष्य Grok को फीड होता है, जो सर्वर-साइड टूल्स और लोकल verify_design फ़ंक्शन को कॉल करता है, फिर सभी चेक पास होने पर स्ट्रक्चर्ड रिव्यू लिखता है

रिव्यू लूप प्रस्ताव को वेरिफिकेशन से अलग करता है। इमेज: लेखक द्वारा।

पहली API कॉल से पहले सफलता को परिभाषित करें। किसी दोष को केवल तब गिनें जब Grok उसे किसी आवश्यकता और सहायक साक्ष्य से जोड़ता है। किसी सुधार को केवल तब गिनें जब verify_design() all_pass = true लौटाता है।

Python में Grok 4.7 API कैसे सेट करें

आपको प्रीपेड क्रेडिट्स के साथ xAI API कुंजी, Python 3.10 या नया, और OpenAI Python सॉफ़्टवेयर डेवलपमेंट किट (SDK) चाहिए जो xAI के बेस URL की ओर इशारा करता हो। कुंजी xAI Console में बनाएँ, फिर नीचे उपयोग किए गए पैकेज इंस्टॉल करें।

python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install openai python-dotenv pydantic httpx streamlit
pip install matplotlib schemdraw pytest  # Optional diagrams and verifier tests

API उदाहरण पहले पैकेज समूह का उपयोग करते हैं; दूसरा रिपॉज़िटरी डायग्राम्स और टेस्ट्स को सपोर्ट करता है। मैंने इन्हें Python 3.11.9, openai 3.19.2, pydantic 2.13.5, streamlit 1.64.0, और httpx 0.28.1 के साथ टेस्ट किया। कुंजी को XAI_API_KEY एन्वायरनमेंट वेरिएबल के रूप में सेव करें, और उसे सोर्स कोड में रखने के बजाय python-dotenv से लोड करें; हमारा वर्चुअल एन्वायरनमेंट गाइड अगर यह सेटअप नया है, तो समझाता है।

अपनी पहली Grok 4.7 API कॉल करें

यदि आपकी कुंजी पहले से Responses API के साथ काम करती है, तो स्टेप 1 पर जाएँ। अन्यथा, यह रिक्वेस्ट एक ही बार में कुंजी, बेस URL, और मॉडल ID जाँचती है।

import os
import httpx
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.environ["XAI_API_KEY"], base_url="https://api.x.ai/v1",
                timeout=httpx.Timeout(3600.0))

response = client.responses.create(
    model="grok-4.7",
    reasoning={"effort": "low"},
    input="In one sentence, what does a low-dropout regulator do?",
)
print(response.output_text)

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

स्टेप 1: क्या Grok 4.7 केवल इमेज से सर्किट रिव्यू कर सकता है?

हाँ, Grok 4.7 केवल इमेज से स्कीमैटिक का रिव्यू कर सकता है, बशर्ते प्रॉम्प्ट में साफ़ कहा गया हो कि कोई टूल्स नहीं आने वाले। बेसलाइन PNG को base64 डेटा URL के रूप में आवश्यकताओं के टेक्स्ट के साथ भेजती है।

image = {
    "type": "input_image",
    "image_url": f"data:image/png;base64,{SCHEMATIC_B64}",
    "detail": "high",
}
response = client.responses.create(
    model="grok-4.7",
    input=[{"role": "user", "content": [
        image,
        {"type": "input_text", "text": REVIEW_PROMPT},
    ]}],
)

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

केवल-इमेज रिव्यू ने क्या पाया?

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

TL;DR में बताए अनुसार, Grok ने 15.9 Hz कटऑफ और 100 Hz पर 16.1 dB हानि के साथ फ़िल्टर दोष की पुष्टि की। उसने रेग्युलेटर और ADC को अनुमान लगाने के बजाय "अधिक साक्ष्य चाहिए" के अंतर्गत रखा।

स्टेप 2: Files API के साथ डेटाशीट्स कैसे जोड़ें

संलग्न दस्तावेज़ अस्पष्ट चिंता को नंबरों से समर्थित दावे में बदल देते हैं। प्रत्येक दस्तावेज़ एक बार अपलोड करें और उसे file_id से संदर्भित करें।

with open(DATASHEET_PATH, "rb") as datasheet:
    uploaded = client.files.create(
        file=datasheet,
        purpose="assistants",
        expires_after={"anchor": "created_at", "seconds": 7 * 24 * 3600},
    )
content = [image, *[{"type": "input_file", "file_id": fid} for fid in file_ids],
           {"type": "input_text", "text": EVIDENCE_PROMPT}]

क्योंकि यह ट्यूटोरियल expires_after सात दिन सेट करता है, कैश्ड IDs केवल उसी विंडो में मान्य हैं। expires_after के बिना, xAI अपलोड की गई फ़ाइलें तब तक रखता है जब तक आप उन्हें डिलीट नहीं करते।

यहाँ कैप्चर किए गए OpenAI SDK रिस्पॉन्सेज़ में, अटैचमेंट सर्च custom_tool_call आइटम्स के रूप में दिखा जिनके नाम pdf_search और pdf_browse थे, जबकि उपयोग को document_search_calls के अंतर्गत गिना गया। यह प्रेक्षित व्यवहार है, सामान्य टूल-टाइप कॉन्ट्रैक्ट नहीं, इसलिए लूप प्रलेखित उपयोग काउंटर भी जाँचता है।

डेटाशीट्स रिव्यू को कैसे बदलती हैं?

दस्तावेज़ों ने स्टेप 1 के दो खुले प्रश्नों का समाधान किया और पावर, ADC, और फ़िल्टर निष्कर्षों का समर्थन किया। रेग्युलेटर निष्कर्ष ने TLV700 की 200 mA रेटिंग, ESP32-C3 का 335 mA ट्रांसमिट पीक, और 500 mA सप्लाई सिफारिश का हवाला दिया।

फ़िल्टर के लिए, Grok ने निकाला कि कौन से कैपेसिटर मान R5 बदले बिना दोनों बैंडविड्थ नियमों को संतुष्ट करेंगे: लगभग 32 से 81 nF। हर डिकॉय "जाँचा गया और स्वीकार्य" के अंतर्गत कारण सहित आया।

स्टेप 3: Grok 4.7 कोड निष्पादन से गणनाओं की पुष्टि कैसे करें

कोड निष्पादन xAI का सर्वर-साइड Python सैंडबॉक्स है, जिसे आप OpenAI क्लाइंट का उपयोग करते समय tools में {"type": "code_interpreter"} के रूप में जोड़ते हैं। प्रॉम्प्ट एक नियम जोड़ता है: नंबर वाले हर दावे की पुष्टि होने से पहले उसे कंप्यूट किया जाना चाहिए।

पहले लिंक की गई कोड निष्पादन गाइड कहती है कि सैंडबॉक्स में नेटवर्क एक्सेस नहीं है और रिक्वेस्ट्स के बीच कोई स्टेट नहीं रखता। कुछ डेटाशीट नंबरों के लिए, यह पर्याप्त है।

Grok को कौन-सी गणनाएँ जाँचना चाहिए?

Grok से पावर बजट, ADC रेंज, और फ़िल्टर बैंडविड्थ को एक स्क्रिप्ट में जाँचने के लिए कहें। यदि सर्किट आपकी बात नहीं हैं, तो नीचे का आउटपुट छोड़ दें; मुख्य बात उसके बाद आती है।

f=  100.0 Hz  |H|=0.157177  attenuation=16.0722 dB
fc required for <= 1 dB at 100 Hz: fc >= 196.5227 Hz
V_adc_fs = 3.0000 V
90% limit = 2.2500 V
required rating = max(headroom, mcu min) = 500.00 mA

196.5 Hz का न्यूनतम कटऑफ वह संख्या है जिस पर फ़िल्टर सुधार निर्भर करता है, और कोड इसे मॉडल की अंकगणित पर छोड़ने के बजाय गणना करता है। सबसे कम अटेन्यूएशन टॉलरेंस कॉर्नर भी 100 Hz पर 15 dB से अधिक खोता है, इसलिए निर्णय टिकता है।

स्टेप 4: क्या Grok 4.7 API के माध्यम से वेब सर्च कर सकता है?

हाँ। वेब सर्च जाँचता है कि संलग्न दस्तावेज़ अभी भी वर्तमान हैं या नहीं, क्योंकि निर्माता किसी मॉडल के प्रशिक्षण कटऑफ के बाद डेटाशीट्स में संशोधन करते हैं। इसे आधिकारिक डोमेन्स तक सीमित करें ताकि साक्ष्य फर्स्ट-पार्टी रहे।

tools = [
    {"type": "code_interpreter"},
    {"type": "web_search", "filters": {"allowed_domains": ["ti.com", "espressif.com"]}},
]

पहले लिंक की गई वेब सर्च गाइड पाँच तक allowed_domains की अनुमति देती है, जिनमें docs.espressif.com जैसे सबडोमेन्स शामिल हैं। मैं इस स्टेप को तब भी रखूँगा जब संलग्न डेटाशीट्स वर्तमान हों, क्योंकि यह आपके अपलोड के बाद प्रकाशित किसी संशोधन को पकड़ सकता है।

उद्धरण क्या साबित करते हैं?

Grok को वर्तमान TI प्रोडक्ट पेज, ESP32-C3 डॉक्यूमेंटेशन, हार्डवेयर चेकलिस्ट, और किसी भी प्रासंगिक एराटा का हवाला देना चाहिए। उन उद्धरणों को स्रोत के साक्ष्य के रूप में लें, न कि इंजीनियरिंग निष्कर्ष के प्रमाण के रूप में।

डोमेन फ़िल्टर्स फिर भी एक अप्रासंगिक पेज दे सकते हैं। जाँचें कि हर उद्धरण ठीक उसी कंपोनेंट और सीमा का समर्थन करता है जो गणना में उपयोग हुई।

टर्मिनल ट्रेस जिसमें Grok संलग्न डेटाशीट्स खोज रहा है, कोड निष्पादन चला रहा है, और वेब सर्च से निर्माता पेज जाँच रहा है

Grok फाइलें खोजता है, गणना करता है, स्रोत जाँचता है। इमेज: लेखक द्वारा।

स्टेप 5: Grok 4.7 फ़ंक्शन कॉलिंग से वेरिफायर कैसे जोड़ें

verify_design() एक सादा Python फ़ंक्शन है जो आपकी मशीन पर चलता है, और वही एकमात्र जज है कि कोई रिविज़न पास होता है या नहीं। Grok फ़ंक्शन कॉलिंग के माध्यम से डिज़ाइन मान प्रस्तावित करता है, और यह फ़ंक्शन उन्हें स्थिर सीमाओं के विरुद्ध जाँचता है।

VERIFY_DESIGN_TOOL = {
    "type": "function",
    "name": "verify_design",
    "description": "Deterministically check an EnviroNode revision against EN-REQ-001...",
    "parameters": {
        "type": "object",
        "properties": {
            "revision": {"type": "string"},
            "regulator_part": {"type": "string"},
            "gain_rf_ohm": {"type": "number"},
            "gain_rg_ohm": {"type": "number"},
            "filter_r_ohm": {"type": "number"},
            "filter_c_nf": {"type": "number"},
        },
        "required": ["revision", "regulator_part", "gain_rf_ohm",
                     "gain_rg_ohm", "filter_r_ohm", "filter_c_nf"],
    },
}

पावर क्षमता को max((335 + 10) mA × 1.25, 500 mA) को पूरा करना चाहिए। ADC के लिए, 1.0 V × (1 + Rf/Rg) 1,500 और 2,250 mV के बीच रहना चाहिए। फ़िल्टर चेक्स 100 Hz पर हानि मापते हैं और कटऑफ को 500 Hz पर सीमित करते हैं; हर चेक एक मान, एक सीमा, और पास या फेल लौटाता है।

टूल स्कीमा केवल Grok को यह बताता है कि कौन से मान भेजने हैं। मूल पास-या-फेल लॉजिक सामान्य Python है:

import math

part = PARTS.get(regulator_part.strip().upper())
required_ma = max((335 + 10) * 1.25, 500)
power_ok = (
    part is not None
    and float(part["rated_iout_ma"]) >= required_ma
    and float(part["vin_max_v"]) >= 5.25
    and float(part["vout_v"]) == 3.3
)

gain = 1 + gain_rf_ohm / gain_rg_ohm
adc_mv = gain * 1000

fc = 1 / (2 * math.pi * filter_r_ohm * filter_c_nf * 1e-9)
loss_db = 10 * math.log10(1 + (100 / fc) ** 2)

checks = {
    "PWR-002": power_ok,
    "ADC-001": adc_mv <= 2250,
    "ADC-002": adc_mv >= 1500,
    "BW-001": loss_db <= 1.0,
    "BW-002": fc <= 500,
}
return {"all_pass": all(checks.values()), "checks": checks}

पूरा फ़ंक्शन अवैध मानों को भी अस्वीकार करता है और हर परिणाम के साथ माप लौटाता है। इसे किसी ज्ञात-अच्छे डिज़ाइन, ज्ञात-खराब डिज़ाइन, अज्ञात कंपोनेंट, और एक नज़दीकी मिस के साथ टेस्ट करें।

ग्रेडिंग मॉडल से नहीं, कोड से क्यों होनी चाहिए?

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

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

स्टेप 6: सर्किट को फिर से डिज़ाइन और वेरिफाई कैसे करें

Grok को एक लक्ष्य दें: हर पुष्ट उल्लंघन को सबसे छोटे युक्तिसंगत बदलावों के सेट से ठीक करें, और तब तक डिज़ाइन को पूरा न मानें जब तक पहले परिभाषित चेक पास न हो जाए। स्टेप 3 से 5 के साक्ष्य और टूल्स उपलब्ध कराएँ, फिर रिक्वेस्ट लिमिट सेट करें।

यही वह जगह है जहाँ TL;DR की कॉन्टेक्स्ट चेतावनी मायने रखती है। और टर्न जोड़ने से पहले इसे सुलझाएँ।

फ़ाइल-भारी लूप्स को कॉन्टेक्स्ट कॉम्पैक्शन की आवश्यकता क्यों होती है?

जारी रिक्वेस्ट में पहले के टूल परिणाम शामिल होते हैं, और दस्तावेज़ सर्च बहुत सारा टेक्स्ट लौटा सकते हैं। असफल प्रोटोटाइप में, अगला कंटिन्युएशन 1,116,321 टोकन तक पहुँचा और Grok 4.7 की 500,000-टोकन विंडो से ऊपर चला गया।

कॉन्टेक्स्ट कॉम्पैक्शन सीमा से ऊपर जा चुकी रिक्वेस्ट को नहीं बचा सकता। सुधरे हुए लूप में हर सफल डॉक्यूमेंट-सर्च टर्न के बाद अगली रिक्वेस्ट से पहले कॉम्पैक्ट किया जाता है।

details = (response.usage.model_extra or {}).get(
    "server_side_tool_usage_details", {}
)
observed_attachment_call = any(
    item.type == "custom_tool_call"
    and item.name in {"pdf_search", "pdf_browse"}
    for item in response.output
)
used_documents = (
    details.get("document_search_calls", 0) > 0
    or observed_attachment_call
)

if used_documents:
    compacted = client.responses.compact(
        model="grok-4.7", input=history + list(response.output) + follow_up)
    history = list(compacted.output)  # pass the compaction item back unchanged
    # Compaction drops tool output, so restate the verifier's verdict ourselves.
    history.append({"role": "user", "content":
                    "verify_design results, exactly as returned: " + json.dumps(results)})
else:
    history = history + list(response.output) + follow_up
response = client.responses.create(model="grok-4.7", input=history, tools=TOOLS,
                                   store=False, prompt_cache_key=cache_key)

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

क्या Rev B वेरिफिकेशन पास कर गया?

हाँ। Grok ने हर फेलिंग सबसिस्टम में एक-एक पार्ट बदला: पावर, ADC गेन, और फ़िल्टर बैंडविड्थ। आरेख Rev A और Rev B के ठीक-ठीक मान दिखाता है।

आरेख जो EnviroNode Rev A और Rev B में रेग्युलेटर, एम्प्लिफ़ायर गेन रेसिस्टर, और फ़िल्टर कैपेसिटर के बदलावों की तुलना करता है

तीन कंपोनेंट बदलाव Rev A को ठीक करते हैं। इमेज: लेखक द्वारा।

संशोधित मान फिर verify_design() को जाते हैं। यह प्रत्येक आवश्यकता के लिए एक परिणाम लौटाता है।

वेरिफायर आउटपुट जिसमें संशोधित रेग्युलेटर, ADC रेंज, और फ़िल्टर चेक्स पास दिख रहे हैं

संशोधित डिज़ाइन सभी वेरिफिकेशन चेक्स पास करता है। इमेज: लेखक द्वारा।

फेलिंग परिणाम एक function_call_output के रूप में वापस जाता है, ताकि Grok डिज़ाइन को तब तक संशोधित कर सके जब तक चेक पास न हो जाएँ या रिक्वेस्ट लिमिट पूरी न हो।

स्टेप 7: स्ट्रक्चर्ड सर्किट रिव्यू कैसे लौटाएँ

स्ट्रक्चर्ड आउटपुट ऐसी ऑब्जेक्ट लौटाते हैं जो स्कीमा से मेल खाते हैं, न कि वह गद्य जिसे आपको पार्स करना पड़े। उसी बातचीत में Pydantic मॉडल के साथ client.responses.parse() कॉल करें, टूल कॉल्स बंद रखकर।

class Finding(BaseModel):
    violated_requirement: str
    severity: Literal["blocker", "major", "minor"]
    evidence: list[str]
    recommended_change: str
    verifier_result: Literal["pass", "fail", "not_verified"]

parsed = client.responses.parse(
    model="grok-4.7", input=history + [REPORT_REQUEST],
    text_format=DesignReview, tools=TOOLS, tool_choice="none", store=False,
)

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

स्ट्रक्चर्ड रिव्यू ने क्या रिपोर्ट किया?

स्ट्रक्चर्ड रिपोर्ट को हर मूल दोष को रेज़ॉल्व्ड चिह्नित करना चाहिए, वेरिफायर द्वारा लौटाए गए मापे गए मान का हवाला देना चाहिए, और अनटेस्टेड चिंताओं को open_risks के अंतर्गत रखना चाहिए। इस डिज़ाइन के लिए, इनमें एक रेग्युलेटर शामिल है जो ठीक 500 mA फ़्लोर पर बैठता है और एक ADC कैपेसिटर जो Espressif की सिफारिश से भिन्न है।

क्या उच्च Grok 4.7 तर्क प्रयास सर्किट रिव्यू में सुधार करता है?

उच्च प्रयास ने वेरिफायर स्कोर में सुधार नहीं किया, लेकिन फ़िल्टर सुधार की गुणवत्ता बदल दी। हर स्तर को वही स्कीमैटिक, प्रॉम्प्ट, टूल्स, और रिक्वेस्ट लिमिट मिली।

Effort

Defects / false positives

Verifier calls

Input / cached

Output / reasoning

Tools

Time

Cost

low

3/3, 0; PASS

1

256,006 / 197,120

7,950 / 2,323

7

111.2 s

$0.2990

high

3/3, 0; PASS

1

364,611 / 131,456

21,904 / 14,268

15

292.8 s

$0.7385

xhigh

3/3, 0; PASS

2

413,071 / 336,896

19,685 / 14,800

17

277.8 s

$0.5239

low ने रेसिस्टर घटाया और 1 µF कैपेसिटर रखा, जिससे कैपेसिटिव-लोड और सेटलिंग व्यवहार वेरिफायर के बाहर रह गया। Microchip की कैपेसिटिव-लोड मार्गदर्शिका कहती है कि सीरीज़ रेसिस्टर स्थिरता में सुधार कर सकता है, इसलिए यह परिणाम यह साबित नहीं करता कि सुधार अस्थिर है; यह फ़्रीक्वेंसी-रिस्पॉन्स, स्टेप-रिस्पॉन्स, या बेंच टेस्टिंग की माँग करता है। high ने कैपेसिटर बदला, जबकि xhigh ने एक अतिरिक्त वेरिफायर कॉल के बाद high जैसे ही अंतिम मान चुने।

xhigh तर्क कब सार्थक है?

इस एकल तुलना के लिए, high बेहतर संतुलन देता है। इसने अनमॉडल्ड लोड चिंता से बचा लिया, बिना xhigh द्वारा किए गए अतिरिक्त वेरिफायर कॉल के। प्रति स्तर एक निष्पादन कोई सामान्य रैंकिंग स्थापित नहीं कर सकता।

क्या Grok 4.7 ने सर्किट ठीक किया?

प्रारंभिक प्रश्न का उत्तर हाँ है, वेरिफायर के पाँच चेक्स के भीतर। तालिका पहले के निष्कर्षों को एक दृश्य में संक्षेपित करती है।

  • इमेज और आवश्यकताएँ
    • जोड़ता है: दृश्य निरीक्षण
    • परिणाम: वह पुष्टि करता है जो केवल स्कीमैटिक साबित कर सकता है
  • डेटाशीट्स
    • जोड़ता है: निर्माता सीमाएँ
    • परिणाम: दो खुले प्रश्नों को निष्कर्षों में बदलता है
  • कोड निष्पादन
    • जोड़ता है: जाँची गई गणनाएँ
    • परिणाम: पावर और फ़िल्टर समस्याओं को मापता है
  • वेब सर्च
    • जोड़ता है: वर्तमान आधिकारिक स्रोत
    • परिणाम: जाँचता है कि संलग्न साक्ष्य वर्तमान हैं या नहीं
  • लोकल वेरिफायर
    • जोड़ता है: Python से पास या फेल
    • परिणाम: केवल उसी रिविज़न को स्वीकार करता है जो हर नियम पास करे

Grok ने एन्कोडेड आवश्यकताओं को ठीक किया। उसने यह साबित नहीं किया कि संशोधित बोर्ड विद्युत रूप से पूर्ण था या उत्पादन के लिए तैयार था।

दस्तावेज़ तय करते हैं कि किसी चिंता का साक्ष्य है या नहीं। Python तय करता है कि कोई रिविज़न पास होता है या नहीं। धाराप्रवाह गद्य इनमें से किसी का स्थानापन्न नहीं हो सकता।

Streamlit में रिव्यू देखें

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

लाइव रिव्यू टूल्स और रिपोर्ट दिखाता है। वीडियो: लेखक द्वारा।

पूरे रिव्यू की लागत क्या आई?

इमेज-ओनली बेसलाइन से लेकर high रीडिज़ाइन तक प्रोग्रेसिव पथ की लागत लगभग $3.10 आई। इस कुल में स्टेप 1 से 4 के साथ अंतिम रीडिज़ाइन और स्ट्रक्चर्ड रिपोर्ट शामिल हैं।

अलग low/high/xhigh तुलना में लगभग $1.56 और जुड़ा। बिल की गई राशियाँ cost_in_usd_ticks से आती हैं; $3.10 में कॉम्पैक्शन के लिए अनुमानित $0.11 शामिल है क्योंकि उस रिस्पॉन्स में टोकन काउंट्स थे पर बिल्ड-कॉस्ट फ़ील्ड नहीं था। असफल सेटअप और डीबगिंग रिक्वेस्ट्स शामिल नहीं हैं।

Grok 4.7 सर्किट रिव्यू सीमाएँ

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

  • स्कीमैटिक इमेज हार्डवेयर डिज़ाइन नहीं है: कोई प्रिंटेड सर्किट बोर्ड (PCB) लेआउट या थर्मल चेक नहीं चला, और कोई बोर्ड बना नहीं
  • वेरिफायर ब्लाइंड स्पॉट बना सकता है: यह कैपेसिटिव-लोड स्थिरता, सेटलिंग, LDO थर्मल डिसिपेशन, या कंपोनेंट टॉलरेंस कॉर्नर्स जाँचता नहीं

तर्क तुलना एक केस स्टडी है, EEBench जैसे बेंचमार्क नहीं। वास्तविक हार्डवेयर के लिए, रिविज़न स्वीकार करने से पहले सिमुलेशन, टॉलरेंस विश्लेषण, और मानव अनुमोदन जोड़ें।

अंतिम विचार

सर्किट रिव्यूअर ने तीनों डाले गए दोष खोजे और ठीक किए, पर परिणाम पूरी तरह साफ़ जीत नहीं था। Rev B ने पहली सबमिशन में पाँचों चेक पास किए, जबकि low तुलना ने एक कैपेसिटिव-लोड और सेटलिंग जोखिम उजागर किया जिसे वे चेक्स कवर नहीं करते थे। अधिक कठिन API समस्या दस्तावेज़-भारी हिस्ट्री को 500,000-टोकन विंडो के अंदर रखना था।

मैं किसी बड़े बोर्ड का परीक्षण करने से पहले ऑप-एम्प लोड और सेटलिंग चेक्स जोड़ूँगा, फिर ऐसा केस डिज़ाइन करूँगा जहाँ पहला रिविज़न फेल हो ताकि लूप को रिकवर करना पड़े। मैं साक्ष्य पढ़ने और बदलाव प्रस्तावित करने की ज़िम्मेदारी Grok पर रखूँगा, लिखित आवश्यकताओं की ज़िम्मेदारी Python पर, और अंतिम साइन-ऑफ़ किसी इंजीनियर पर छोड़ूँगा।

Khalid Abdelaty

लेखक

Khalid Abdelaty

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

FAQs

क्या Grok 4.7 API उपयोग के लिए मुफ्त है?

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

क्या आप OpenAI SDK की जगह xAI Python SDK उपयोग कर सकते हैं?

हाँ, xai-sdk grok-4.7 के साथ काम करता है, लेकिन कुछ नाम अलग हैं: वहाँ कोड निष्पादन code_execution है और OpenAI SDK में code_interpreter । उदाहरण OpenAI SDK का उपयोग करते हैं क्योंकि वही Responses फ़ॉर्मेट अन्य प्रदाताओं पर भी लागू होता है।

क्या Grok 4.7 टूल कॉल्स को होते समय स्ट्रीम कर सकता है?

हाँ। रन के दौरान एक्टिविटी प्राप्त करने के लिए stream=True पास करें। इस इम्प्लीमेंटेशन में, पूर्ण टूल आइटम्स response.output_item.done के माध्यम से आए, और अंतिम response.completed इवेंट में usage ऑब्जेक्ट था; SDK या API अपग्रेड करते समय सटीक इवेंट नाम सत्यापित करें।

क्या xAI अपलोड की गई स्कीमैटिक्स और डेटाशीट्स स्टोर करता है?

डिफ़ॉल्ट रूप से, xAI API रिक्वेस्ट्स और रिस्पॉन्सेज़ को 30 दिनों तक रखता है और आपकी अनुमति के बिना उन पर ट्रेन नहीं करता। अपलोड की गई फाइलें तब तक रहती हैं जब तक आप उन्हें डिलीट नहीं करते या expires_after समाप्त नहीं होता। Zero Data Retention यहाँ उपयोग किए गए Files API को निष्क्रिय कर देता है, इसलिए दस्तावेज़ उपलब्ध कराने का अलग तरीका चाहिए।

क्या Grok 4.7 किसी इलेक्ट्रिकल इंजीनियर की जगह ले सकता है?

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

विषय