एक ऑटोनॉमस (Autonomous) AI एजेंट को आमतौर पर तीन अलग-अलग मॉड्यूल्स को मिलाकर तैयार किया जाता है: ऑन-चेन डेटा कलेक्टर (RPC नोड्स और इंडेक्सर APIs), कॉग्निटिव कोर (कम लेटेंसी वाली LLM) और ट्रांजैक्शन एग्जीक्यूशन गेटवे (Action Layer)। अगर आप अपने ट्रेडिंग लॉजिक को GPT-4o जैसे भारी सेंसरशिप वाले कमर्शियल मॉडल्स के भरोसे छोड़ने की सोच रहे हैं, तो भारी वोलैटिलिटी (volatility) के समय अपनी API keys के ब्लॉक होने के लिए तैयार रहिए। इनके इंटरनल सेफ्टी फिल्टर्स अक्सर ट्रेडिंग सिग्नल्स के ट्रांसमिशन को फाइनेंशियल रिस्क जनरेट करने की कैटेगरी में डाल देते हैं। बिना किसी रुकावट के ऑटोमेशन चलाने के लिए, अनसेंसर्ड ओपन-वेट्स मॉडल्स (जैसे Llama 3.3 70B, DeepSeek V3) का इस्तेमाल करना ही बेस्ट है, जिन्हें डिसेंट्रलाइज्ड होस्टिंग पर डिप्लॉय किया गया हो या फिर जो Venice AI जैसे स्पेशलाइज्ड गेटवे के जरिए एक्सेसिबल हों।
इसके एग्जीक्यूशन लेयर को ऐसे इन्फ्रास्ट्रक्चर से कनेक्ट किया जाता है जहां पिंग (ping) बिल्कुल मिनिमम हो। परपेचुअल कॉन्ट्रैक्ट्स (perps) के सेगमेंट में Hyperliquid API आज के समय में एक गोल्ड स्टैंडर्ड बन चुका है, क्योंकि यह एक डेडिकेटेड L1 ऐपचेन पर काम करता है जहां ऑर्डर्स की प्रोसेसिंग स्पीड 0.1 सेकंड तक की होती है। कॉग्निटिव कोर का आपके वॉलेट पर कोई डायरेक्ट एक्सेस नहीं होता: मॉडल को मार्केट मैट्रिक्स का एक पूरा ऐरे (array) मिलता है और वह JSON फॉर्मेट में केवल रिकमेंडेशन देता है। इसके बाद लोकल Python स्क्रिप्ट नेटवर्क पर भेजने से पहले उस रिस्पॉन्स को सख्त रिस्क लिमिट्स के पैमाने पर अच्छी तरह वैरिफाई करती है।
कोड ये रहा, और Hyperliquid API के डॉक्यूमेंटेशन को आप यहाँ पढ़ सकते हैं: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# एनवायरनमेंट से कीज निकाल रहे हैं, स्क्रिप्ट में प्राइवेट कीज को हार्डकोड करना सीधे आफत को बुलावा देना है
VENICE_URL = "https://api.venice.ai/api/v1/chat/completions"
VENICE_KEY = os.getenv("VENICE_API_KEY", "")
WALLET_KEY = os.getenv("AGENT_PRIVATE_KEY", "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")def get_market_data(coin="ETH"):
# सीधे Hyperliquid ऐपचेन से ऑर्डरबुक और करंट फंडिंग डेटा पार्स कर रहे हैं
try:
r = requests.post("https://api.hyperliquid.xyz/info", json={"type": "metaAndAssetCtxs"}, timeout=8)
res = r.json()
universe = res[0]["universe"]
ctxs = res[1]
idx = next(i for i, a in enumerate(universe) if a["name"] == coin)
return {
"ticker": coin,
"price": float(ctxs[idx]["midPrice"]),
"funding": float(ctxs[idx]["funding"]),
"oi": float(ctxs[idx]["openInterest"])
}
except Exception:
return None # अगर HL में लैग आ रहा है, तो ऑर्डर्स को मत छुओ, सेफ्टी सबसे पहले हैdef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# मॉडल को एक सख्त दायरे में बांध रहे हैं ताकि वह फालतू टेक्स्ट न दे। हमें सिर्फ क्लीन JSON चाहिए
prompt = (
"You are a trading bot execution engine. Analyze the metrics. "
"Return JSON ONLY. No markdown blocks, no text explanations. "
"Format: {\"action\": \"BUY\"|\"SELL\"|\"HOLD\", \"pct\": int, \"leverage\": int}"
)
payload = {
"model": "llama-3.3-70b-instruct",
"messages": [
{"role": "system", "content": prompt},
{"role": "user", "content": f"Data: {json.dumps(context)}"}
],
"temperature": 0.1 # हैलुसिनेशन्स और क्रिएटिविटी को पूरी तरह खत्म करने के लिए
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# अगर मॉडल ने गड़बड़ करके कोड ब्लॉक मार्कडाउन जोड़ दिया है, तो बैकस्टिक्स हटा रहे हैं
if "```" in out:
out = out.split("```")[1].replace("json", "").strip()
return json.loads(out)
except Exception:
return {"action": "HOLD", "pct": 0, "leverage": 1}def filter_limits(decision, current_price):
# एक मजबूत सेफ्टी फ्यूज। अगर मॉडल का दिमाग घूमा, तो कोड उसे तुरंत रोक देगा
if decision["action"] not in ["BUY", "SELL"]:
return None
# लेवरेज को मैक्सिमम 3x और वॉल्यूम को टोटल डिपॉजिट के 5% तक लिमिट कर रहे हैं
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# 0.3% का स्लिपेज लेकर चल रहे हैं ताकि ऑर्डर तुरंत एग्जीक्यूट हो जाए
slip = 1.003 if decision["action"] == "BUY" else 0.997
return {
"coin": "ETH",
"side": decision["action"],
"px": round(current_price * slip, 2),
"lev": leverage,
"size_pct": pct
}def run_pipeline():
if WALLET_KEY != "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":
acc = Account.from_key(WALLET_KEY)
print(f"[+] बोट इस एड्रेस के लिए एक्टिव है: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] HL के साथ कोई कनेक्शन नहीं है।")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] ऑर्डर तैयार हो चुका है: {json.dumps(final_order)}")
else:
print("[*] सही कंडीशन्स का इंतजार है, पोजीशन में कोई बदलाव नहीं।")if __name__ == "__main__":
run_pipeline()लेंडिंग मार्केट्स पर Yield Farming का ऑटोमेशन
स्पॉट DeFi सेक्टर में एजेंट्स को आमतौर पर Morpho Blue या Fluid जैसे आइसोलेटेड पूल्स या फिर पुराने और भरोसेमंद Aave V3 में डेट पोजीशन्स (debt positions) को मैनेज करने के लिए ट्रेन किया जाता है। यहाँ सबसे बड़ी सिरदर्दी लगातार हेल्थ फैक्टर (Health Factor या HF) कैलकुलेट करने की होती है, वरना पोजीशन के परखच्चे उड़ने में देर नहीं लगेगी। बोट RPC के जरिए PoolLens कॉन्ट्रैक्ट को हिट करता है और बिल्कुल ट्रेडिशनल तरीके से रिस्क का हिसाब लगाता है:
अगर मार्केट नीचे जाने लगता है और कोलेटरल (collateral) की वैल्यू गिरने लगती है, तो एजेंट को खुद आगे बढ़कर कर्ज का आंशिक भुगतान (Self-Deleverage) शुरू कर देना चाहिए। अपने खुद के पैसे फंसाने से बचने के लिए, वह Balancer या Uniswap V3 के जरिए फ्लैश लोन (flash loans) का इस्तेमाल करता है। यह बेहद क्रिटिकल है, क्योंकि Morpho जैसे प्लेटफॉर्म्स पर लिक्विडेशन पेनल्टी बहुत ज्यादा होती है, और आप पलक झपकते ही अपने पूरे फंड का 10-15% गंवा सकते हैं।
अगर आपका बोट भारी-भरकम APY के चक्कर में एक पूल से दूसरे पूल में छलांग लगाता रहता है, तो कोड के अंदर ट्रांजैक्शन कॉस्ट का एक कड़ा कैलकुलेशन सेट करना बेहद जरूरी है। स्क्रिप्ट ParaSwap या 1inch API को कॉल करके लेटेस्ट कोट्स निकालती है और टोटल प्रॉफिट में से गैस फीस और स्लिपेज (slippage) के नुकसान को माइनस करती है। अगर आर्बिट्रम (Arbitrum) से बेस (Base) पर स्टेबलकॉइन्स का ट्रांसफर करने की कॉस्ट को रिकवर करने में 72 घंटे से ज्यादा का समय लग रहा है, तो सीधे उस मॉडल को रिजेक्ट कर दीजिए। ट्रांजैक्शन स्क्रिप्ट के बेस लॉजिक लेवल पर ही ब्लॉक हो जाएगा, भले ही LLM अपनी प्रेडिक्शन्स में उसे कितनी ही टॉप प्रायोरिटी पर क्यों न रख रहा हो।
ऑटोनॉमस सिस्टम्स के लिए रिस्क मैट्रिक्स
पूरा का पूरा वॉलेट किसी LLM के हाथ में सौंप देना हमेशा एक बहुत बड़ा सुसाइडल कदम है। न्यूरल नेटवर्क्स के पास अपने खुद के ऐसे अजीबोगरीब बग्स होते हैं, जो पारंपरिक एल्गोरिदमिक ट्रेडिंग (algorithmic trading) की दुनिया में कभी देखने को भी नहीं मिले।
- डेटा फीड का करप्शन (Data Poisoning)
हैकर्स या अटैकर्स ऑन-चेन फेक ट्रांजैक्शंस चलाने लगते हैं या सोशल मीडिया पर फेक न्यूज की बाढ़ ला देते हैं। AI इसे "एक बहुत बड़े बुलिश ट्रेंड की शुरुआत" मान लेता है और बिल्कुल टॉप प्राइस (highs) पर जाकर खरीदारी करने लगता है।
सोल्यूशन - मल्टी-सोर्स वेरिफिकेशन। स्क्रिप्ट को सोशल मीडिया के टेक्स्ट वाले कचरे को ब्लॉकचेन से सीधे मिलने वाले असली ट्रेडिंग वॉल्यूम के साथ क्रॉस-चेक करना चाहिए। अगर पूल में कोई रियल लिक्विडिटी नहीं है — तो उसे सीधे इग्नोर मारो। - फॉर्मेटिंग एरर्स (JSON Break)
मार्केट में अचानक भयंकर वोलैटिलिटी शुरू होती है, मॉडल पैनिक कर जाता है, कोई इनवर्टेड कॉमा बंद करना भूल जाता है, रिस्पॉन्स में फालतू का टेक्स्ट जोड़ देता है या JSON का स्ट्रक्चर बिगाड़ देता है। स्क्रिप्ट क्रैश हो जाती है और बोट बंद पड़ जाता है।
सोल्यूशन - सख्त try/except ब्लॉक लगाना। LLM के रिस्पॉन्स को पार्स करते समय आने वाली कोई भी सिंटैक्स एरर लॉजिक को तुरंत HOLD (पोजीशन होल्ड रखने) के मोड में डाल देनी चाहिए। फंड की सुरक्षा से बढ़कर कुछ नहीं है। - रीबैलेंसिंग का फ्रंटरनिंग (Frontrunning)
बोट लिक्विडिटी को दूसरी जगह ट्रांसफर करने के लिए ट्रांजैक्शन को पब्लिक मेमपूल (mempool) में भेजता है, जहाँ MEV बोट्स पहले से ही ताक लगाकर बैठे होते हैं। नतीजा यह होता है कि हम एक तगड़े स्लिपेज का शिकार बन जाते हैं और पैसे गंवा देते हैं।
सोल्यूशन - प्राइवेट RPCs का इस्तेमाल। सभी ट्रांजैक्शंस को सीधे Flashbots Protect या BuilderRPC के जरिए भेजें, पब्लिक मेमपूल को पूरी तरह बाईपास करके, ताकि हमारी मूवमेंट किसी को दिखाई न दे। - नेटवर्क लैग का कबाड़ा (Cascading Latency)
मार्केट के बहुत तेजी से टूटने पर L1 में गैस फीस अचानक आसमान छूने लगती है। मार्जिन टॉप-अप करने के लिए बोट द्वारा भेजी गई ट्रांजैक्शंस पेंडिंग होकर अटक जाती हैं, और पोजीशन आराम से लिक्विडेट हो जाती है।
सोल्यूशन - गैस और लिक्विडिटी का एक्स्ट्रा बैकअप। वॉलेट के बैलेंस में हमेशा कुल फंड का 15-20% हिस्सा नेटिव टोकेन्स (ETH/SOL) के रूप में बिना छुए सुरक्षित रखें, और maxFeePerGas में नेटवर्क के करंट मीडियन वैल्यू से कम से कम +50% का एक्स्ट्रा बैकअप जोड़कर रखें।
इन सब बातों का सीधा सा मतलब यही है कि कॉग्निटिव पार्ट (LLM) के भरोसे रिस्क मैनेजमेंट को छोड़ना अपने पैरों पर कुल्हाड़ी मारने जैसा है। मॉडल केवल एक फ्लेक्सिबल एनालिस्ट के तौर पर बेहतरीन काम कर सकता है, जो छिपे हुए पैटर्न्स और प्रॉफिटेबल पूल्स को ढूंढ निकाले। लेकिन पोजीशन का साइज क्या होगा, मैक्सिमम लेवरेज कितना रहेगा, और मार्केट से इमरजेंसी एग्जिट करने के ट्रिगर्स क्या होंगे — ये सब चीजें कोड के अंदर मजबूती से हार्डकोडेड होनी चाहिए।
