−25%

Windows के सालाना भुगतान पर, 31 अक्टूबर तक। प्लान देखें

EQVPS
शुरू करें

सैंडबॉक्स में आपका पहला एजेंट टास्क: LLM कोड लिखता है, microVM उसे चलाता है

AI से कोड चलाने का सबसे छोटा काम का लूप बनाएँ: मॉडल Python स्क्रिप्ट लिखता है, Firecracker सैंडबॉक्स उसे चलाता है, और त्रुटियाँ तब तक मॉडल के पास लौटती हैं जब तक स्क्रिप्ट चल न जाए। लगभग 40 लाइनें, साथ में बिना किसी कोड के MCP से यही टास्क।

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

आपको Python 3.8+, EQVPS अकाउंट टोकन (अकाउंट जोड़ना देखें) और किसी मॉडल की API की चाहिए।

1. पहले खर्च सीमा तय करें

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

curl -X PUT https://api.eqvps.com/api/v1/eqvps/sandboxes/budget \
  -H "Authorization: Bearer $EQVPS_API_KEY" -H "Content-Type: application/json" \
  -d '{"daily_usd": 2, "monthly_usd": 20}'

सीमा पूरी होने पर नए सैंडबॉक्स को 429 budget_exceeded मिलता है और चल रहे अस्थायी सैंडबॉक्स हटा दिए जाते हैं। विवरण सैंडबॉक्स की सीमाएँ और बिलिंग में है।

2. दो लाइब्रेरी इंस्टॉल करें

pip install eqvps anthropic
export EQVPS_API_KEY="your-eqvps-token"
export ANTHROPIC_API_KEY="your-model-key"

उदाहरण एक मॉडल प्रदाता इस्तेमाल करता है, लेकिन कुछ भी उस पर निर्भर नहीं। मॉडल से सिर्फ़ ask() फ़ंक्शन बात करता है।

3. लिखो, चलाओ, सुधारो लूप

इसे agent.py नाम से सेव करें:

import re
import anthropic
from eqvps import Sandbox

TASK = "Count the prime numbers below 1,000,000 and print only the number."
client = anthropic.Anthropic()

def ask(messages):
    msg = client.messages.create(model="claude-sonnet-5", max_tokens=2000, messages=messages)
    return msg.content[0].text

def extract_code(text):
    m = re.search(r"`{3}(?:python)?\n(.*?)`{3}", text, re.S)
    return m.group(1) if m else text

messages = [{"role": "user", "content": "Write a Python 3 script for this task. "
             "Reply with a single code block and nothing else.\n\nTask: " + TASK}]

with Sandbox.create(tariff="small", idle_timeout=120) as sb:
    for attempt in range(1, 4):
        reply = ask(messages)
        r = sb.run(extract_code(reply), timeout=55)
        print(f"attempt {attempt}: exit code {r.exit_code}")
        if r.ok:
            print(r.stdout.strip())
            break
        messages += [
            {"role": "assistant", "content": reply},
            {"role": "user", "content": f"The script failed with exit code {r.exit_code}.\n"
             f"stderr:\n{r.stderr[-3000:]}\nFix it. Reply with a single code block."},
        ]

चलाएँ:

python3 agent.py

आम तौर पर यह attempt 1: exit code 0 और फिर 78498 छापता है। अगर पहली स्क्रिप्ट फ़ेल हो, तो आपको त्रुटि ठीक की हुई दूसरी कोशिश दिखेगी।

हर हिस्सा क्या करता है:

  • Sandbox.create(..., idle_timeout=120) लगभग एक सेकंड में microVM चालू करता है। अगर आपकी स्क्रिप्ट बीच में बंद हो जाए, तब भी सैंडबॉक्स 2 मिनट की निष्क्रियता के बाद खुद हट जाता है।
  • sb.run(code, timeout=55) कोड चलाता है और एग्ज़िट कोड, stdout और stderr लौटाता है। कोड का क्रैश होना सामान्य नतीजा है, exception नहीं, इसलिए लूप उसे मॉडल को दिखा सकता है।
  • r.stderr[-3000:] त्रुटि का सिर्फ़ आखिरी हिस्सा भेजता है। बड़ी स्क्रिप्ट का पूरा traceback मॉडल का बहुत सारा कॉन्टेक्स्ट बर्बाद कर सकता है।
  • तीन कोशिशें जानबूझकर रखी गई सीमा है। जो मॉडल तीन बार में स्क्रिप्ट ठीक न कर पाए, उसे आमतौर पर चौथी कोशिश नहीं, बेहतर टास्क विवरण चाहिए।

4. जब टास्क को 55 सेकंड से ज़्यादा चाहिए

एक सिंक्रोनस कॉल ज़्यादा से ज़्यादा 55 सेकंड चलती है। लंबे काम को बैकग्राउंड में शुरू करें और इंतज़ार करें:

task = sb.run(code, background=True)
result = task.wait(timeout=1800)

आपका wait टाइमआउट हो जाए तब भी टास्क चलता रहता है, और आप sb.task(task_id) से उसे फिर उठा सकते हैं।

5. यही टास्क MCP से, बिना कोड

अगर आप Claude Desktop या Cursor जैसा MCP क्लाइंट EQVPS MCP सर्वर के साथ इस्तेमाल करते हैं, तो एजेंट के पास सैंडबॉक्स टूल पहले से हैं: create_sandbox, run_code, exec_command, upload_file, download_file और kill_sandbox। एक प्रॉम्प्ट काफ़ी है:

एक छोटा अस्थायी सैंडबॉक्स बनाओ। एक Python स्क्रिप्ट लिखो जो 1,000,000 से कम अभाज्य संख्याएँ गिने, उसे वहाँ चलाओ, फ़ेल हो तो सुधारो, मुझे नतीजा बताओ और सैंडबॉक्स हटा दो।

एजेंट वही कॉल करता है जो ऊपर की स्क्रिप्ट करती है। कौन-से टूल बिना पुष्टि के अनुमति देना सुरक्षित है, यह MCP सुरक्षा उपाय में बताया गया है।

इसमें कितना खर्च हुआ

सैंडबॉक्स एक मिनट से काफ़ी कम चला और न्यूनतम 60 सेकंड के हिसाब से बिल हुआ: small पर $0.00055। मॉडल कॉल का खर्च सैंडबॉक्स से ज़्यादा है। नए अकाउंट का $1 ट्रायल क्रेडिट ऐसे लगभग 1,800 रन के लिए काफ़ी है।

आगे कहाँ जाएँ

सामान्य प्रश्न

मॉडल का कोड सीधे अपनी मशीन पर क्यों न चलाऊँ?

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

क्या यह उदाहरण वाले मॉडल के अलावा दूसरे मॉडल के साथ भी चलता है?

हाँ। लूप को बस एक ऐसा फ़ंक्शन चाहिए जो मैसेज ले और टेक्स्ट लौटाए। ask() फ़ंक्शन को किसी भी चैट API से बदलें, लोकल मॉडल से भी।

एजेंट को अनगिनत सैंडबॉक्स बनाने से क्या रोकता है?

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

क्या जनरेट किया गया कोड इंटरनेट तक जा सकता है?

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

टिप्पणियाँ

अभी तक कोई टिप्पणी नहीं। पहले बनें।

एक टिप्पणी छोड़ें

टिप्पणियाँ दिखने से पहले मॉडरेट की जाती हैं।