NeboAI
NeboAI
शुरू करें

गतिविधियाँ

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

फ़ील्ड

{
  "id": "draft-reply",
  "label": "Draft the reply",
  "intent": "Draft a reply to the customer message in _watch_payload using the reply-drafting skill.",
  "skills": ["reply-drafting"],
  "requires_tools": ["mail_message_send"],
  "on_error": { "retry": 1, "fallback": "notify_owner" }
}
फ़ील्डडिफ़ॉल्टअर्थ
idज़रूरीवर्कफ़्लो के अंदर अद्वितीय। connections और डेटा पाथ में इस्तेमाल होता है।
typecustomकर्मचारी चरण, या इनमें से एक: condition, loop, wait, http, command, decide।
intentकोई नहींकर्मचारी को क्या हासिल करना चाहिए। कर्मचारी चरण के लिए intent या steps ज़रूरी है।
steps[]क्रमबद्ध निर्देश, जब एक वाक्य काफ़ी न हो।
labelकोई नहींमालिक को दिखाया जाने वाला नाम।
skills[]इस्तेमाल करने वाली स्किल। यहाँ सूचीबद्ध मार्केटप्लेस स्किल कर्मचारी के साथ इंस्टॉल होती हैं।
tools[]सेट होने पर, केवल यही टूल चरण इस्तेमाल कर सकता है।
requires_tools[]वे टूल जिनका सफल होना ज़रूरी है ताकि चरण पूरा माना जाए।
cmds[]चरण के लिए नामित प्लगइन कमांड।
mcps[]चरण के लिए नामित MCP सर्वर।
modelकोई नहींइस चरण के लिए एक मॉडल id।
paramsकोई नहींटाइप की गई गतिविधियों के पैरामीटर, और कर्मचारी चरणों के लिए maxIterations।
min_iterationsकोई नहींचरण खत्म होने से पहले कम से कम इतने मॉडल टर्न।
token_budgetकोई नहीं{max}। एक अनुमान।
on_error{retry: 1, fallback: notify_owner}दोबारा कोशिशें, फिर फ़ॉलबैक। दोबारा कोशिशों के बाद कोई भी विफलता रन खत्म कर देती है।

कर्मचारी चरण

कर्मचारी चरण कर्मचारी के एक टर्न के रूप में चलता है: उसकी पर्सोना, मेमोरी और कनेक्शन लागू होते हैं, और यह अधिकतम 50 मॉडल टर्न, या params.maxIterations, इस्तेमाल कर सकता है। पहले के चरणों के नतीजे [Activity 'id' result] ब्लॉक के रूप में दिए जाते हैं। जो चरण emit सूची के साथ वर्कफ़्लो खत्म करता है, उसे उन इवेंट के साथ emit_event कॉल करने को कहा जाता है। रन खत्म करने के लिए exit टूल हमेशा उपलब्ध रहता है।

डेटा कॉन्टेक्स्ट

टाइप की गई गतिविधियाँ एक ही ऑब्जेक्ट से डॉट वाले पाथ के ज़रिए मान पढ़ती हैं: inputs में रन के इनपुट होते हैं, nodes.<id> में हर पूरी हुई गतिविधि का आउटपुट (JSON होने पर JSON के रूप में पार्स किया हुआ), और item में लूप के अंदर मौजूदा आइटम। सादा पाथ पहले inputs में, फिर nodes में देखता है।

condition

{ "id": "large", "type": "condition", "params": { "expression": "inputs.amount >= 500" } }

params.expression ज़रूरी है। इसके बाहर जाने वाले कनेक्शन True और False लेबल वाले होते हैं। params.mode तय करता है कि इसे कैसे पढ़ा जाए:

मोडएक्सप्रेशन
expressionडिफ़ॉल्ट। ==, !=, >=, <=, > या < के साथ path op value, दोनों तरफ़ संख्याएँ होने पर संख्याओं के रूप में तुलना; या सादा पाथ, तब true जब उसका मान truthy हो।
existsएक पाथ; तब true जब वह किसी truthy मान पर पहुँचे।
containspath contains text, या पिछले आउटपुट से मिलाया जाने वाला सादा टेक्स्ट।
regexपिछले आउटपुट से मिलाया जाने वाला पैटर्न।

loop

{ "id": "each-invoice", "type": "loop", "params": { "source": "nodes.fetch.invoices", "concurrency": 4 } }

params.source किसी सूची का पाथ है। Each item लेबल वाला कनेक्शन बॉडी तक ले जाता है, जो item सेट करके हर आइटम के लिए एक बार चलती है; Done लेबल वाला सभी आइटम के बाद चलता है। जब तक आप concurrency सेट न करें, सभी दोहराव एक साथ शुरू होते हैं। maxIterations और batchSize भी स्वीकार किए जाते हैं।

"connections": [
  { "from": "__trigger__", "to": "fetch" },
  { "from": "fetch", "to": "each-invoice" },
  { "from": "each-invoice", "to": "check", "label": "Each item" },
  { "from": "each-invoice", "to": "report", "label": "Done" }
]

wait, http और command

{ "id": "pause", "type": "wait", "params": { "duration": "5m" } }
{ "id": "status", "type": "http", "params": { "url": "https://status.example.com/api", "method": "GET" } }
{ "id": "export", "type": "command", "params": { "command": "date -u" } }
प्रकारज़रूरीव्यवहार
waitparams.durations, m या h में दी गई अवधि के लिए रुकता है। किसी तय समय तक रुकने का विकल्प नहीं है; किसी इवेंट पर फिर से शुरू करने के लिए उस पर दूसरा वर्कफ़्लो ट्रिगर करें।
httpparams.urlअनुरोध भेजता है। method, headers और body वैकल्पिक हैं।
commandparams.commandएक शेल कमांड चलाता है। उसका stdout गतिविधि का आउटपुट होता है।

decide

decide गतिविधि अब तक के काम के बारे में टाइप किए गए सवाल पूछती है और ऐसे संरचित जवाब दर्ज करती है जिनके आधार पर condition रूट कर सके।

{
  "id": "triage",
  "type": "decide",
  "params": {
    "questions": {
      "urgency": { "type": "score", "instructions": "How urgent is this request?", "criteria": ["low", "normal", "high"] },
      "refund": { "type": "noul", "instructions": "The customer is asking for money back." }
    },
    "default": { "urgency": "normal", "refund": false }
  }
}
सवाल का प्रकारcriteriaजवाब
choiceविकल्प से विवरण का ऑब्जेक्ट, 2 से 255 विकल्प।choice, confidence और probabilities।
score2 से 10 क्रमबद्ध स्तरों की सूची।0 (पहला स्तर) से ऊपर score, और confidence।
noulकोई नहीं।noul, इस बात की संभावना कि कथन सही है।

किसी जवाब पर condition से रूट करें, जैसे nodes.triage.urgency.score >= 1.5। जब कोई फ़ैसला न हो सके, तो params.default हर सवाल का सुरक्षित जवाब देता है; डिफ़ॉल्ट से दिए गए जवाब का confidence 0 होता है। बिना डिफ़ॉल्ट वाले सवाल को कोई जवाब नहीं मिलता, इसलिए उस पर आधारित condition अपना False एज लेती हैं।

त्रुटियाँ

on_error.retry तय करता है कि विफल गतिविधि कितनी बार दोबारा चलाई जाए; डिफ़ॉल्ट 1 है। आख़िरी कोशिश के बाद रन खत्म हो जाता है, और notify_owner के डिफ़ॉल्ट fallback से मालिक को बताया जाता है। रन शुरू होने पर Nebo हर टाइप की गई गतिविधि के ज़रूरी पैरामीटर जाँचता है, और किसी अज्ञात गतिविधि की ओर इशारा करने वाली शाखा को अस्वीकार करता है।