सीधे सामग्री पर जाएँ

फ़ंक्शन कॉलिंग

LLM को 299 एंडपॉइंट, 299 टूल बनाकर दे देना सबसे सीधा तरीक़ा लगता है, पर यह गलत है। यहाँ वह ढाँचा है जो काम करता है, और वे चार विफलताएँ जिनसे बचने की तैयारी पहले से करनी चाहिए।

299 टूल न बनाएँ

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

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

एक टूल वाला ढाँचा

टूल की परिभाषा
{
  "name": "occult_api",
  "description":
    "Vedic astrology calculations from the Occult API. Call this for anything involving a birth chart, panchanga, dasha, muhurta, matching or numerology. Do not compute astrology yourself - planetary positions require an ephemeris and cannot be derived from a date.",
  "input_schema": {
    "type": "object",
    "properties": {
      "route": {
        "type": "string",
        "description": "Endpoint path, e.g. /api/astro/panchanga/. Use the catalogue at https://occultapi.com/llms.txt to choose one."
      },
      "body": {
        "type": "object",
        "description": "Request body. Always include date_time (ISO 8601 with offset), latitude, longitude, timezone_as_float. Batch calculations with a keys array where the endpoint supports it."
      }
    },
    "required": ["route", "body"]
  }
}

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

हैंडलर

node
async function occultApi({ route, body }) {
  const response = await fetch(`${process.env.OCCULT_API_BASE}${route}`, {
    method: "POST",
    headers: {
      "X-API-Key": process.env.OCCULT_API_KEY,   // server-side only
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });

  const payload = await response.json();

  // 402 means out of credits. It is NOT transient - retrying spends nothing
  // and fixes nothing, so surface it rather than backing off.
  if (response.status === 402) {
    return { error: "insufficient_credits", retryable: false };
  }

  // The envelope is the same on every endpoint: branch on is_error, and hand
  // the model the message rather than a stack trace it cannot act on.
  if (payload.is_error) {
    return { error: payload.message, retryable: false };
  }

  return payload.data;
}

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

दो टूल वाला ढाँचा, जब मॉडल को खोजबीन करनी हो

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

टूल की परिभाषाएँ
[
  {
    "name": "occult_search",
    "description": "Find the right Occult API endpoint by name or by what it calculates, e.g. 'manglik' or 'sunrise'. Returns routes and their request fields. Costs nothing.",
    "input_schema": {
      "type": "object",
      "properties": { "query": { "type": "string" } },
      "required": ["query"]
    }
  },
  {
    "name": "occult_call",
    "description": "Call an Occult API endpoint found with occult_search. One credit per successful call (the PDF reports and chat cost 25); failures are free.",
    "input_schema": {
      "type": "object",
      "properties": {
        "route": { "type": "string" },
        "body": { "type": "object" }
      },
      "required": ["route", "body"]
    }
  }
]

occult_search को /llms.txt या ज़्यादा विस्तार वाली /llms-full.txt से जोड़ें — दोनों इसी काम के लिए बनी हैं। अगर आपका फ़्रेमवर्क स्पेक से टूल बनाता है, तो OpenAPI 3.1 स्पेक भी है।

चार विफलताएँ, जिनसे पहले से बचना चाहिए

  • हर गणना के लिए एक कॉल। ज़्यादातर एंडपॉइंट keys सूची लेते हैं और एक ही अनुरोध में, एक क्रेडिट में, कई चीज़ें गणना कर देते हैं। अपने भरोसे छोड़ा गया मॉडल चार बार कॉल करेगा और चार क्रेडिट ख़र्च करेगा। टूल के विवरण में यह साफ़ लिख दें।
  • 402 पर दोबारा कोशिश। यह बैलेंस की समस्या है, नेटवर्क की नहीं। हैंडलर में इसे दोबारा न भेजने लायक चिह्नित करें, क्योंकि सिर्फ़ स्टेटस कोड देखकर मॉडल यह फ़र्क़ नहीं समझ सकता।
  • कुंजी का क्लाइंट तक पहुँच जाना। टूल आपके सर्वर पर चलने चाहिए। मॉडल को कुंजी देखने की कभी ज़रूरत नहीं होती, और जिस ढाँचे में वह उसे देख सके, वहाँ एक प्रॉम्प्ट इंजेक्शन से ही कुंजी लीक हो सकती है।
  • गढ़े हुए फ़ील्ड नाम। मॉडल date या lat का अंदाज़ा लगाते हैं। असली फ़ील्ड date_time, latitude, longitude और timezone_as_float हैं। इन्हें विवरण में ही लिख दें, ताकि मॉडल को 400 खाकर न सीखना पड़े।

असली कॉल कैसी दिखती है

curl
curl -X POST https://api.occultapi.com/api/astro/panchanga/ \
  -H 'X-API-Key: yt_live_your_key_here' \
  -H 'Content-Type: application/json' \
  -d '{
    "date_time": "2026-09-17T06:00:00+05:30",
    "latitude": 26.9124,
    "longitude": 75.7873,
    "timezone_as_float": 5.5,
    "keys": ["tithi", "nakshatra_segments", "yogam", "karana"]
  }'

चार गणनाएँ, एक क्रेडिट। उत्तर में X-Credits-Charged और X-Credits-Remaining होते हैं — अपने UI में चलता हुआ ख़र्च दिखाने का यही सबसे सस्ता तरीक़ा है।

आगे