Genesis Arbitrage

Genesis Arbitrage · · 15 मिनट में पढ़ें

AI एजेंट के लिए क्रिप्टो मार्केट डेटा: API, function calling, MCP और llms.txt

संक्षेप में

  • भाषा मॉडल बाज़ार को केवल अपने प्रशिक्षण डेटा की कटऑफ़ तारीख तक जानता है। मौजूदा कीमतें, स्प्रेड और funding rate उसे टूल से मिलते हैं: मॉडल कॉल और उसके आर्गुमेंट चुनता है, और आपका कोड API रिक्वेस्ट भेजता है।
  • मार्केट डेटा API के ऊपर टूल संकीर्ण होना चाहिए: एक endpoint, फ़िल्टर पैरामीटर में, ज़रूरी फ़ील्ड वाली कुछ पंक्तियाँ और नतीजे में डेटा का समय। टूल की परिभाषाएँ OpenAPI स्पेसिफ़िकेशन से आती हैं, और MCP वही टूल किसी भी संगत क्लाइंट से जोड़ देता है।
  • key आपके सर्वर पर रहती है, बाहरी डेटा का टेक्स्ट मॉडल तक केवल टूल के नतीजे के अंदर पहुँचता है, और हर ट्रेड की पुष्टि इंसान करता है। Genesis API केवल पढ़ने के लिए है और एजेंट के लिए openapi.json, llms-full.txt और API कैटलॉग प्रकाशित करता है।

AI एजेंट क्रिप्टो मार्केट डेटा टूल के ज़रिए पाता है: मॉडल तय करता है कि उसे कौन-सा डेटा चाहिए, आपका कोड Crypto API को कॉल करता है और उसे कीमतों, स्प्रेड और डेटा बनने के समय वाला छोटा JSON लौटाता है। टूल या तो मॉडल के API में function calling से जोड़े जाते हैं या MCP सर्वर से, और दोनों साधारण REST API के ऊपर चलते हैं।

उदाहरण Genesis API पर बने हैं, जो CEX, DEX, ऑन-चेन और प्रेडिक्शन मार्केट के डेटा वाला केवल पढ़ने के लिए REST API है। आम तौर पर Crypto API और उनकी तुलना कैसे करें, इसके लिए देखें Crypto API: मार्केट डेटा API के प्रकार और चुनाव कैसे करें।

मॉडल को मौजूदा कीमतें क्यों नहीं पता

भाषा मॉडल को एक निश्चित तारीख तक जमा किए गए टेक्स्ट पर प्रशिक्षित किया जाता है, यानी उसकी knowledge cutoff तक। उसके बाद की लिस्टिंग, दरों और कीमतों के बारे में वह कुछ नहीं जानता, और याददाश्त से बताई गई BTC की कीमत अज्ञात तारीख़ के प्रशिक्षण टेक्स्ट का एक आंकड़ा है। मॉडल को मौजूदा समय भी नहीं पता, जब तक आप उसे रिक्वेस्ट में न दें।

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

मॉडल को क्या चाहिएकहाँ से आता हैउदाहरण
API के पाथ, पैरामीटर और फ़ील्डसंदर्भ में रेफ़रेंसllms-full.txt, openapi.json
कीमतें, स्प्रेड, दरेंटूल कॉलGET /funding/spread?coin=TON
मौजूदा समय और डेटा की उम्रसिस्टम प्रॉम्प्ट और टूल का नतीजाupdated_at, age_sec

function calling कैसे काम करती है

Function calling वह मोड है जिसमें मॉडल टेक्स्ट की जगह टूल का नाम और आर्गुमेंट लौटाता है, और रिक्वेस्ट आपका कोड चलाता है। उदाहरण (समझाने के लिए): उपयोगकर्ता पूछता है कि TON पर इस समय सबसे बड़ा funding स्प्रेड कहाँ है। कॉल और नतीजा, योजनाबद्ध रूप में:

{
  "tool_call": {
    "name": "get_funding",
    "arguments": { "coin": "TON" }
  },
  "tool_result": {
    "updated_at": 1794675860,
    "age_sec": 12,
    "rows": [
      {
        "coin": "TON",
        "spread_pct": 0.04,
        "pair": ["Bitget", "Bybit"],
        "funding_pct": [0.05, 0.01],
        "interval": ["8h", "8h"]
      }
    ]
  }
}
  1. ऐप मॉडल को सवाल और टूल की परिभाषाएँ भेजता है: नाम, उद्देश्य और JSON Schema में आर्गुमेंट की स्कीमा।
  2. मॉडल आर्गुमेंट {"coin": "TON"} के साथ get_funding का कॉल लौटाता है।
  3. आपका कोड आर्गुमेंट जाँचता है, X-API-Key हेडर के साथ GET /funding/spread?coin=TON भेजता है और रिस्पॉन्स छोटा करता है।
  4. नतीजा मॉडल को लौटता है, जो जवाब देता है: Bitget और Bybit, हर 8 घंटे पर 0.05% और 0.01%, अंतर 0.04%, डेटा 12 सेकंड पुराना।
  5. अगर डेटा काफ़ी नहीं है, तो मॉडल अगला टूल कॉल करता है।

मॉडल कोई नेटवर्क रिक्वेस्ट नहीं करता और API key को कभी नहीं देखता। फ़ील्ड के नाम मॉडल के API पर निर्भर करते हैं: Claude API में स्कीमा input_schema में रहती है, कॉल tool_use ब्लॉक के रूप में आता है और नतीजा tool_result ब्लॉक के रूप में लौटता है, जबकि MCP स्कीमा को inputSchema कहता है। दोनों में यह JSON Schema है।

मार्केट डेटा API के ऊपर टूल कैसे डिज़ाइन करें

एक टूल, एक काम

मॉडल टूल को उसके विवरण से चुनता है, इसलिए संकीर्ण टूल सामान्य call_api(path, params) से ज़्यादा भरोसेमंद चलते हैं। एजेंट के कामों के लिए बने पाँच से सात टूल में से चुनना स्पेसिफ़िकेशन के 37 ऑपरेशन में से चुनने से आसान है।

टूलGenesis API endpointप्लान
get_spreads/arbitrage/spot-spotसभी
get_funding/funding/spreadसभी
get_prediction_arbs/predictions/arbitrageStart, Pro, Max
get_book/orderbooks/bookPro, Max

विवरण में लिखें कि टूल कब कॉल करना है और संख्याएँ किस इकाई में हैं: Genesis API में स्प्रेड और दरें प्रतिशत में हैं, इसलिए 0.92 का मतलब 0.92% है।

फ़िल्टर पैरामीटर के रूप में, जाँच कोड में

API के फ़िल्टर, जैसे coin, exchange और min_spread, टूल के पैरामीटर बन जाते हैं। मॉडल उन्हें सवाल से भरता है, हैंडलर उन्हें पैरामीटर, प्रकार और मानों की अनुमत सूची से जाँचता है, और enum अनुमत मान तय करता है: /orderbooks/book के लिए market केवल spot या futures है। मॉडल रिक्वेस्ट का पाथ कभी नहीं बनाता, और स्कीमा अतिरिक्त फ़ील्ड ठुकरा देती है (additionalProperties: false)।

फ़िल्टर किया गया रिस्पॉन्स ETag के बिना आता है, इसलिए हर दोहराया गया फ़िल्टर्ड पोल एक कॉल खर्च करता है: मुफ़्त 304 नहीं मिलता। अगर एजेंट को दर्जनों कॉइन चाहिए, तो पूरा बिना फ़िल्टर वाला डेटासेट लोकल रखना और उसे If-None-Match से पोल करना सस्ता है।

संक्षिप्त नतीजे

उदाहरण (समझाने के लिए): बिना फ़िल्टर वाला पूरा /funding/spread रिस्पॉन्स 1,000 कॉइन कवर करता है। 10 एक्सचेंज वाले कॉइन की एक पंक्ति में 2 + 10 + 8 × 5 = 52 मान होते हैं: कॉइन, स्प्रेड, best में सबसे अच्छी जोड़ी के 10 फ़ील्ड और others में बाकी 8 एक्सचेंज में से हर एक के 5 फ़ील्ड। पूरा रिस्पॉन्स 1,000 × 52 = 52,000 मान है, जबकि सबसे अच्छी जोड़ियों के जवाब के लिए 8 मान की 5 पंक्तियाँ चाहिए: 5 × 8 = 40।

टूल की परिभाषाएँ और नतीजे हर चरण में संदर्भ में आते हैं: Claude API उन्हें इनपुट टोकन के रूप में गिनता है।

डेटा का समय और ताज़ापन

हैंडलर नतीजे में updated_at, यानी meta.updated_at से डेटा बनने का समय (unix सेकंड में), और age_sec डालता है। तब मॉडल कल का स्प्रेड मौजूदा बताने की जगह कह सकता है: "डेटा 12 सेकंड पुराना है"।

डेटा का ताज़ापन प्लान से तय होता है: meta.freshness_sec Trial में 60 सेकंड से Max में 5 सेकंड तक है। यह अंतराल बीतने से पहले API वही स्नैपशॉट लौटाता है, इसलिए हैंडलर रिस्पॉन्स को freshness_sec सेकंड के लिए कैश करता है। ऑर्डर बुक की अपनी घड़ी है: book_ts, age_sec और 30 सेकंड से पुरानी बुक के लिए stale फ़्लैग।

उदाहरण: get_funding टूल

नीचे की परिभाषा MCP फ़ॉर्मैट में है; Claude API के लिए यही सामग्री input_schema में जाती है। limit हैंडलर खुद लागू करता है: API में ऐसा कोई पैरामीटर नहीं है।

{
  "name": "get_funding",
  "description": "funding कहाँ ज़्यादा या कम है: एक्सचेंजों की सबसे अच्छी जोड़ी",
  "inputSchema": {
    "type": "object",
    "properties": {
      "coin": {
        "type": "string",
        "description": "कॉइन का टिकर, जैसे TON"
      },
      "min_spread": {
        "type": "number",
        "minimum": 0,
        "description": "न्यूनतम स्प्रेड, %: 0.05 का मतलब 0.05% है"
      },
      "limit": {
        "type": "integer",
        "minimum": 1,
        "maximum": 10,
        "description": "कितनी पंक्तियाँ लौटानी हैं, डिफ़ॉल्ट 5"
      }
    },
    "additionalProperties": false
  }
}

Python हैंडलर: freshness_sec के लिए कैश, 429 और 503 पर एक छोटा इंतज़ार, बिना key वाला लॉग और डेटा के समय के साथ संक्षिप्त नतीजा।

import logging
import os
import time

import requests

URL = "https://api.genesisarbitrage.com/v1/funding/spread"
KEY = os.environ["GENESIS_API_KEY"]  # key केवल सर्वर पर रहती है
cache = {}  # रिक्वेस्ट के पैरामीटर -> (प्राप्ति का समय, रिस्पॉन्स बॉडी)


def get_funding(coin=None, min_spread=None, limit=5):
    p = {"coin": coin and coin.upper(), "min_spread": min_spread}
    p = {k: v for k, v in p.items() if v}
    ck = tuple(sorted(p.items()))
    got, body = cache.get(ck, (0, None))
    if not body or time.time() - got >= body["meta"]["freshness_sec"]:
        for attempt in range(2):  # 429, 503: छोटा इंतज़ार, एक दोबारा कोशिश
            r = requests.get(URL, params=p, timeout=10,
                             headers={"X-API-Key": KEY})
            wait = int(r.headers.get("Retry-After", "0"))
            if attempt or wait > 5 or r.status_code not in (429, 503):
                break
            time.sleep(wait)
        logging.info("get_funding %s -> %s id=%s", p, r.status_code,
                     r.headers.get("X-Request-Id"))  # लॉग में key नहीं
        if r.status_code != 200:
            return {"error": r.status_code}  # 401, 403, 429, 503
        body = r.json()
        cache[ck] = (time.time(), body)
    t = body["meta"]["updated_at"]
    top = sorted(body["data"], key=lambda x: -x["spread_pct"])
    rows = [{"coin": x["coin"], "spread_pct": x["spread_pct"],
             "pair": [x["best"]["exchange_1"], x["best"]["exchange_2"]],
             "funding_pct": [x["best"]["funding_1_pct"],
                             x["best"]["funding_2_pct"]],
             "interval": [x["best"]["interval_1"],
                          x["best"]["interval_2"]]}
            for x in top[:min(max(int(limit), 1), 10)]]
    return {"updated_at": t, "age_sec": int(time.time() - t),
            "rows": rows}

हैंडलर 5 सेकंड से लंबे इंतज़ार नहीं करता: कोटा खत्म होने पर Retry-After रीसेट की ओर इशारा करता है, जो कई दिन दूर हो सकता है। मॉडल को स्टेटस कोड मिलता है और वह उपयोगकर्ता को बताता है कि क्या हुआ: 403 का मतलब plan_restricted है, यानी प्लान से बाहर का endpoint (Genesis API की त्रुटियाँ)।

टूल की परिभाषाओं के स्रोत के रूप में OpenAPI

OpenAPI मशीन से पढ़े जाने वाले HTTP API विवरण का मानक है: ऑपरेशन को operationId, छोटे summary और स्कीमा वाले पैरामीटर से बताया जाता है। संस्करण 3.1 में Schema Object, JSON Schema 2020-12 का सुपरसेट है (OpenAPI 3.1 स्पेसिफ़िकेशन), और MCP डिफ़ॉल्ट रूप से inputSchema को JSON Schema 2020-12 मानकर पढ़ता है। इसलिए पैरामीटर बिना रूपांतरण के टूल में चले जाते हैं।

स्क्रिप्ट Genesis API की स्पेसिफ़िकेशन से टूल बनाती है: वह चुने हुए ऑपरेशन लेती है, x-genesis-plans के अनुसार आपके प्लान से बाहर वालों को छोड़ देती है और query व path पैरामीटर ले जाती है। हेडर हैंडलर का काम हैं।

import requests

SPEC = "https://genesisarbitrage.com/openapi.json"


def tools_from_spec(wanted, plan):
    """wanted: operationId -> टूल का नाम; plan: trial … max."""
    spec = requests.get(SPEC, timeout=15).json()
    tools, routes = [], {}
    for path, item in spec["paths"].items():
        op = item.get("get", {})
        name = wanted.get(op.get("operationId"))
        if not name or plan not in op.get("x-genesis-plans", []):
            continue  # ज़रूरत नहीं या प्लान में नहीं: 403 plan_restricted
        props, required = {}, []
        for prm in op.get("parameters", []):
            if "$ref" in prm or prm["in"] not in ("query", "path"):
                continue  # X-API-Key और If-None-Match हैंडलर भेजता है
            props[prm["name"]] = {**prm["schema"],
                                  "description": prm["description"]}
            if prm.get("required"):
                required.append(prm["name"])
        tools.append({
            "name": name,
            "description": op["description"].split("\n\n")[0],
            "inputSchema": {"type": "object", "properties": props,
                            "required": required,
                            "additionalProperties": False}})
        routes[name] = path  # टूल का नाम -> endpoint का पाथ
    return tools, routes


tools, routes = tools_from_spec({"getFundingSpread": "get_funding",
                                 "getArbitrageSpotSpot": "get_spreads"},
                                plan="trial")

getFundingSpread पैरामीटर coin और min_spread वाला get_funding टूल बन जाता है। सारे ऑपरेशन दें तो Trial में 37 में से 11 बचते हैं, Start में 16। routes डिक्शनरी हर टूल का पाथ रखती है।

MCP: REST API के ऊपर अपना सर्वर

MCP (Model Context Protocol) AI ऐप्लिकेशन को डेटा और टूल से जोड़ने का खुला मानक है। Anthropic ने इसे 25 नवंबर 2024 को ओपन-सोर्स किया (Anthropic की घोषणा) और 9 दिसंबर 2025 को Agentic AI Foundation को सौंप दिया, जो Linux Foundation के तहत एक फ़ंड है (MCP ब्लॉग)।

मॉडल वाला ऐप्लिकेशन, यानी होस्ट, हर सर्वर के लिए एक MCP क्लाइंट बनाता है। सर्वर JSON-RPC 2.0 पर टूल, रिसोर्स और प्रॉम्प्ट टेम्पलेट देता है: लोकल सर्वर stdio पर, रिमोट सर्वर Streamable HTTP पर, जिसके लिए MCP टोकन OAuth से लेने की सलाह देता है (MCP आर्किटेक्चर)।

Function callingMCP
टूल कहाँ परिभाषित होते हैंमॉडल API को भेजी रिक्वेस्ट मेंसर्वर पर; क्लाइंट उन्हें tools/list से लेता है
कॉल कौन चलाता हैआपके ऐप्लिकेशन का कोडMCP सर्वर, tools/call रिक्वेस्ट पर
कहाँ काम करता हैउस ऐप में जहाँ आपने लूप लिखाMCP सपोर्ट करने वाले किसी भी क्लाइंट में

REST API को MCP सर्वर में लपेटने के चार चरण हैं:

  1. ऑपरेशन चुनें

    एजेंट के काम के लिए 3–7 ऑपरेशन लें; टूल के नाम, विवरण और पैरामीटर OpenAPI से बनाएँ, जैसे ऊपर की स्क्रिप्ट में।

  2. tools/list पर सूची लौटाएँ

    सर्वर हर टूल का name, description और inputSchema लौटाता है।

  3. tools/call संभालें

    आर्गुमेंट जाँचें, सर्वर के एनवायरनमेंट की key से GET रिक्वेस्ट भेजें और content ब्लॉक में संक्षिप्त JSON लौटाएँ। API की त्रुटि isError: true के साथ लौटाएँ: मॉडल उससे अपने आर्गुमेंट सुधारता है।

  4. ट्रांसपोर्ट चुनें

    stdio पर सर्वर आपकी मशीन पर चलता है और key बाहर नहीं जाती। रिमोट Streamable HTTP सर्वर को ऑथराइज़ेशन के पीछे रखें, वरना जिसे भी URL पता चलेगा वह आपका कोटा खर्च कर देगा।

आधिकारिक MCP SDK 10 भाषाओं के लिए हैं, Python और TypeScript से लेकर Go और Rust तक (SDK की सूची)।

llms.txt और llms-full.txt

llms.txt /llms.txt पर रखी Markdown फ़ाइल है, जो भाषा मॉडल को किसी वेबसाइट का उपयोग करने में मदद करती है। Jeremy Howard ने यह फ़ॉर्मैट 3 सितंबर 2024 को प्रस्तावित किया (llmstxt.org): एकमात्र अनिवार्य हिस्सा नाम वाला H1 है, उसके बाद ब्लॉककोट में सार और पेजों के Markdown संस्करणों के लिंक वाले सेक्शन।

llms-full.txt को प्रस्ताव परिभाषित नहीं करता: यह नाम पूरे डॉक्यूमेंटेशन सेट को एक Markdown फ़ाइल में रखने के लिए इस्तेमाल होता है, और MCP का डॉक्यूमेंटेशन साइट, उदाहरण के लिए, इसे प्रकाशित करती है। मॉडल को लिंक खोलने की ज़रूरत नहीं, क्योंकि पूरा रेफ़रेंस उसके संदर्भ में आ जाता है।

एजेंट की सुरक्षा

key को सर्वर पर एनवायरनमेंट वेरिएबल में रखें: वह प्रॉम्प्ट, ब्राउज़र या लॉग में नहीं दिखनी चाहिए। Genesis API की key केवल पढ़ने वाली है, इसलिए वह ऑर्डर नहीं लगा सकती और फ़ंड नहीं निकाल सकती, और लीक होने पर आपका कोटा खर्च होता है। लीक हुई key को अपनी प्रोफ़ाइल में फिर से जारी करें से बदलें (key सँभालना)।

प्रॉम्प्ट इंजेक्शन (prompt injection) डेटा में छिपा मॉडल के लिए निर्देश है। टोकन का नाम वह तय करता है जिसने उसे डिप्लॉय किया, और ट्रेडर का नाम ट्रेडर खुद, इसलिए किसी फ़ील्ड में "पिछले निर्देश अनदेखे करो" लिखा हो सकता है। Genesis API में बाहरी टेक्स्ट प्रेडिक्शन मार्केट के title और outcome फ़ील्ड, ट्रेडर के name, ऑन-चेन के token_name और Genesis AI+ सिग्नल के message_ru व message_en में आता है: सिस्टम प्रॉम्प्ट में लिखें कि टूल के नतीजे केवल डेटा हैं।

MCP स्पेसिफ़िकेशन सर्वर से टूल के इनपुट जाँचने, कॉल की दर सीमित करने और आउटपुट साफ़ करने की माँग करती है, और क्लाइंट को संवेदनशील ऑपरेशन की पुष्टि करने और टूल के उपयोग का लॉग रखने की सलाह देती है (MCP टूल)। X-Request-Id लॉग करें: उसके, UTC में समय, endpoint और स्टेटस के साथ सपोर्ट रिक्वेस्ट ढूँढ सकता है।

ऑटोमेशन के जोखिम Crypto API कोर्स के पाठ 5 में हैं।

लागत और लिमिट

केवल 200 रिस्पॉन्स Genesis API का कोटा खर्च करता है; 304 और त्रुटियाँ मुफ़्त हैं, पर प्रति सेकंड rate limit में गिनी जाती हैं। लिमिट पार होने पर सर्वर 429 देता है और कुछ नहीं काटता।

प्लानकीमतकोटा और दरताज़ापन
Trial$20/माह500,000 कॉल, 1 req/s60 s
Start$50/माह2M कॉल, 2 req/s30 s
Pro$100/माह5M कॉल, 5 req/s10 s
Max$200/माह10M कॉल, 15 req/s5 s

उदाहरण (समझाने के लिए): रोज़ 500 सवाल, हर एक पर 3 टूल कॉल, यानी 500 × 3 = रोज़ 1,500 कॉल और 30 दिन में 1,500 × 30 = 45,000, जो Trial के कोटा का 9% है। कैश freshness_sec के भीतर उन्हीं पैरामीटर वाले दोहराव को सँभालता है, और हर जवाब पर टूल कॉल की सीमा लूप को कोटा खाने से रोकती है।

meta.freshness_sec से ज़्यादा बार पोल करने पर नया स्नैपशॉट नहीं मिलता। ETag और रीट्राई के साथ सस्ती पोलिंग लिमिट में रहकर Crypto API को कैसे पोल करें में है, और लिमिट Genesis API की लिमिट गाइड में। अगर एजेंट को केवल नियम चाहिए और मॉडल नहीं, तो Python में Crypto Arbitrage Bot ज़्यादा सरल है।

AI एजेंट के लिए Genesis API

Genesis API, Genesis Arbitrage के डेटा वाला REST API है: CEX और DEX स्प्रेड, order book, funding, open interest, क्रॉस-चेन, ऑन-चेन प्रवाह, प्रेडिक्शन मार्केट, स्पोर्ट्सबुक surebet और AI सिग्नल। रिक्वेस्ट X-API-Key हेडर के साथ HTTP GET हैं, रिस्पॉन्स data और meta वाला JSON (रिस्पॉन्स फ़ॉर्मेट), और SDK की ज़रूरत नहीं।

एजेंट के लिए प्रकाशित:

कोई आधिकारिक MCP सर्वर, WebSocket और ट्रेडिंग endpoint नहीं हैं: एजेंट डेटा पढ़ता है, और ट्रेड इंसान के पास रहते हैं। चरण-दर-चरण सेटअप AI एजेंट के लिए Genesis API गाइड में है।

सवाल और जवाब

क्या AI एजेंट अपने आप क्रिप्टो ट्रेड कर सकता है?

केवल तब, जब आप उसे एक्सचेंज का ट्रेडिंग API दें, और वह आपका कोड और आपका जोखिम है। Genesis API से नहीं: वह केवल डेटा पढ़ता है। MCP स्पेसिफ़िकेशन कहती है कि इंसान को हमेशा टूल कॉल अस्वीकार करने का मौका मिलना चाहिए; ट्रेड के लिए नियम बनाएँ कि हर ऑर्डर की पुष्टि इंसान करे।

AI एजेंट को Genesis API का कौन-सा प्लान चाहिए?

$20 प्रति माह का Trial CEX स्प्रेड, funding और open interest कवर करता है। Start स्टॉक, ऑन-चेन सेक्शन और exact व dutch मोड में प्रेडिक्शन आर्बिट्राज जोड़ता है, जबकि Pro और Max सब कुछ खोलते हैं, DEX और order book समेत। प्रतिक्रिया की गति प्रति सेकंड की लिमिट और प्लान के ताज़ापन पर निर्भर है; प्लान में क्या है, यह Genesis API की कीमतें पेज पर है।

एजेंट के लिए Genesis API की स्पेसिफ़िकेशन कहाँ से लें?

OpenAPI 3.1 genesisarbitrage.com/openapi.json पर है, और मॉडल के लिए रेफ़रेंस genesisarbitrage.com/llms-full.txt पर। एजेंट दोनों को /.well-known/api-catalog कैटलॉग से भी पा सकता है।

क्या Genesis API का MCP सर्वर है?

आधिकारिक नहीं है। आप उन्हीं हैंडलर से अपना बनाते हैं: MCP टूल सर्वर के एनवायरनमेंट की key के साथ endpoint पर GET रिक्वेस्ट है। न्यूनतम Python उदाहरण शब्दावली की MCP प्रविष्टि में है।