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 હોય ત્યારે સાચું.
existsએક પાથ; તે 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 હોય છે. ડિફૉલ્ટ વગરના પ્રશ્નને કોઈ જવાબ મળતો નથી, તેથી તેના પરની conditions પોતાની False એજ લે છે.

ભૂલો

on_error.retry નિષ્ફળ પ્રવૃત્તિનો કેટલી વાર ફરી પ્રયાસ કરવો તે નક્કી કરે છે; ડિફૉલ્ટ 1 છે. છેલ્લા પ્રયાસ પછી રન પૂરો થાય છે, અને notify_ownerના ડિફૉલ્ટ fallback સાથે માલિકને જાણ કરાય છે. રન શરૂ થાય ત્યારે Nebo દરેક ટાઇપ કરેલી પ્રવૃત્તિના જરૂરી પેરામીટર્સ તપાસે છે, અને અજાણી પ્રવૃત્તિ તરફ દોરતી શાખાને નકારે છે.