AI ഏജൻ്റുമാരും ടൂൾ ഉപയോഗവും

നേട്ടങ്ങൾ:

• ഒരു ഏജൻ്റിനെ 'മോഡൽ + ടൂൾസ് + ലൂപ്പ്' എന്ന് നിർവചിക്കുകയും അത് എപ്പോൾ ആവശ്യമാണെന്ന് തീരുമാനിക്കുകയും ചെയ്യുന്നു
• പേര്, വിവരണം, input_schema എന്നിവ ഉപയോഗിച്ച് ടൂൾ നിർവചനം എഴുതുന്നു
• tool_use, tool_result ലൂപ്പ് എന്നിവയുടെ ഒഴുക്കും പിശക് കൈകാര്യം ചെയ്യലും നിരീക്ഷിക്കുന്നു

ഇതുവരെ, മോഡൽ എല്ലായ്‌പ്പോഴും ഒരു ജോലി ചെയ്‌തിട്ടുണ്ട്: ടെക്‌സ്‌റ്റ് ഇൻപുട്ട് സ്വീകരിക്കുക, ടെക്‌സ്‌റ്റ് പ്രതികരണങ്ങൾ സൃഷ്‌ടിക്കുക. എന്നാൽ യഥാർത്ഥ ജോലിക്ക് പലപ്പോഴും വാചകത്തേക്കാൾ കൂടുതൽ ആവശ്യമാണ്; ഒരു കണക്കുകൂട്ടൽ നടത്തുക, ഒരു ഡാറ്റാബേസ് അന്വേഷിക്കുക, ഒരു API വിളിക്കുക, നിലവിലെ വിനിമയ നിരക്ക് കണ്ടെത്തുക. മോഡലിന് ഈ കാര്യങ്ങൾ സ്വയം ചെയ്യാൻ കഴിയില്ല - എന്നാൽ അവ എപ്പോൾ ചെയ്യണമെന്ന് അവൾക്ക് തീരുമാനിക്കാനും ആരോടെങ്കിലും അവ ചെയ്യാൻ ആവശ്യപ്പെടാനും കഴിയും. ഇതാണ് ടൂൾ ഉപയോഗം മോഡലിന് നൽകുന്നത്, ഇതാണ് AI ഏജൻ്റുമാരുടെ അടിസ്ഥാനം. ഈ യൂണിറ്റിൽ, ഒരു ഏജൻ്റ് എന്താണെന്നും ടൂൾ എങ്ങനെ നിർവചിച്ചിരിക്കുന്നുവെന്നും tool_use ലൂപ്പ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും നമ്മൾ പഠിക്കും.

എന്താണ് ഒരു ഏജൻ്റ്? മോഡൽ + ടൂളുകൾ + ലൂപ്പ്

ഒരു AI ഏജൻ്റിന് മൂന്ന് ഭാഗങ്ങളുണ്ട്: മോഡൽ (തീരുമാനം എടുക്കുന്ന മസ്തിഷ്കം), ടൂളുകൾ (മോഡലിന് വിളിക്കാൻ കഴിയുന്ന പ്രവർത്തനങ്ങൾ: കാലാവസ്ഥ, ഡാറ്റാബേസ് അന്വേഷണം, ഇമെയിൽ അയയ്‌ക്കുക), ലൂപ്പ് (ലൂപ്പ്; മോഡൽ ടൂളിനെ വിളിക്കുന്നു, ഫലം നേടുന്നു, എന്തുചെയ്യണമെന്ന് വീണ്ടും തീരുമാനിക്കുന്നു, അങ്ങനെ പലതും).

നിർണായകമായ വ്യത്യാസം: ഒരൊറ്റ പാറ്റേൺ കോൾ ഒരു ഏജൻ്റല്ല. ഓരോ ഘട്ടത്തിലും ടൂൾ ഫലത്തെ അടിസ്ഥാനമാക്കി അടുത്ത നീക്കം തിരഞ്ഞെടുക്കുന്ന മോഡൽ പടിപടിയായി മുന്നോട്ട് പോകുന്ന ഒരു പ്രക്രിയയാണ് ഏജൻ്റ്. "ഒരു മനുഷ്യനെപ്പോലെ ചിന്തിക്കുക, നിങ്ങളുടെ കൈകൾ ഉപയോഗിക്കുക, ഫലം നോക്കുക, വീണ്ടും ചിന്തിക്കുക."

ഒരു പ്രധാന വസ്തുത: മോഡൽ തന്നെ വാഹനം പ്രവർത്തിപ്പിക്കുന്നില്ല. "ഈ ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് ഈ ടൂളിനെ വിളിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു" എന്ന് മോഡൽ പറയുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ (ഒരു ഹാർനെസ് എന്ന് വിളിക്കുന്നു) ടൂൾ പ്രവർത്തിപ്പിക്കുകയും ഫലം മോഡലിലേക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. സുരക്ഷയ്ക്ക് ഇത് അത്യന്താപേക്ഷിതമാണ്: മോഡൽ നിങ്ങളുടെ സിസ്റ്റത്തെ നേരിട്ട് സ്പർശിക്കില്ല; എല്ലാ പ്രവർത്തനങ്ങളും നിങ്ങളുടെ നിയന്ത്രണത്തിലാണ്.

നുറുങ്ങ്: ഏജൻ്റുമായുള്ള എല്ലാ പ്രശ്‌നങ്ങളും പരിഹരിക്കാൻ ശ്രമിക്കരുത്. ഏജൻ്റ്; കാലതാമസം, ചെലവുകൾ, പിശകുകൾ എന്നിവയുടെ അപകടസാധ്യത വർദ്ധിപ്പിക്കുന്നു. ആദ്യം ചോദിക്കുക: "ഇത് ഒരൊറ്റ കോളിലൂടെയോ ഒരു നിശ്ചിത വർക്ക്ഫ്ലോയിലൂടെയോ പരിഹരിക്കപ്പെടുമോ?" അതെ എന്നാണ് ഉത്തരമെങ്കിൽ, ഒരു ഏജൻ്റിൻ്റെ ആവശ്യമില്ല. ഘട്ടങ്ങൾ മുൻകൂട്ടി അറിയാൻ കഴിയാത്ത തുറന്ന ജോലികൾക്കുള്ളതാണ് ഏജൻ്റ്.

ടൂൾ ഡെഫനിഷൻ: പേര്, വിവരണം, input_schema

മോഡലിലേക്ക് ഒരു ഉപകരണം അവതരിപ്പിക്കുന്നതിന്, നിങ്ങൾ മൂന്ന് കാര്യങ്ങൾ നൽകുന്നു:

• പേര്: വാഹനത്തിൻ്റെ ഐഡൻ്റിറ്റി, ഉദാ. ഗെറ്റ്_വെതർ.
• വിവരണം: ഉപകരണം എന്താണ് ചെയ്യുന്നത്, എപ്പോൾ വിളിക്കണം. ശരിയായ സമയത്ത് ശരിയായ ഉപകരണം തിരഞ്ഞെടുക്കാൻ മോഡലിനെ അനുവദിക്കുന്ന ഏറ്റവും പ്രധാനപ്പെട്ട മേഖലയാണിത്. "എന്താണ് ചെയ്യുന്നത്" എന്ന് മാത്രമല്ല "എപ്പോൾ വിളിക്കുക" എന്നും എഴുതുക.
• input_schema (ഇൻപുട്ട് സ്കീമ): ടൂൾ പ്രതീക്ഷിക്കുന്ന പരാമീറ്ററുകൾ ഏത് തരത്തിലാണ് എന്ന് നിർവചിക്കുന്ന JSON സ്കീമ.

# വാഹന നിർവചനം (സങ്കല്പപരമായ — JSON സ്കീമ){ "name": "get_order_status", "description": "ഒരു ഓർഡറിൻ്റെ നിലവിലെ ഷിപ്പിംഗ് നില വീണ്ടെടുക്കുന്നു. ഒരു ഓർഡർ നമ്പർ എവിടെയാണെന്നോ എപ്പോൾ എത്തുമെന്നോ ഉപയോക്താവ് ചോദിക്കുമ്പോൾ വിളിക്കുക.", "input_schema": { "type": "object"no:" "properties": "properties": "properties" "string", "വിവരണം": "ഓർഡർ നമ്പർ, ഉദാ. SP-1024"} }, "ആവശ്യമാണ്": ["order_no"] }}

ഒരു നല്ല ടൂൾ വിവരണത്തിനുള്ള നിയമങ്ങൾ: വ്യക്തവും സംക്ഷിപ്തവുമായ പേര്, "എപ്പോൾ ഉപയോഗിക്കണം" എന്നതോടുകൂടിയ വിവരണം, ഓരോ പാരാമീറ്ററിനുമുള്ള വിവരണം, ആവശ്യമുള്ളവ നിർബന്ധമായും ഉൾപ്പെടുത്തുക. വാഹനങ്ങളുടെ എണ്ണം ഫോക്കസ് ചെയ്യുക; സമാനമായ ഡസൻ കണക്കിന് വാഹന മോഡലുകൾ ആശ്ചര്യകരമാണ്.

പ്രദേശം

അത് എന്താണ് ചെയ്യുന്നത്?

നല്ല ഉദാഹരണം

മോശം ഉദാഹരണം

പേര്

വാഹന ഐഡി

ഓർഡർ_സ്റ്റാറ്റസ്_ഗെറ്റിർ

കൊണ്ടുവരിക

വിവരണം

അത് എന്ത് ചെയ്യുന്നു + എപ്പോൾ വിളിക്കണം

"കാർഗോ സ്റ്റാറ്റസ് നൽകുന്നു; ഓർഡർ എവിടെയാണെന്ന് ഉപയോക്താവ് ചോദിക്കുമ്പോൾ വിളിക്കുക"

"ഡാറ്റ ലഭ്യമാക്കുന്നു"

ഇൻപുട്ട്_സ്‌കീമ

പാരാമീറ്റർ തരവും ആവശ്യകതയും

{order_no: സ്ട്രിംഗ്, വ്യാഖ്യാനിച്ചത്}

ഡയഗ്രം ഇല്ല / വിവരണം ഇല്ല

ടൂൾ_ഉപയോഗം → ടൂൾ_ഫലം ലൂപ്പ്

സൈക്കിൾ ഇതുപോലെ പ്രവർത്തിക്കുന്നു, ഘട്ടം ഘട്ടമായി:

1. നിങ്ങൾ ഉപയോക്തൃ ചോദ്യം + ഉപകരണ വിവരണങ്ങൾ മോഡലിലേക്ക് അയയ്ക്കുന്നു.
2. മോഡൽ നേരിട്ട് പ്രതികരിക്കുകയോ ടൂൾ_ഉപയോഗ ബ്ലോക്ക് സൃഷ്ടിക്കുകയോ ചെയ്യുന്നു: "order_no=SP-1024 ഉപയോഗിച്ച് order_durumu_getir വിളിക്കുക."
3. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ യഥാർത്ഥത്തിൽ ടൂൾ പ്രവർത്തിപ്പിക്കുന്നു (ഡാറ്റാബേസ് അന്വേഷിക്കുന്നു).
4. ടൂൾ_ഫലമായി നിങ്ങൾ ഫലം മോഡലിലേക്ക് തിരികെ അയയ്ക്കുന്നു.
5. ഈ ഫലത്തോടെ, മോഡൽ ഒന്നുകിൽ അന്തിമ ഉത്തരം നൽകുന്നു അല്ലെങ്കിൽ മറ്റൊരു ഉപകരണം വിളിക്കുന്നു. "ഞാൻ പൂർത്തിയാക്കി" എന്ന് മോഡൽ പറയുന്നതുവരെ സൈക്കിൾ തുടരുന്നു.

# Agent loop (conceptual)messages = [user_question]ആയിരിക്കുമ്പോൾ True: response = model.uret(messages, tools=tool_definitions) if response.tur == "tool_use": result = harness.run(response.tool_name, response.entries) # APPLICATION റൺ മെസേജുകൾ റിട്ടേൺ ചെയ്യൂ # അന്തിമ പ്രതികരണം; ലൂപ്പ് അവസാനിക്കുന്നു

ആധുനിക SDK-കൾ നിങ്ങൾക്കായി ഈ ലൂപ്പ് പ്രവർത്തിപ്പിക്കുന്ന ടൂൾ റണ്ണറുകൾ വാഗ്ദാനം ചെയ്യുന്നു; നിങ്ങൾ ടൂൾ ഫംഗ്‌ഷനുകൾ എഴുതുക. പക്ഷേ, തിരശ്ശീലയ്ക്ക് പിന്നിൽ സംഭവിക്കുന്നത് അതാണ്.

പിശക് മാനേജ്മെൻ്റ്

ടൂളുകൾ പരാജയപ്പെട്ടേക്കാം: ഓർഡർ കണ്ടെത്തിയില്ല, API സമയം കഴിഞ്ഞു, ഇൻപുട്ട് അസാധുവാണ്. നിങ്ങൾക്ക് ഉപകരണം പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഒരു വിവരണാത്മക ടൂൾ_ഫലമായി ("പിശക്: ഓർഡർ നമ്പർ SP-9999 കണ്ടെത്തിയില്ല") പിശക് ഫ്ലാഗായി മോഡലിലേക്ക് പിശക് തിരികെ നൽകുക. മോഡലിന് ഇത് കാണാനും ഉപയോക്താവിനോട് സൌമ്യമായി വിശദീകരിക്കാനും അല്ലെങ്കിൽ മറ്റൊരു വഴി പരീക്ഷിക്കാനും കഴിയും. പിശക് വിഴുങ്ങുകയും ശൂന്യമായ ഫലങ്ങൾ നൽകുകയും ചെയ്യരുത്; എന്താണ് തെറ്റ് സംഭവിച്ചതെന്ന് മോഡൽ അറിഞ്ഞിരിക്കണം.

ദുർബല/ശക്തമായ വാഹന വിവരണം

ദുർബലമായ (അനിശ്ചിത നാമം, "എപ്പോൾ" ഇല്ല):

പേര്: "ഡാറ്റ", വിവരണം: "ഡാറ്റ ലഭ്യമാക്കുന്നു"# എപ്പോൾ, എങ്ങനെ വിളിക്കണമെന്ന് മോഡലിന് അറിയില്ല; ഒന്നുകിൽ അത് വിളിക്കില്ല അല്ലെങ്കിൽ തെറ്റായി വിളിക്കുന്നു.

ശക്തമായത് (നെറ്റ് നെയിം + എപ്പോൾ + പാരാമീറ്റർ വിവരണം):

name: "musteri_bakiyesi_getir"വിവരണം: "ഒരു ഉപഭോക്താവിൻ്റെ കറണ്ട് അക്കൗണ്ട് ബാലൻസ് തിരികെ നൽകുന്നു. ഉപഭോക്താവ് ഡെബിറ്റ്, ക്രെഡിറ്റ് അല്ലെങ്കിൽ ബാലൻസ് ആവശ്യപ്പെടുമ്പോൾ വിളിക്കുക. പേയ്‌മെൻ്റ് നടത്തുന്നില്ല." input_schema: {custeri_id: string ("ഉപഭോക്തൃ ഐഡി")}# മോഡൽ ശരിയായ സമയത്ത്, അതിൻ്റെ പരിധി അറിഞ്ഞുകൊണ്ട്, ശരിയായ പരിധിയിൽ വിളിക്കുന്നു.

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - അനാവശ്യ ഏജൻ്റ്. ഒരു ടീം ഒരു മൾട്ടി-ടൂൾ ഏജൻ്റ് ഉപയോഗിച്ച് "ടെക്സ്റ്റ് സംഗ്രഹിക്കുക" ബിസിനസ്സ് നിർമ്മിച്ചു; ഓരോ റീക്യാപ്പിനും 4 മോഡൽ കോളുകളും 9 സെക്കൻഡും എടുക്കും. ജോലി യഥാർത്ഥത്തിൽ ഒരു കോൾ ജോലിയായിരുന്നു. ഞങ്ങൾ ഏജൻ്റിനെ നീക്കം ചെയ്‌ത് ഒരൊറ്റ കോളായി ചുരുക്കിയപ്പോൾ, സമയം 1.5 സെക്കൻഡായി കുറഞ്ഞു, ചെലവ് നാലിലൊന്നായി കുറഞ്ഞു. പാഠം: ശരിക്കും ആവശ്യമുള്ളപ്പോൾ ഏജൻ്റ് ഉപയോഗിക്കുക.

കേസ് 2 - ദുർബലമായ വിശദീകരണം, തെറ്റായ കോൾ. ഒരു സപ്പോർട്ട് ഏജൻ്റിൽ, ബാലൻസ് ചോദ്യത്തിലും ഷിപ്പിംഗ് ചോദ്യത്തിലും മോഡൽ ക്രമരഹിതമായി fetch എന്ന് വിളിക്കപ്പെടുന്ന ഒരു അവ്യക്ത ടൂൾ വിളിച്ചു. വാഹനങ്ങളെ balance_getir, cargo_durumu_getir എന്നിങ്ങനെ വിഭജിച്ച് "കോൾ എപ്പോൾ" വിശദീകരണങ്ങൾ ചേർത്തപ്പോൾ, തെറ്റായ വാഹന തിരഞ്ഞെടുപ്പ് 50 ഉദാഹരണങ്ങളിൽ 18 ൽ നിന്ന് 1 ആയി കുറഞ്ഞു.

കേസ് 3 - പിശക് വിഴുങ്ങി. ഓർഡർ കണ്ടെത്താനാകാതെ വന്നപ്പോൾ ഒരു ഏജൻ്റ് ശൂന്യമായ ഫലങ്ങൾ നൽകുന്നു; മോഡൽ ഇതിനെ "ഓർഡർ ഡെലിവർ ചെയ്തു" എന്ന് വ്യാഖ്യാനിക്കുകയും ഉപഭോക്താവിനെ തെറ്റിദ്ധരിപ്പിക്കുകയും ചെയ്തു. tool_result ("ഓർഡർ കണ്ടെത്തിയില്ല") എന്നതിലേക്ക് പിശക് സന്ദേശം വ്യക്തമായി എഴുതുമ്പോൾ, മോഡൽ "എനിക്ക് ഈ നമ്പർ കണ്ടെത്താൻ കഴിഞ്ഞില്ല, നിങ്ങൾക്കത് പരിശോധിക്കാമോ?" അവൻ പറയാൻ തുടങ്ങി.

സാധാരണ തെറ്റുകൾ

• എല്ലാം ഒരു ഏജൻ്റിലേക്ക് മാറ്റുന്നു: ഒരു കോൾ മതിയെങ്കിൽ, ഏജൻ്റ് ചെലവും കാലതാമസവും ചേർക്കുന്നു.
• അവ്യക്തമായ വാഹന വിവരണം: എപ്പോൾ വിളിക്കണമെന്ന് മോഡലിന് അറിയില്ല; തെറ്റായി തിരഞ്ഞെടുക്കുന്നു.
• മോഡലാണ് വാഹനം ഓടിക്കുന്നതെന്ന് കരുതി: ഹാർനെസ് വാഹനത്തെ ഓടിക്കുന്നു; മോഡൽ ആഗ്രഹിക്കുന്നു.
• പിശക് വിഴുങ്ങുന്നു: എന്താണ് തെറ്റ് സംഭവിച്ചതെന്ന് മോഡൽ അറിഞ്ഞിരിക്കണം; ഓപ്പൺ ടൂൾ_ഫലമായി പിശക് നൽകുക.
• സമാനമായ നിരവധി വാഹനങ്ങൾ: മോഡൽ ആശയക്കുഴപ്പത്തിലാകുന്നു; ടൂൾസെറ്റ് ഫോക്കസ് ചെയ്തതും കുറഞ്ഞതുമായി സൂക്ഷിക്കുക.

ശ്രദ്ധിക്കുക: "ആ വാഹനം വിളിക്കുക" എന്ന് മോഡൽ പറഞ്ഞതുകൊണ്ട് നടപടി എടുക്കണമെന്ന് അർത്ഥമാക്കുന്നില്ല. വിനാശകരമായ ടൂളുകളിൽ (ഇല്ലാതാക്കുക, ചെക്ക്ഔട്ട്, ഇമെയിൽ) നിങ്ങളുടെ ആപ്ലിക്കേഷൻ അന്ധമായി കോൾ എക്സിക്യൂട്ട് ചെയ്യാൻ പാടില്ല - ഇതാണ് അടുത്ത യൂണിറ്റിലെ സുരക്ഷാ വിഷയത്തിൻ്റെ കാതൽ.

ചുരുക്കത്തിൽ

• ഏജൻ്റ് = മോഡൽ (തീരുമാനം) + ഉപകരണങ്ങൾ (പ്രവർത്തനങ്ങൾ) + ലൂപ്പ് (കോൾ ടൂൾ, ഫലം നേടുക, വീണ്ടും തീരുമാനിക്കുക).
• ഒരൊറ്റ പാറ്റേൺ കോൾ ഒരു ഏജൻ്റല്ല; ഏജൻ്റ് ഒരു ഘട്ടം ഘട്ടമായുള്ള പ്രക്രിയയാണ്.
• മോഡൽ വാഹനം ഓടിക്കുന്നില്ല; നിങ്ങളുടെ ആപ്ലിക്കേഷൻ റൺ (ഹാർനെസ്) കൂടാതെ ടൂൾ_ഫലമായി ഫലം നൽകുന്നു.
• പേര്, വിവരണം (പ്രത്യേകിച്ച് "എപ്പോൾ വിളിക്കുക"), input_schema എന്നിവ പ്രകാരം ഉപകരണം തിരിച്ചറിയുന്നു.
• ടൂൾ_ഉപയോഗം → ഹാർനെസ് റണ്ണുകൾ → ടൂൾ_ഫലം → മോഡൽ "പൂർത്തിയായി" എന്ന് പറയുന്നതുവരെ ലൂപ്പ് തുടരുന്നു; പിശകുകൾ മോഡലിൽ വ്യക്തമായി റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു.

ആപ്ലിക്കേഷൻ ടാസ്ക്

നിങ്ങളുടെ സ്വന്തം ബിസിനസ്സിൽ നിന്ന് ഏജൻ്റിന് നൽകാവുന്ന 3 ടൂളുകൾ രൂപകൽപ്പന ചെയ്യുക. (1) ഓരോന്നിനും പേര്, വിവരണം "കോൾ എപ്പോൾ", input_schema എന്നിവ എഴുതുക; ഒരെണ്ണമെങ്കിലും വിനാശകരമല്ലാത്ത വായനാ ഉപകരണവും മറ്റൊന്ന് കണക്കുകൂട്ടലും ആകട്ടെ. (2) ഒരു റിയലിസ്റ്റിക് ഉപയോക്തൃ ചോദ്യം തിരഞ്ഞെടുത്ത് സ്വമേധയാ എഴുതുക (ഒരു ലൂപ്പിൽ) ഈ ടൂളുകളിൽ ഏതൊക്കെ ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് മോഡൽ വിളിക്കും, tool_result വന്നതിന് ശേഷം അത് എന്തുചെയ്യും. (3) ടൂളുകളിൽ ഒന്ന് പരാജയപ്പെടുന്ന ഒരു സാഹചര്യം സജ്ജീകരിക്കുകയും പിശക് സന്ദേശം മോഡലിലേക്ക് എങ്ങനെ മടങ്ങുമെന്ന് കാണിക്കുകയും ചെയ്യുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] എനിക്ക് ഏജൻ്റിനെ "മോഡൽ + ടൂൾസ് + ലൂപ്പ്" എന്ന് നിർവചിക്കാനും അത് എപ്പോൾ ആവശ്യമാണെന്ന് തീരുമാനിക്കാനും കഴിയും.
• [ ] ഹാർനെസ് വാഹനത്തെ ഓടിക്കുന്നുണ്ടെന്ന് എനിക്കറിയാം, മോഡലിന് അത് വേണം.
• എനിക്ക് [ ] പേര്, വിവരണം ("കോൾ എപ്പോൾ"), input_schema എന്നിവ ഉപയോഗിച്ച് ഒരു സോളിഡ് വാഹന വിവരണം എഴുതാം.
• എനിക്ക് [ ] tool_use → tool_result സൈക്കിൾ ഘട്ടം ഘട്ടമായി പിന്തുടരാനാകും.
• [ ] ഞാൻ ഉപകരണത്തിലെ പിശകുകൾ ഓപ്പൺ ടൂൾ_ഫലമായി മോഡലിന് റിപ്പോർട്ട് ചെയ്യുന്നു.