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 ನಲ್ಲಿನ ಅವಧಿಗೆ ವಿರಾಮ ನೀಡುತ್ತದೆ. wait-until ಇಲ್ಲ; ಈವೆಂಟ್ ಬಂದಾಗ ಮುಂದುವರಿಸಲು, ಅದರ ಮೇಲೆ ಎರಡನೇ ವರ್ಕ್‌ಫ್ಲೋವನ್ನು ಟ್ರಿಗರ್ ಮಾಡಿ.
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. ಡೀಫಾಲ್ಟ್ ಇಲ್ಲದ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ಸಿಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದರ ಮೇಲಿನ conditions ತಮ್ಮ False ಅಂಚನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ.

ದೋಷಗಳು

ವಿಫಲವಾದ ಚಟುವಟಿಕೆಯನ್ನು ಎಷ್ಟು ಬಾರಿ ಮರುಪ್ರಯತ್ನಿಸಬೇಕು ಎಂದು on_error.retry ಹೊಂದಿಸುತ್ತದೆ; ಡೀಫಾಲ್ಟ್ 1. ಕೊನೆಯ ಮರುಪ್ರಯತ್ನದ ನಂತರ ರನ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಡೀಫಾಲ್ಟ್ fallback ಆದ notify_owner ಇದ್ದರೆ ಮಾಲೀಕರಿಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ. ರನ್ ಪ್ರಾರಂಭವಾದಾಗ Nebo ಪ್ರತಿ ಟೈಪ್ ಮಾಡಿದ ಚಟುವಟಿಕೆಯ ಅಗತ್ಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಅಜ್ಞಾತ ಚಟುವಟಿಕೆಗೆ ತೋರಿಸುವ ಶಾಖೆಯನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ.