ഫീൽഡുകൾ
{
"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-ലും ഡാറ്റ പാത്തുകളിലും ഉപയോഗിക്കുന്നു. |
type | custom | ഒരു ജീവനക്കാരന്റെ ഘട്ടം, അല്ലെങ്കിൽ 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. |
contains | path 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" } } | തരം | നിർബന്ധം | പെരുമാറ്റം |
|---|---|---|
wait | params.duration | s, m അല്ലെങ്കിൽ h-ലുള്ള ഒരു കാലയളവ് താൽക്കാലികമായി നിർത്തുന്നു. ഒരു നിശ്ചിത സമയം വരെ കാത്തിരിക്കാനുള്ള സംവിധാനമില്ല; ഒരു ഇവന്റിൽ പുനരാരംഭിക്കാൻ, അതിൽ രണ്ടാമതൊരു വർക്ക്ഫ്ലോ ട്രിഗർ ചെയ്യുക. |
http | params.url | അഭ്യർത്ഥന നടത്തുന്നു. method, headers, body എന്നിവ ഓപ്ഷണലാണ്. |
command | params.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 ഓരോ ടൈപ്പ് ചെയ്ത പ്രവർത്തനത്തിന്റെയും നിർബന്ധിത പാരാമീറ്ററുകൾ പരിശോധിക്കുന്നു, അജ്ഞാതമായ ഒരു പ്രവർത്തനത്തിലേക്ക് ചൂണ്ടുന്ന ശാഖ നിരസിക്കുന്നു.