GitHub, Java-விற்கான Copilot SDK-ஐ அறிமுகப்படுத்தியுள்ளது—இது ஒரு production-tested runtime ஆகும், இதை நீங்கள் எந்தவொரு Java பயன்பாட்டிலும் Maven dependency ஆகப் பயன்படுத்தலாம். Spring Boot திட்டங்களுக்கான Spring AI மற்றும் framework-agnostic மேம்பாட்டிற்கான LangChain4j ஆகியவற்றிற்கு இணையாக, AI agents-களை உருவாக்க இந்த SDK Java குழுக்களுக்கு மூன்றாவது வழியை வழங்குகிறது.
ஒரு புதிய விருப்பம் ஏன் முக்கியமானது
ஒரு backend-இல் generative AI-ஐச் சேர்ப்பது இப்போது Java நிறுவனங்களுக்கான ஒரு வழக்கமான தேவையாக உள்ளது. பெரும்பாலான குழுக்கள் ஏற்கனவே நிறுவப்பட்ட இரண்டு நூலகங்களுக்கு (libraries) இடையே ஒன்றைத் தேர்ந்தெடுக்கின்றன:
- Spring AI – Spring Boot-உடன் நெருக்கமானத் தொடர்பைக் கொண்டது; இது configuration, observability மற்றும் lifecycle management ஆகியவற்றிற்காக முழு Spring ecosystem-ஐயும் பயன்படுத்துகிறது.
- LangChain4j – framework-agnostic ஆக இருந்தாலும், memory, tool calling மற்றும் model access ஆகியவற்றிற்காகத் தனக்கென சில abstractions-களைக் கொண்டுள்ளது.
இவை இரண்டும் டெவலப்பர்களை, எல்லா architecture-களுக்கும் பொருந்தாத சில விதிமுறைகளையும் (conventions) மற்றும் runtime-களையும் பின்பற்றத் தூண்டுகின்றன. GitHub-இன் Copilot SDK, Spring context மற்றும் LangChain4j-இன் உயர்நிலை abstractions-களைத் தவிர்த்து, ஒரு எளிமையான (leaner) மாற்றாக அமைகிறது.
இந்த SDK உண்மையில் என்ன செய்கிறது
Copilot SDK என்பது ஒரு LLM API-இன் மெல்லிய உறை (thin wrapper) மட்டுமல்ல. இது host application-இன் அதே JVM-இல் இயங்கும் ஒரு இலகுரக agent runtime-ஐ வழங்குகிறது. “bring-your-own-key” (BYOK) முறையில், இந்த SDK ஒரு Copilot சந்தா (subscription) தேவையின்றி OpenAI, Anthropic அல்லது எந்தவொரு இணக்கமான endpoint-உடனும் நேரடியாகத் தொடர்பு கொள்கிறது.
இதன் முக்கிய திறன்கள்:
- Automatic tool calling – நீங்கள் ஒரு Java method reference-ஐக் கொடுத்தால், SDK அந்த method signature-லிருந்து தேவையான JSON schema-வை உருவாக்கும், இதனால் கைமுறையாக schema-க்களை உருவாக்க வேண்டிய அவசியம் இல்லை.
- Reactive streaming – இது raw Reactive Streams-இல் கட்டமைக்கப்பட்டுள்ளது; நீண்ட நேரம் எடுக்கும் completions-களின் போது, servlet containers நினைவகக் குவிப்பிலிருந்து (memory bloat) பாதுகாக்க இது back-pressure handling-ஐ வழங்குகிறது.
- Minimal coupling – இந்த runtime எந்தவொரு servlet container-இலும் இயங்கும் மற்றும் ஒரு திட்டத்தை (project) ஒரு குறிப்பிட்ட framework-க்குள் முடக்கிவிடாது.
- Context management – இது token பயன்பாடு மற்றும் உரையாடல் வரலாற்றைத் (conversation history) தானாகவே கண்காணிக்கிறது, இதனால் LLM அழைப்புகளின் போது வழக்கமாகச் செய்ய வேண்டிய கணக்கீடுகளை (bookkeeping) எளிதாக்குகிறது.
நீங்கள் இன்னும் என்ன உருவாக்க வேண்டும்
SDK-இன் எளிமை காரணமாக, சில பொறுப்புகள் பயன்பாட்டிற்கு (application) விடப்பட்டுள்ளன:
- Memory management – இந்த runtime உரையாடல் வரலாற்றை ஒருபோதும் துண்டிக்காது (truncate). model token வரம்பிற்குள் இருக்க நீங்கள் ஒரு sliding-window அல்லது வேறு ஒரு உத்தியைச் செயல்படுத்த வேண்டும்.
- Retry logic – rate-limit அல்லது தற்காலிகத் தவறுகளுக்கு (transient errors) இதில் built-in retry policy இல்லை. அந்த நோக்கத்திற்காக Resilience4j போன்ற நூலகங்களைப் பயன்படுத்தவும்.
- Observability – இந்த SDK தானாகவே metrics அல்லது traces-களை வழங்காது. உதாரணமாக, OpenTelemetry மூலம் அழைப்புகளை (calls) கைமுறையாக instrument செய்யவும்.
இந்த இடைவெளிகள் வேண்டுமென்றே விடப்பட்டுள்ளன; இந்த SDK ஒரு முழுமையான (full-stack) தீர்வைத் திணிக்காமல், உங்கள் வழியில் குறுக்கிடாமல் இருக்க விரும்புகிறது.
மற்றவற்றுடன் ஒப்பிடும்போது இது எப்படி உள்ளது
| அம்சம் (Feature) | Copilot SDK | Spring AI | LangChain4j |
|---|---|---|---|
| Framework சார்பு (dependence) | ஏதுமில்லை – எந்த servlet container-இலும் இயங்கும் | Spring Boot தேவை | ஏதுமில்லை, ஆனால் தனக்கென சில abstractions-களைச் சேர்க்கிறது |
| Built-in observability | இல்லை | Spring observability-உடன் ஒருங்கிணைக்கப்பட்டுள்ளது | இல்லை |
| Memory handling | கைமுறை (Manual) | — | பகுதி அளவு (Partial) |
| Tool-calling ஆதரவு | method refs-லிருந்து தானியங்கி schema உருவாக்கம் | — | கைமுறை (Manual) |
| Reactive streaming | Native Reactive Streams | — | — |
முழுமையான கட்டுப்பாட்டை விரும்புபவர்களும், ஏற்கனவே ஒரு monitoring stack-ஐக் கொண்டிருபவர்களும் Copilot SDK-இன் “bare bones” அணுகுமுறையைத் தேர்ந்தெடுக்கலாம். தானாகவே கிடைக்கும் (out-of-the-box) observability, configuration management அல்லது Spring-இன் dependency injection-உடன் நெருக்கமான ஒருங்கிணைப்பை விரும்பும் குழுக்கள் பெரும்பாலும் Spring AI-யையே பயன்படுத்துவார்கள். LangChain4j, Spring context-ஐத் திணிக்காமல் சில உயர்நிலை பயன்பாடுகளை (utilities) வழங்குவதன் மூலம் ஒரு இடைநிலைப் பாதையை (middle ground) வகிக்கிறது.