𝗔𝗜 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻: 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻 𝘃𝘀. 𝗡𝗮𝘁𝗶𝘃𝗲 𝗖𝗼𝗱𝗲

AI പ്രോട്ടോടൈപ്പുകൾ നിർമ്മിക്കുമ്പോൾ വേഗത വളരെ പ്രധാനമാണ്. പ്രോംപ്റ്റുകൾ (prompts), വെക്റ്റർ സ്റ്റോറുകൾ (vector stores), മോഡലുകൾ എന്നിവ വേഗത്തിൽ ബന്ധിപ്പിക്കാൻ ഡെവലപ്പർമാർ ആഗ്രഹിക്കുന്നു. ഈ ആവശ്യം LangChain പോലുള്ള ഫ്രെയിംവർക്കുകളുടെ ഉപയോഗത്തിലേക്ക് നയിക്കുന്നു.

എന്നാൽ ഒരു പ്രോട്ടോടൈപ്പിൽ നിന്ന് കോഡ് പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിലേക്ക് മാറ്റുമ്പോൾ എന്റെ കാഴ്ചപ്പാട് മാറുന്നു. പ്രൊഡക്ഷനിൽ, ഓരോ ഡിപെൻഡൻസിയും (dependency) ടെക്നിക്കൽ ഡെബ്റ്റുമായി (technical debt) താരതമ്യം ചെയ്ത് പരിശോധിക്കേണ്ടതുണ്ട്. ഡീബഗ്ഗിംഗ് (debugging), മെയിന്റനൻസ് (maintenance), ബ്രേക്കിംഗ് ചേഞ്ചുകൾ (breaking changes) എന്നിവ നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്.

GenAI ഡാറ്റാ പൈപ്പ്‌ലൈനുകൾ നിർമ്മിക്കുന്നതിനുള്ള രണ്ട് രീതികൾ ഞാൻ താരതമ്യം ചെയ്തു: പ്യുവർ നേറ്റീവ് പൈത്തൺ (Pure Native Python), LangChain Expression Language (LCEL).

അവയുടെ ഗുണദോഷങ്ങൾ താഴെ പറയുന്നവയാണ്:

Native Python Approach

  • ഇത് ഭാരം കുറഞ്ഞ ഔദ്യോഗിക OpenAI ക്ലയന്റ് ഉപയോഗിക്കുന്നു.
  • ഇത് നിങ്ങളുടെ വൾനറബിലിറ്റി സർഫസ് (vulnerability surface) കുറയ്ക്കുകയും ഡിപെൻഡൻസി പ്രശ്നങ്ങൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു.
  • കോഡ് ഒരു സ്റ്റാൻഡേർഡ് എക്സിക്യൂഷൻ ഫ്ലോ പിന്തുടരുന്നു.
  • എറർ സംഭവിച്ച കൃത്യമായ വരിയിലേക്ക് സ്റ്റാക്ക് ട്രാസുകൾ (stack traces) സൂചിപ്പിക്കുന്നു.
  • നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ബ്രേക്ക്പോയിന്റുകളും ലോഗിംഗും എളുപ്പത്തിൽ ഉപയോഗിക്കാം.
  • പ്രൊവൈഡറിൽ നിന്നുള്ള റോ (raw) API സ്കീമയെ നിങ്ങൾ നേരിട്ട് ആശ്രയിക്കുന്നു.

LangChain Approach

  • ഇത് ഒന്നിലധികം നെസ്റ്റഡ് പാക്കേജുകൾ (nested packages) അവതരിപ്പിക്കുന്നു.
  • വലിയ എൻ്റർപ്രൈസ് ഡിപ്ലോയ്മെന്റുകളിൽ ഈ ഡിപെൻഡൻസികൾ നിലനിർത്താൻ കൂടുതൽ ഓപ്പറേഷണൽ ഓവർഹെഡ് (operational overhead) നേരിടേണ്ടി വരുന്നു.
  • പൈപ്പ്‌ലൈനുകൾ പ്രഖ്യാപിക്കാൻ ഇത് ഒരു കസ്റ്റം പൈപ്പ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു.
  • സ്റ്റാക്ക് ട്രാസുകൾ ഫ്രെയിംവർക്ക് കോഡിലേക്ക് ആഴത്തിൽ പോകുന്നതിനാൽ ഇത് ഡീബഗ്ഗിംഗ് പ്രയാസകരമാക്കുന്നു.
  • ഇത് മോഡൽ-സ്പെസിഫിക് API മാറ്റങ്ങളിൽ നിന്ന് നിങ്ങളെ സംരക്ഷിക്കുന്നു.
  • കുറഞ്ഞ മാറ്റങ്ങളോടെ OpenAI പോലുള്ള മോഡൽ പ്രൊവൈഡർമാരെ Anthropic പോലുള്ളവയിലേക്ക് മാറ്റാൻ നിങ്ങൾക്ക് കഴിയും.

How to choose:

നിങ്ങളുടെ പൈപ്പ്‌ലൈൻ ലളിതമായ ഒരു സിംഗിൾ-സ്റ്റെപ്പ് ട്രാൻസാക്ഷൻ ആണെങ്കിൽ 'Native' തിരഞ്ഞെടുക്കുക. നിങ്ങൾ നേരിട്ടുള്ള text-to-JSON പാഴ്സിംഗ് ആണ് ചെയ്യുന്നതെങ്കിൽ, ക്ലീൻ റാപ്പർ കോഡിലൂടെ (wrapper code) നിങ്ങളുടെ സിസ്റ്റം ലളിതവും സുതാര്യവുമാക്കാം.

നിങ്ങളുടെ ആവശ്യങ്ങൾ വർദ്ധിക്കുമ്പോൾ LangChain തിരഞ്ഞെടുക്കുക. നിങ്ങൾക്ക് സങ്കീർണ്ണമായ പ്രോംപ്റ്റ് മാനേജ്‌മെന്റ്, ലോംഗ്-ടേം മെമ്മറി എന്നിവ ആവശ്യമുണ്ടെങ്കിലോ അല്ലെങ്കിൽ ഒന്നിലധികം മോഡൽ വെണ്ടർമാരെ വേഗത്തിൽ മാറ്റേണ്ടി വരികയാണെങ്കിലോ, ഈ ഫ്രെയിംവർക്ക് ഉപയോഗിക്കുന്നത് ലാഭകരമാണ്.

കുറഞ്ഞ കോഡ് എഴുതുക എന്നത് മാത്രമല്ല നമ്മുടെ ലക്ഷ്യം. സ്കെയിലബിൾ ആയതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുക എന്നതാണ് നമ്മുടെ ലക്ഷ്യം.

Source: https://dev.to/ingit_bhatnagar/orchestrating-ai-langchain-framework-abstraction-vs-pure-native-code-4iec

Optional learning community: https://t.me/GyaanSetuAi