பெரும்பாலான மக்கள் ஒரு LLM-க்குத் தூண்டுதல்களை (prompts) வழங்க முடியும். ஆனால், உண்மையான டிராஃபிக்கைத் தாங்கக்கூடிய ஒரு தயாரிப்பிற்குள் அதை உருவாக்குவது முற்றிலும் மாறுபட்ட விஷயம். நீங்கள் ஒரு சாட் விண்டோவில் தட்டச்சு செய்வதிலிருந்து, ஒரு தயாரிப்பு நிலையில் (production) AI-ஐ வெளியிடுவது வரை செல்ல விரும்பினால், அந்தத் தொழில்நுட்ப அடுக்கு (stack) எவ்வாறு ஒன்றிணைந்து செயல்படுகிறது என்பதை நீங்கள் புரிந்து கொள்ள வேண்டும். இது மந்திரம் அல்ல. இது தனித்தனி பொறியியல் சிக்கல்களின் ஒரு தொடர்முறை (pipeline), மேலும் ஒவ்வொரு அடுக்கிற்கும் அதன் சொந்தத் தோல்வி முறைகள் (failure modes) உள்ளன.

நீங்கள் ஒரு வார்த்தையைத் தட்டச்சு செய்த தருணத்திலிருந்து, ஒரு ஏஜென்ட் ஒரு பணியை முடிக்கும் தருணம் வரை, ஒரு நவீன AI அமைப்பு எவ்வாறு செயல்படுகிறது என்பதை நான் விளக்குகிறேன்.

அடித்தளம்: மாதிரிகள் எவ்வாறு சிந்திக்கின்றன

அதன் மையப்பகுதியில், ஒரு பெரிய மொழி மாதிரி (large language model) ஒரே ஒரு விஷயத்தை மட்டுமே செய்கிறது: அது அடுத்த டோக்கனை (token) கணிக்கிறது. அந்த டோக்கன் அடுத்த வார்த்தையாகவோ, ஒரு வார்த்தையின் பகுதியாகவோ அல்லது ஒரு குறியீடாகவோ கூட இருக்கலாம். கவிதை, குறியீடு (code), பகுத்தறிவு போன்ற மற்ற அனைத்தும், அந்த ஒற்றைத் பணியை பெரிய அளவில் செய்வதன் மூலம் உருவாகும் வெளிப்பாடுகளாகும் (emergent behavior).

உங்கள் தூண்டுதலில் இருந்து மாதிரியின் பதில் வரையிலான பயணம் இவ்வாறு அமைகிறது.

டோக்கனைசேஷன் (Tokenization) என்பது முதல் படி. ஒரு நரம்பியல் வலைப்பின்னலுக்கு (neural network) மூல உரை (raw text) என்பது அர்த்தமற்றது, எனவே மாதிரி உங்கள் வார்த்தைகளைத் துண்டுகளாகப் பிரித்து, ஒவ்வொரு துண்டையும் ஒரு எண்ணாக மாற்றுகிறது. "tokenization" என்ற வார்த்தை மூன்று தனித்தனி டோக்கன்களாக மாறலாம். "New York" என்ற சொற்றொடர் அகராதியைப் பொறுத்து ஒன்று அல்லது இரண்டு டோக்கன்களாக இருக்கலாம். இந்த எண்கள் தன்னிச்சையானவை அல்ல; அவை மாதிரி பயிற்சியின் போது கற்றுக்கொண்ட ஒரு நிலையான அகராதியிலிருந்து வருகின்றன.

வார்த்தைகள் எண்களாக மாறியவுடன், அவற்றுக்கு அர்த்தம் தேவைப்படுகிறது. எம்பெடிங்ஸ் (Embeddings) அந்த எண்களை வெக்டர்களாக (vectors) மாற்றுகின்றன—அவை கணித வெளியில் ஒத்த கருத்துக்களை அருகருகே வைக்கும் மிதப்புப் புள்ளி மதிப்புகளின் (floating-point values) நீண்ட பட்டியல்களாகும். "King" மற்றும் "Queen" ஆகியவை அருகருகே அமையும். "Paris" மற்றும் "Berlin" ஆகியவை ஒன்றாகக் குழுமமாக இருக்கும், ஆனால் "Python" அல்லது "JavaScript" ஆகியவற்றிலிருந்து வேறுபட்ட பகுதியில் இருக்கும்.

ஆனால் வெக்டர்கள் மட்டும் வரிசையை இழந்துவிடும். நிலை குறியீட்டு முறை (Positional encoding) வாக்கியத்தில் ஒவ்வொரு டோக்கனும் எங்குள்ளது என்பதை மாதிரிக்குத் தெரிவிக்கிறது. இது இல்லையென்றால், "The dog bit the man" மற்றும் "The man bit the dog" ஆகிய இரண்டும் ஒரே மாதிரியாகத் தோன்றும்.

அடுத்து கவனம் செலுத்தும் முறை (attention mechanism) வருகிறது. இங்குதான் மாதிரி உள்ளீட்டில் உள்ள அனைத்து டோக்கன்களையும் பார்த்து, அடுத்த டோக்கனைக் கணிப்பதற்கு எவை முக்கியம் என்பதைத் தீர்மானிக்கிறது. நீங்கள், "நிறுவனம் எப்போது தொடங்கப்பட்டது, மேலும் இப்போது அதை வழிநடத்துவது யார்?" என்று கேட்கும்போது, மாதிரி "தொடங்கப்பட்டது" (founded) என்பதை ஒரு தேதியுடனும், "வழிநடத்துகிறது" (leads) என்பதை ஒரு CEO பெயருடனும் இணைக்க வேண்டும். Attention அந்தத் தொடர்புகளை உருவாக்குகிறது.

இந்தச் செயல்பாடுகள் பல அடுக்குகளாக (layers) ஒன்றன் மேல் ஒன்றாக அமைகின்றன—பெரும்பாலும் டஜன் கணக்கான அடுக்குகள் இருக்கும்—ஆரம்ப அடுக்குகள் தொடரியலை (syntax) கையாள்கின்றன மற்றும் பிந்தைய அடுக்குகள் சுருக்கமான பகுத்தறிவை (abstract reasoning) உருவாக்குகின்றன. இடையில் எங்கோ, ஃபீட்-ஃபார்வர்ட் நெட்வொர்க்குகள் (feed-forward networks) உண்மைத் தகவல்களைச் சேமித்து வைக்கின்றன. பாரிஸ் பிரான்சின் தலைநகரம் அல்லது ஒரு குறிப்பிட்ட API ஒரு JSON payload-ஐ எதிர்பார்க்கிறது போன்ற தகவல்களை மாதிரி இங்கேதான் வைத்திருக்கும். இது ஒரு தரவுத்தளம் (database) அல்ல, ஆனால் வடிவங்களை (patterns) செயல்படுத்தும் ஒரு சுருக்கப்பட்ட எடைகளின் (weights) வலைப்பின்னல் ஆகும்.

இறுதியாக, டிகோடிங் (decoding) உட்புற வெக்டர் பிரதிநிதித்துவங்களை மீண்டும் மனிதர்கள் படிக்கக்கூடிய டோக்கன்களாக மாற்றுகிறது. தான் ஆங்கிலத்தில் எழுதுகிறோம் என்பதை மாதிரி "அறிவதில்லை"; அது சாத்தியமான ஆயிரக்கணக்கான அடுத்த டோக்கன்களை வரிசைப்படுத்தி, ஒரு நிறுத்த நிலை (stop condition) வரும் வரை மிகவும் சாத்தியமான ஒன்றைத் தேர்ந்தெடுத்துக்கொண்டே இருக்கிறது.

RAG அடுக்கு: மாதிரிகளுக்கு நினைவாற்றலை வழங்குதல்

ஒரு அடிப்படை மாதிரி கால freezing நிலையில் உள்ளது. அதன் எடைகள் (weights) ஒரு குறிப்பிட்ட தேதி வரை இணையத் தகவல்களை மட்டுமே கொண்டிருக்கும், மேலும் நீங்கள் அவற்றை வழங்காதவரை உங்கள் தனிப்பட்ட ஆவணங்களை அணுக முடியாது. இது பெரும்பாலான வணிகத் பணிகளுக்கு அதை பயனற்றதாக்குகிறது. Retrieval-Augmented Generation அல்லது RAG, பதிலளிப்பதற்கு முன் மாதிரி ஒரு வெளிப்புற நூலகத்தை (external library) ஆலோசிக்கும் வகையில் அமைப்பதன் மூலம் இதைச் சரிசெய்கிறது.

இதன் அமைப்பு கருத்தியல் ரீதியாக எளிமையானது ஆனால் நடைமுறையில் நுணுக்கமானது. முதலில், உங்கள் ஆவணங்களை எடுத்து சிறு துண்டுகளாகப் பிரித்தல் (chunking) முறையைப் பயன்படுத்துகிறீர்கள். நூறு பக்கங்கள் கொண்ட PDF-ஐ அப்படியே தூண்டுதல் விண்டோவில் போடக்கூடாது. அர்த்தம் குறையாமல் இருக்கும் அதே வேளையில், மாதிரியின் சூழல் வரம்பிற்குள் (context limit) பொருந்தும் வகையில் அதை பத்திகள், பிரிவுகள் அல்லது அர்த்தமுள்ள தொகுதிகளாகப் பிரிக்க வேண்டும்.

ஒவ்வொரு துண்டும் ஒரு எம்பெடிங் மாடல் (embedding model) வழியாகச் சென்று, LLM-க்குள் இருக்கும் டோக்கன்களைப் போலவே ஒரு வெக்டராக மாறுகிறது. இந்த வெக்டர்கள் ஒரு வெக்டர் தரவுத்தளத்தில் (vector database) வாழ்கின்றன—இது துல்லியமான தேடலை விட ஒற்றுமைத் தேடலுக்காக (similarity search) வடிவமைக்கப்பட்ட ஒரு சிறப்புச் சேமிப்பகமாகும். ஒரு பயனர் கேள்வி கேட்கும்போது, அவர்களின் வினாவை (query) எம்பெட் செய்து தரவுத்தளத்தைக் கேட்கிறீர்கள்: "இந்த வெக்டருக்கு அர்த்தத்தில் மிக நெருக்கமான துண்டுகள் எவை?"

வெறும் வெக்டர் தேடல் மட்டுமே பெரும்பாலும் துல்லியமான பொருத்தங்களைக் கண்டறிவதில் தவறிவிடும். ஒரு சிறந்த தயாரிப்பு அமைப்பு, முக்கிய வார்த்தை பொருத்தம் (keyword matching) மற்றும் அர்த்தமுள்ள ஒற்றுமை (semantic similarity) ஆகியவற்றை இணைக்கும் கலப்புத் தேடலைப் (hybrid search) பயன்படுத்துகிறது. யாராவது "SLA-99 compliance" என்று கேட்டால், உங்களுக்குத் தேவை அந்தச் சொற்றொடரை நேரடியாகக் கொண்ட ஆவணம் மட்டுமே தவிர, அது போன்ற உணர்வைத் தரும் ஆவணம் அல்ல.

மீட்டெடுத்தலுக்குப் பிறகு, மறுவரிசைப்படுத்துதல் (re-ranking) தேவையற்ற இரைச்சலை (noise) வடிகட்டுகிறது. ஆரம்பத் தேடல் இருபது துண்டுகளைத் தரலாம், ஆனால் முதல் மூன்று அல்லது நான்கு மட்டுமே உண்மையில் உதவும். ஒரு re-ranker பொருத்தத்தை மதிப்பிட்டு, எதையும் LLM-க்கு அனுப்பும் முன் மற்றவற்றைத் தள்ளிவிடுகிறது, இது டோக்கன்களைச் சேமிக்கிறது மற்றும் தவறான தகவல்களை (hallucinations) உருவாக்குவதைக் குறைக்கிறது.

ஏஜென்ட் அடுக்கு: செயல்பாடுகளைச் செய்தல்

RAG ஒரு மாடலை வாசிக்க அனுமதிக்கிறது. Agents அதைச் செயல்பட அனுமதிக்கின்றன.

ஒரு Agent என்பது அடிப்படையில் ஒரு loop-க்குள் சிக்கிக்கொண்ட ஒரு LLM ஆகும். அது கவனிக்கும், சிந்திக்கும், செயல்படும், மற்றும் மீண்டும் கவனிக்கும். நீங்கள் ஒரு Agent-இடம் விமான டிக்கெட் முன்பதிவு செய்யச் சொன்னால், அது முன்பதிவு எவ்வாறு செயல்படுகிறது என்பதை மட்டும் விவரிப்பதில்லை. அது அந்தப் பணியை நிலைகளாகப் பிரிக்கிறது, சரியான functions-களை அழைக்கிறது, பதில்களைப் படிக்கிறது மற்றும் அதற்கேற்ப மாற்றங்களைச் செய்கிறது.

அந்த loop இவ்வாறு அமையும். Observe: Agent தற்போதைய நிலையை வாசிக்கிறது—உங்கள் கோரிக்கை, முந்தைய tool calls-களின் முடிவுகள், ஏதேனும் பிழைகள். Reason: LLM அடுத்து என்ன செய்ய வேண்டும் என்பதைத் தீர்மானிக்கிறது, பெரும்பாலும் ஒரு கட்டமைக்கப்பட்ட திட்டத்தை உருவாக்குவதன் மூலம் அல்லது முன் வரையறுக்கப்பட்ட விருப்பங்களிலிருந்து ஒன்றைத் தேர்ந்தெடுப்பதன் மூலம் இது நடக்கும். Act: அது ஒரு tool-ஐ அழைக்கிறது.

Tools தான் Agents நிஜ உலகத்துடன் தொடர்பு கொள்ளும் வழியாகும். அவை JSON schemas மூலம் வரையறுக்கப்படுகின்றன, அவை ஒரு API-க்கு என்ன parameters தேவை என்பதை மாடலுக்குத் துல்லியமாகத் தெரிவிக்கின்றன. LLM தன்னிச்சையான HTTP requests-களைச் செய்வதில்லை. அது ஒரு schema-வை நிரப்புகிறது. "Call the weather API with city: London and units: metric." ஒருவேளை tool ஒரு வெப்பநிலையைத் திருப்பிக் கொடுத்தால், agent அதை வழங்குகிறது