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, ഇരുവശവും സംഖ്യകളാണെങ്കിൽ സംഖ്യകളായി താരതമ്യം ചെയ്യുന്നു; അല്ലെങ്കിൽ ഒരു വെറും പാത്ത്, അതിന്റെ മൂല്യം truthy ആകുമ്പോൾ true.
existsഒരു പാത്ത്; അത് ഒരു truthy മൂല്യത്തിലേക്ക് എത്തുമ്പോൾ true.
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.
scoreക്രമീകരിച്ച 2 മുതൽ 10 വരെ തലങ്ങളുടെ ലിസ്റ്റ്.0 (ആദ്യ തലം) മുതൽ മുകളിലേക്കുള്ള score, ഒപ്പം confidence.
noulഒന്നുമില്ല.noul, പ്രസ്താവന ശരിയാകാനുള്ള സാധ്യത.

nodes.triage.urgency.score >= 1.5 പോലുള്ള ഒരു condition ഉപയോഗിച്ച് ഒരു ഉത്തരത്തിൽ റൂട്ട് ചെയ്യുക. ഒരു തീരുമാനവും എടുക്കാൻ കഴിയാത്തപ്പോൾ ഓരോ ചോദ്യത്തിനുമുള്ള സുരക്ഷിതമായ ഉത്തരം params.default നൽകുന്നു; ഡിഫോൾട്ട് ഉത്തരത്തിന് confidence 0 ആണ്. ഡിഫോൾട്ട് ഇല്ലാത്ത ചോദ്യത്തിന് ഉത്തരം ലഭിക്കില്ല, അതിനാൽ അതിലെ condition-കൾ അവയുടെ False എഡ്ജ് സ്വീകരിക്കുന്നു.

പിശകുകൾ

പരാജയപ്പെട്ട ഒരു പ്രവർത്തനം എത്ര തവണ വീണ്ടും ശ്രമിക്കണമെന്ന് on_error.retry സജ്ജമാക്കുന്നു; ഡിഫോൾട്ട് 1 ആണ്. അവസാന ശ്രമത്തിനുശേഷം റൺ അവസാനിക്കുന്നു, notify_owner എന്ന ഡിഫോൾട്ട് fallback ഉള്ളപ്പോൾ ഉടമയെ അറിയിക്കുന്നു. റൺ ആരംഭിക്കുമ്പോൾ Nebo ഓരോ ടൈപ്പ് ചെയ്ത പ്രവർത്തനത്തിന്റെയും നിർബന്ധിത പാരാമീറ്ററുകൾ പരിശോധിക്കുന്നു, അജ്ഞാതമായ ഒരു പ്രവർത്തനത്തിലേക്ക് ചൂണ്ടുന്ന ശാഖ നിരസിക്കുന്നു.