NeboAI
NeboAI
ആരംഭിക്കൂ

വർക്ക്ഫ്ലോകൾ

ആവശ്യപ്പെടാതെ തന്നെ ഒരു ജീവനക്കാരൻ ചെയ്യുന്ന ജോലിയാണ് വർക്ക്ഫ്ലോ: ഒരു പ്രഭാത സംഗ്രഹം, ഓരോ പുതിയ സന്ദേശത്തിനും ഒരു മറുപടി, ഒരു പ്രതിവാര റിപ്പോർട്ട്. ഓരോ വർക്ക്ഫ്ലോയും ഒരു ട്രിഗറിനെ ജീവനക്കാരൻ നിർവഹിക്കുന്ന പ്രവർത്തനങ്ങളുമായി ജോടിയാക്കുന്നു. വർക്ക്ഫ്ലോകൾ ജീവനക്കാരന്റെ agent.json-ലാണ്, അതിനാൽ അവ റോളിനൊപ്പം സഞ്ചരിക്കുന്നു.

ആദ്യ വർക്ക്ഫ്ലോ

agent.json-ലേക്ക് ഒരു workflows മാപ്പ് ചേർക്കുക. ഓരോ കീയും ഒരു വർക്ക്ഫ്ലോയ്ക്ക് പേര് നൽകുന്നു; ഓരോ മൂല്യത്തിനും ഒരു ട്രിഗറും പ്രവർത്തനങ്ങളും ഉണ്ട്.

{
  "workflows": {
    "morning-summary": {
      "trigger": { "type": "schedule", "cron": "0 8 * * 1-5" },
      "description": "Summarize yesterday's open conversations every weekday morning.",
      "activities": [
        { "id": "summarize", "intent": "Summarize yesterday's open customer conversations and what each one is waiting on." }
      ]
    }
  }
}

ഈ വർക്ക്ഫ്ലോ പ്രവൃത്തിദിവസങ്ങളിൽ ബോട്ടിന്റെ പ്രാദേശിക സമയം 08:00-ന് പ്രവർത്തിക്കുന്നു. ജീവനക്കാരൻ സ്വന്തം വ്യക്തിത്വം, സ്കില്ലുകൾ, കണക്ഷനുകൾ എന്നിവ ഉപയോഗിച്ച് പ്രവർത്തനം നിർവഹിക്കുന്നു.

വർക്ക്ഫ്ലോ ഫീൽഡുകൾ

ഫീൽഡ്അർത്ഥം
triggerനിർബന്ധം. വർക്ക്ഫ്ലോ എപ്പോൾ പ്രവർത്തിക്കുന്നു. Triggers കാണുക.
descriptionവർക്ക്ഫ്ലോ എന്തിനുള്ളതാണ്.
activitiesഘട്ടങ്ങൾ. Activities കാണുക.
connectionsപ്രവർത്തനങ്ങളെ ഒരു ഗ്രാഫാക്കുന്ന {from, to, label} എഡ്ജുകൾ. __trigger__ തുടക്കവും __emit__ ഒടുക്കവുമാണ്.
emitഈ വർക്ക്ഫ്ലോ പൂർത്തിയാകുമ്പോൾ പ്രഖ്യാപിക്കുന്ന ഇവന്റുകൾ: ഒരു ലിസ്റ്റ്, അല്ലെങ്കിൽ കോമ കൊണ്ട് വേർതിരിച്ച ഒരു സ്ട്രിംഗ്. Events കാണുക.
inputsഓരോ റണ്ണിലേക്കും കൈമാറുന്ന മൂല്യങ്ങൾ.
budget{total_per_run, cost_estimate}. ഒരു ഗ്രാഫ് റണ്ണിൽ, total_per_run ഔട്ട്പുട്ട് ടോക്കണുകൾക്ക് പരിധി വയ്ക്കുന്നു; അല്ലാത്തപ്പോൾ രണ്ടും ഏകദേശ കണക്കുകളാണ്.
caseവർക്ക്ഫ്ലോയെ ഓരോ വ്യക്തിക്കും വസ്തുവിനും ദീർഘനേരം നീളുന്ന ഒരു കേസാക്കി മാറ്റുന്നു. Cases കാണുക.

ഒരു ട്രിഗറുള്ളതും പ്രവർത്തനങ്ങളില്ലാത്തതുമായ വർക്ക്ഫ്ലോ സാധുവാണ്. പ്രവർത്തനങ്ങളില്ലാത്ത ഒരു watch അതിന്റെ ഇവന്റുകൾ മറ്റ് വർക്ക്ഫ്ലോകളിലേക്ക് കൈമാറുക മാത്രം ചെയ്യുന്നു.

ഒരു റൺ എങ്ങനെ നടക്കുന്നു

connections ഇല്ലാതെ, പ്രവർത്തനങ്ങൾ ക്രമത്തിൽ നടക്കുന്നു, ഓരോന്നും ജീവനക്കാരൻ നിർവഹിക്കുന്നു. ഓരോ പ്രവർത്തനത്തിന്റെയും ഫലം അടുത്തതിലേക്ക് കൈമാറുന്നു. ഔട്ട്പുട്ട് ഇല്ലാത്ത ഒരു പ്രവർത്തനം റൺ അവസാനിപ്പിക്കുന്നു.

connections ഉള്ളപ്പോൾ, പ്രവർത്തനങ്ങൾ ഒരു ഗ്രാഫ് രൂപപ്പെടുത്തുന്നു. ശാഖകൾ സമാന്തരമായി പ്രവർത്തിക്കുന്നു, ആറ് തരം പ്രവർത്തനങ്ങൾ മോഡലില്ലാതെ പ്രവർത്തിക്കുന്നു: condition, loop, wait, http, command, decide. റൂട്ടിംഗ് കൃത്യമായിരിക്കണമെങ്കിൽ ഒരു ഗ്രാഫ് ഉപയോഗിക്കുക.

{
  "trigger": { "type": "watch", "plugin": "mail", "event": "email.new" },
  "activities": [
    { "id": "classify", "type": "decide",
      "params": {
        "questions": {
          "kind": {
            "type": "choice",
            "instructions": "What kind of message is this?",
            "criteria": { "invoice": "A bill from a vendor", "other": "Anything else" }
          }
        },
        "default": { "kind": "other" }
      } },
    { "id": "is-invoice", "type": "condition", "params": { "expression": "nodes.classify.kind.choice == invoice" } },
    { "id": "record", "intent": "Record the invoice in _watch_payload as a bill and note the due date." }
  ],
  "connections": [
    { "from": "__trigger__", "to": "classify" },
    { "from": "classify", "to": "is-invoice" },
    { "from": "is-invoice", "to": "record", "label": "True" },
    { "from": "record", "to": "__emit__" }
  ],
  "emit": ["invoice.recorded"]
}

ഒരു റണ്ണിന് എന്ത് ലഭിക്കുന്നു

ജീവനക്കാരന് എപ്പോഴും അതിന്റെ വ്യക്തിത്വവും അതിന്റെ inputs ചോദ്യങ്ങൾക്കുള്ള ഉടമയുടെ ഉത്തരങ്ങളും ഉണ്ട്. ഒരു റണ്ണിന് അതിന്റെ ട്രിഗർ അനുസരിച്ച് ഈ മൂല്യങ്ങളും ലഭിക്കുന്നു.

ഇൻപുട്ട്എപ്പോൾ ഉണ്ടാകും
_event_source, _event_payload, _event_originഒരു event ട്രിഗർ പ്രവർത്തിച്ചു. 8 KB-യോ അതിൽ കൂടുതലോ ഉള്ള പേലോഡുകൾ അവയുടെ സ്കെയിലർ ഫീൽഡുകളിലേക്ക് ചുരുക്കുന്നു, ഇമെയിൽ ഹെഡറുകളും അറ്റാച്ച്മെന്റ് റഫറൻസുകളും നിലനിർത്തുന്നു.
_watch_payloadഒരു watch അല്ലെങ്കിൽ folder ട്രിഗർ പ്രവർത്തിച്ചു. വാച്ചറിന്റെ ഔട്ട്പുട്ടിലെ ഒരു വരി, അല്ലെങ്കിൽ ഒരു ഫോൾഡറിന് {files}.
inputsഎപ്പോഴും. വർക്ക്ഫ്ലോയുടെ സ്വന്തം inputs മൂല്യങ്ങൾ.

കേസുകൾ

ചില ജോലികൾ ദിവസങ്ങളോളം നീളും: ഫോളോ-അപ്പുകൾ ആവശ്യമുള്ള ഒരു ലീഡ്, ഡോക്യുമെന്റുകൾക്കായി കാത്തിരിക്കുന്ന ഒരു അഭ്യർത്ഥന. case ചേർത്താൽ, ഓരോ തവണയും പുതുതായി തുടങ്ങുന്നതിന് പകരം വർക്ക്ഫ്ലോ ഓരോ വ്യക്തിക്കും വസ്തുവിനും ഒരു തുറന്ന കേസ് സൂക്ഷിക്കുന്നു.

ഫീൽഡ്അർത്ഥം
keyനിർബന്ധം. വിഷയത്തെ തിരിച്ചറിയുന്ന, ട്രിഗർ ഡാറ്റയിലേക്കുള്ള കോമ കൊണ്ട് വേർതിരിച്ച ഡോട്ട് പാത്തുകൾ, ഉദാഹരണത്തിന് contactEmail,email,phone.
typeകേസിന്റെ തരം, ഉദാഹരണത്തിന് lead. ഒരേ തരമുള്ള വർക്ക്ഫ്ലോകൾ കേസുകൾ പങ്കിടുന്നു. ഡിഫോൾട്ടായി വർക്ക്ഫ്ലോയുടെ പേര്.
default_waitഒരു ടേൺ കാത്തിരിപ്പ് പറയാത്തപ്പോൾ എത്ര നേരം കാത്തിരിക്കണം: 3d, 12h, 45m. ഡിഫോൾട്ട് മൂന്ന് ദിവസം.

ഒരു കേസിന്റെ ഓരോ ടേണും ഒരു JSON ഒബ്ജക്റ്റിൽ അവസാനിക്കണം, അതിനുശേഷം ഒന്നും പാടില്ല. result ബിസിനസ് നിലയാണ്; next എഞ്ചിനോട് wait ചെയ്യാനോ close ചെയ്യാനോ പറയുന്നു. ഒരു സമയപരിധി RFC 3339 അല്ലെങ്കിൽ ഒരു ആപേക്ഷിക കാലയളവാണ്. മറ്റെന്തും അസാധുവായ ടേണാണ്.

{"result": {"status": "awaiting_documents", "summary": "Requested two bank statements"},
 "next":   {"action": "wait", "on": "signal", "deadline": "3d", "reason": "documents"}}

പരിധികളും വീണ്ടെടുക്കലും

  • params.maxIterations മറ്റൊന്ന് പറയുന്നില്ലെങ്കിൽ, ഓരോ പ്രവർത്തനത്തിനും 50 മോഡൽ ടേണുകൾ വരെ എടുക്കാം.
  • ഒരു ഗ്രാഫിൽ, ഒരു റണ്ണിൽ ഒരു പ്രവർത്തനം പരമാവധി 10,000 തവണ പ്രവർത്തിക്കാം.
  • ജീവനക്കാരനുള്ള ഉടമയുടെ ചെലവ് പരിധിയിൽ എത്തുമ്പോൾ റൺ നിർത്തുന്നു. ഒരു പ്രവർത്തനത്തിന്റെ token_budget ഒരു ഏകദേശ കണക്കാണ്.
  • ഒരു റീസ്റ്റാർട്ട് മൂലം തടസ്സപ്പെട്ട റൺ തടസ്സപ്പെട്ടത് എന്ന് അടയാളപ്പെടുത്തി ഒരിക്കൽ പുനരാരംഭിക്കുന്നു.
  • exit ടൂൾ ഉപയോഗിച്ച് ജീവനക്കാരന് ഒരു റൺ നേരത്തെ അവസാനിപ്പിക്കാം.

വർക്ക്ഫ്ലോകൾ പ്രവർത്തിപ്പിക്കുകയും നിയന്ത്രിക്കുകയും ചെയ്യുക

ഉടമയ്ക്ക് ഏത് വർക്ക്ഫ്ലോയും കൈകൊണ്ട് പ്രവർത്തിപ്പിക്കാം. ജീവനക്കാർ run_workflow, workflow_status, list_workflow_runs, set_workflow_enabled, സഹായികളും ടീമുകളും എന്നതിൽ പട്ടികപ്പെടുത്തിയ മറ്റ് വർക്ക്ഫ്ലോ ടൂളുകൾ എന്നിവ ഉപയോഗിച്ച് വർക്ക്ഫ്ലോകൾ നിയന്ത്രിക്കുന്നു.