GitHub ജാവയ്ക്കായി ഒരു Copilot SDK പുറത്തിറക്കി—ഏതൊരു ജാവ ആപ്പിലും ഒരു Maven dependency ആയി ഉപയോഗിക്കാൻ കഴിയുന്ന, പ്രൊഡക്ഷൻ-ടെസ്റ്റ് ചെയ്ത ഒരു റൺടൈം ആണിത്. Spring Boot പ്രോജക്റ്റുകൾക്കായി Spring AI-യും, ഫ്രെയിംവർക്ക്-അജ്ഞാത (framework-agnostic) ഡെവലപ്‌മെന്റിനായി LangChain4j-യും ഉള്ളപ്പോൾ, AI ഏജന്റുകളെ നിർമ്മിക്കാൻ ജാവ ടീമുകൾക്ക് ഒരു മൂന്നാമതൊരു വഴി ഈ SDK നൽകുന്നു.

ഒരു പുതിയ ഓപ്ഷൻ പ്രധാനമാകുന്നത് എന്തുകൊണ്ട്

ഒരു ബാക്കെൻഡിൽ ജനറേറ്റീവ് AI ചേർക്കുന്നത് ഇപ്പോൾ ജാവ ഡെവലപ്പർമാരുടെ ഇടയിൽ ഒരു സാധാരണ ആവശ്യമായി മാറിയിരിക്കുന്നു. മിക്ക ടീമുകളും നിലവിൽ രണ്ട് പ്രശസ്തമായ ലൈബ്രറികൾക്കിടയിൽ ഒന്നാണ് തിരഞ്ഞെടുക്കുന്നത്:

  • Spring AI – Spring Boot-മായി അടുത്ത ബന്ധമുള്ളതാണ്; കോൺഫിഗറേഷൻ, ഒബ്സർവബിലിറ്റി (observability), ലൈഫ്സൈക്കിൾ മാനേജ്‌മെന്റ് എന്നിവയ്ക്കായി ഇത് മുഴുവൻ Spring ഇക്കോസിസ്റ്റത്തെയും ഉപയോഗിക്കുന്നു.
  • LangChain4j – ഫ്രെയിംവർക്ക്-അജ്ഞാതമാണ് (framework-agnostic), എങ്കിലും മെമ്മറി, ടൂൾ കോളിംഗ്, മോഡൽ ആക്സസ് എന്നിവയ്ക്കായി ഇത് സ്വന്തം അബ്‌സ്‌ട്രാക്ഷനുകൾ (abstractions) അടിച്ചേൽപ്പിക്കുന്നു.

ഇവ രണ്ടും ഡെവലപ്പർമാരെ ചില നിശ്ചിത രീതികളും (conventions) റൺടൈമുകളും സ്വീകരിക്കാൻ നിർബന്ധിക്കുന്നു, ഇത് എല്ലാ ആർക്കിടെക്ചറുകൾക്കും അനുയോജ്യമാകണമെന്നില്ല. Spring കോൺടെക്സ്റ്റും LangChain4j-യുടെ ഉയർന്ന തലത്തിലുള്ള അബ്‌സ്‌ട്രാക്ഷനുകളും ഒഴിവാക്കി കൂടുതൽ ലളിതമായ (leaner) ഒരു ബദൽ GitHub-ന്റെ Copilot SDK വാഗ്ദാനം ചെയ്യുന്നു.

ഈ SDK യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നത്

Copilot SDK എന്നത് ഒരു LLM API-ക്ക് ചുറ്റുമുള്ള ഒരു ലളിതമായ റാപ്പർ (wrapper) മാത്രമല്ല. ഇത് ഹോസ്റ്റ് ആപ്ലിക്കേഷന്റെ അതേ JVM-ൽ പ്രവർത്തിക്കുന്ന ഒരു ലൈറ്റ്വെയ്റ്റ് ഏജന്റ് റൺടൈം നൽകുന്നു. “bring-your-own-key” (BYOK) മോഡിൽ, Copilot സബ്‌സ്‌ക്രിപ്ഷൻ ആവശ്യപ്പെടാതെ തന്നെ OpenAI, Anthropic അല്ലെങ്കിൽ മറ്റേതെങ്കിലും അനുയോജ്യമായ എൻഡ്‌പോയിന്റുകളുമായി (endpoint) നേരിട്ട് ബന്ധപ്പെടാൻ ഈ SDK-യ്ക്ക് കഴിയും.

പ്രധാന സവിശേഷതകൾ ഇവയാണ്:

  • Automatic tool calling – നിങ്ങൾ ഒരു Java method reference നൽകിയാൽ മതി; മെത്തേഡ് സിഗ്നേച്ചറിൽ നിന്ന് ആവശ്യമായ JSON schema ഈ SDK സ്വയം നിർമ്മിക്കുന്നു, അതിനാൽ സ്കീമകൾ നേരിട്ട് തയ്യാറാക്കേണ്ടതില്ല.
  • Reactive streaming – റിയാക്റ്റീവ് സ്ട്രീംസുകളിൽ (Reactive Streams) നിർമ്മിച്ച ഇത്, ദീർഘനേരം നീണ്ടുനിൽക്കുന്ന പ്രക്രിയകൾക്കിടയിൽ സെർവ്‌ലെറ്റ് കണ്ടെയ്‌നറുകൾ (servlet containers) മെമ്മറി പ്രശ്നങ്ങളിലേക്ക് പോകാതിരിക്കാൻ ബാക്ക്-പ്രഷർ ഹാൻഡ്‌ലിംഗ് (back-pressure handling) നൽകുന്നു.
  • Minimal coupling – ഈ റൺടൈം ഏത് സെർവ്‌ലെറ്റ് കണ്ടെയ്‌നറിലും പ്രവർത്തിക്കും, കൂടാതെ ഒരു പ്രോജക്റ്റിനെ ഒരു പ്രത്യേക ഫ്രെയിംവർക്കിലേക്ക് മാത്രമായി പരിമിതപ്പെടുത്തുകയുമില്ല.
  • Context management – ഇത് ടോക്കൺ ഉപയോഗവും സംഭാഷണ ചരിത്രവും (conversation history) സ്വയമേവ ട്രാക്ക് ചെയ്യുന്നു, ഇത് LLM കോളുകളുമായി ബന്ധപ്പെട്ട കണക്കുകൾ എളുപ്പമാക്കുന്നു.

നിങ്ങൾ ഇനിയും നിർമ്മിക്കേണ്ട കാര്യങ്ങൾ

SDK-യുടെ ലളിതമായ സ്വഭാവം കാരണം ചില ഉത്തരവാദിത്തങ്ങൾ ആപ്ലിക്കേഷന് വിട്ടുകൊടുക്കുന്നു:

  • Memory management – റൺടൈം സംഭാഷണ ചരിത്രം ഒരിക്കലും മുറിച്ചുമാറ്റാറില്ല (truncate). മോഡൽ ടോക്കൺ പരിധിക്കുള്ളിൽ നിൽക്കാൻ നിങ്ങൾ ഒരു സ്ലൈഡിംഗ്-വിൻഡോ (sliding-window) അല്ലെങ്കിൽ മറ്റ് തന്ത്രങ്ങൾ നടപ്പിലാക്കേണ്ടതുണ്ട്.
  • Retry logic – റേറ്റ്-ലിമിറ്റ് അല്ലെങ്കിൽ താൽക്കാലിക പിശകുകൾക്കായി (transient errors) ഇതിൽ ഇൻബിൽറ്റ് റീട്രൈ പോളിസി ഇല്ല. ഇതിനായി Resilience4j പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുക.
  • Observability – SDK നേരിട്ട് മെട്രിക്സോ ട്രേസോ (metrics or traces) നൽകുന്നില്ല. ഉദാഹരണത്തിന് OpenTelemetry ഉപയോഗിച്ച് കോളുകൾ മാനുവലായി ഇൻസ്ട്രുമെന്റ് ചെയ്യുക.

ഈ കുറവുകൾ ബോധപൂർവ്വമാണ്; ഒരു ഫുൾ-സ്റ്റാക്ക് സൊല്യൂഷൻ നിർദ്ദേശിക്കുന്നതിന് പകരം, കാര്യങ്ങളിൽ ഇടപെടാതെ ലളിതമായി നിലകൊള്ളാനാണ് SDK ശ്രമിക്കുന്നത്.

മറ്റ് ഓപ്ഷനുകളുമായി താരതമ്യം ചെയ്യുമ്പോൾ

സവിശേഷത (Feature) Copilot SDK Spring AI LangChain4j
ഫ്രെയിംവർക്ക് ആശ്രിതത്വം (Framework dependence) ഇല്ല – ഏത് സെർവ്‌ലെറ്റ് കണ്ടെയ്‌നറിലും പ്രവർത്തിക്കും Spring Boot ആവശ്യമാണ് ഇല്ല, എങ്കിലും സ്വന്തം അബ്‌സ്‌ട്രാക്ഷനുകൾ ചേർക്കുന്നു
ഇൻബിൽറ്റ് ഒബ്സർവബിലിറ്റി (Built-in observability) ഇല്ല Spring observability-യുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു ഇല്ല
മെമ്മറി ഹാൻഡ്‌ലിംഗ് (Memory handling) മാനുവൽ — ഭാഗികമായി
ടൂൾ-കോളിംഗ് സപ്പോർട്ട് (Tool-calling support) മെത്തേഡ് റഫറൻസുകളിൽ നിന്ന് ഓട്ടോമാറ്റിക് സ്കീമ ജനറേഷൻ — മാനുവൽ
റിയാക്റ്റീവ് സ്ട്രീമിംഗ് (Reactive streaming) നേറ്റീവ് റിയാക്റ്റീവ് സ്ട്രീംസ് — —

പൂർണ്ണമായ നിയന്ത്രണം ആഗ്രഹിക്കുന്നവരും നിലവിൽ ഒരു മോണിറ്ററിംഗ് സ്റ്റാക്ക് ഉപയോഗിക്കുന്നവരുമായ ഡെവലപ്പർമാർ Copilot SDK-യുടെ ഈ ലളിതമായ (bare bones) സമീപനം ഇഷ്ടപ്പെട്ടേക്കാം. ഔട്ട്-ഓഫ്-ദി-ബോക്സ് ഒബ്സർവബിലിറ്റി, കോൺഫിഗറേഷൻ മാനേജ്‌മെന്റ് അല്ലെങ്കിൽ Spring-ന്റെ डिपൻഡൻസി ഇൻജക്ഷനുമായി (dependency injection) കൂടുതൽ അടുത്ത ബന്ധം ആഗ്രഹിക്കുന്ന ടീമുകൾ Spring AI തന്നെ ഉപയോഗിക്കാൻ സാധ്യതയുണ്ട്. Spring കോൺടെക്സ്റ്റ് നിർബന്ധമാക്കാതെ തന്നെ ചില ഉയർന്ന തലത്തിലുള്ള യൂട്ടിലിറ്റികൾ നൽകിക്കൊണ്ട് LangChain4j ഒരു ഇടനിലക്കാരനായി നിലകൊള്ളുന്നു.