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, వాక్యం నిజమయ్యే సంభావ్యత.

nodes.triage.urgency.score >= 1.5 వంటి condition‌తో జవాబుపై రూట్ చేయండి. ఏ నిర్ణయం తీసుకోలేనప్పుడు ప్రతి ప్రశ్నకు సురక్షితమైన జవాబును params.default ఇస్తుంది; డిఫాల్ట్ జవాబుకు confidence 0. డిఫాల్ట్ లేని ప్రశ్నకు జవాబు ఉండదు, కాబట్టి దానిపై ఉన్న conditionలు తమ False అంచును తీసుకుంటాయి.

ఎర్రర్‌లు

విఫలమైన కార్యకలాపాన్ని ఎన్నిసార్లు మళ్లీ ప్రయత్నించాలో on_error.retry సెట్ చేస్తుంది; డిఫాల్ట్ 1. చివరి ప్రయత్నం తర్వాత రన్ ముగుస్తుంది, డిఫాల్ట్ fallback అయిన notify_ownerతో యజమానికి తెలియజేయబడుతుంది. రన్ ప్రారంభమైనప్పుడు Nebo ప్రతి టైప్డ్ కార్యకలాపం తప్పనిసరి పారామీటర్‌లను తనిఖీ చేస్తుంది, తెలియని కార్యకలాపాన్ని సూచించే శాఖను తిరస్కరిస్తుంది.