Agents dominate every AI conversation right now. Demos make them look like autonomous digital assistants that think, str

தற்போதுள்ள ஒவ்வொரு AI உரையாடலிலும் ஏஜெண்டுகள் (Agents) ஆதிக்கம் செலுத்துகின்றன. டெமோக்கள் பார்க்கும்போது, அவை மனித உதவியின்றி சிந்திக்கும், திட்டமிடும் மற்றும் சிக்கல்களைத் தீர்க்கும் தன்னாட்சி பெற்ற டிஜிட்டல் உதவியாளர்கள் போலத் தோன்றுகின்றன. ஆனால், அதன் இடைமுகத்திற்கு (interface) பின்னால் பார்த்தால், அது மிகவும் எளிமையான ஒன்று என்பதை நீங்கள் காண்பீர்கள். ஒரு ஏஜெண்ட் என்பது ஒரு லூப்பிற்குள் (loop) இயங்கும் ஒரு மொழி மாதிரி (language model) மட்டுமே. இது ஒரு வடிவமைப்பு முறை (design pattern) மட்டுமே, ஒரு உணர்வுநிலை (consciousness) அல்ல. இந்த வேறுபாட்டைப் புரிந்துகொள்வது முக்கியம், ஏனெனில் இது நீங்கள் இந்த அமைப்புகளை எவ்வாறு உருவாக்குவது, பிழைத்திருத்தம் (debug) செய்வது மற்றும் அவற்றை எவ்வாறு நம்புவது என்பதை மாற்றியமைக்கிறது.

ஒரு ஏஜெண்ட் உண்மையில் என்ன?

ஒரு சாதாரண சாட்பாட் (chatbot) என்பது ஒருமுறை மட்டுமே செயல்படும் ஒரு செயல்பாடு (single-shot function). நீங்கள் ஒரு புராம்ப்ட்டை (prompt) உள்ளிடுகிறீர்கள். மாதிரி அடுத்த டோக்கன்களைக் (tokens) கணித்து ஒரு உரைத் தொகுதியைத் திருப்பித் தருகிறது. அவ்வளவுதான், அது நின்றுவிடுகிறது. அதன் பதில் துல்லியமானதா என்று அது சரிபார்க்காது. ஒரு இணைய இணைப்பு வேலை செய்கிறதா அல்லது ஒரு கணக்கீடு சரியானதுதானா என்பதை அது சரிபார்க்காது. அது ஒரே முயற்சியில் தனது சிறந்த யூகத்தை உங்களுக்குக் கொடுத்துவிட்டு அமைதியாகிவிடும்.

ஒரு ஏஜெண்ட் அந்த ஒற்றைச் செயல்பாட்டை மீண்டும் மீண்டும் நிகழும் ஒரு சுழற்சியாக மாற்றுகிறது. மாதிரி இன்னும் உரையை உருவாக்குகிறதுதான், ஆனால் இப்போது அது ஒரு கட்டுப்படுத்தப்பட்ட லூப்பிற்குள் இயங்குகிறது, அங்கு அது வெளி உலகத்தைப் பாதிக்கவும், நடப்பவற்றிற்கு எதிர்வினையாற்றவும் முடியும்.

அந்தச் சுழற்சி இவ்வாறு இருக்கும்:

• இலக்கை மதிப்பிட்டு, என்ன செய்ய வேண்டும் என்று சிந்திப்பது.
• ஒரு கருவி (tool) அல்லது API-ஐப் பயன்படுத்தி ஒரு நடவடிக்கையை எடுப்பது.
• அந்த நடவடிக்கையின் முடிவைக் கவனிப்பது.
• அந்த புதிய தகவலின் அடிப்படையில் மீண்டும் சிந்திப்பது.

பணி முடியும் வரை அல்லது அமைப்பு ஒரு பாதுகாப்பு வரம்பை அடையும் வரை இந்தச் சுழற்சி மீண்டும் மீண்டும் நடைபெறும். இதுதான் முழு ரகசியமும். இதில் மறைமுகமான சிந்தனை இயந்திரம் (reasoning engine) எதுவும் இல்லை. உண்மையான கருவிகளிலிருந்து பெறப்படும் உண்மையான தரவுகளைப் பயன்படுத்தி, தனது பாதையைத் தானே திருத்திக் கொள்ள மாதிரிய에게 வாய்ப்பளிப்பதன் மூலமே இந்த மாயாஜாலம் நிகழ்கிறது.

ReAct: சிந்தனை-செயல்-கவனிப்புச் சுழற்சி (Thought-Action-Observation Cycle)

இந்த லூப்பைச் செயல்படுத்த மிகவும் பொதுவான வழி ReAct முறை ஆகும், இது Reason (சிந்தனை) மற்றும் Act (செயல்) என்பதைக் குறிக்கிறது. லூப்பின் ஒவ்வொரு சுழற்சியிலும், மாதிரி மூன்று தனித்துவமான நிலைகளைக் கடந்து செல்கிறது.

முதலில், மாதிரி ஒரு சிந்தனையை (Thought) உருவாக்குகிறது. இது தற்போதைய சூழ்நிலையைப் பிரதிபலிக்கிறது, அதன் அசல் இலக்கை நினைவூட்டுகிறது மற்றும் அடுத்து என்ன தெரிய வேண்டும் என்பதைத் தீர்மானிக்கிறது. இரண்டாவதாக, அது ஒரு **செயலை (Action)**த் தேர்ந்தெடுக்கிறது. இது ஒரு இணையத் தேடலாகவோ, தரவுத்தள வினவலாகவோ (database query), கால்குலேட்டர் அழைப்பாகவோ அல்லது ஒரு கோப்பைப் படிப்பதற்கான கோரிக்கையாகவோ இருக்கலாம். மூன்றாவதாக, அது ஒரு **கவனிப்பை (Observation)**ப் பெறுகிறது. கணினி மாதிரியின் வெளியே அந்தச் செயலைச் செயல்படுத்தி, அதன் மூல முடிவை உரையாடல் வரலாற்றிற்குத் திருப்பி அனுப்புகிறது. மாதிரி பின்னர் அந்தப் புதிய கவனிப்பைத் தனது புதிய யதார்த்தமாகப் பயன்படுத்தி அடுத்த லூப்பைத் தொடங்குகிறது.

ஒரு எளிய உதாரணத்தைக் கருத்தில் கொள்ளுங்கள். ஆஸ்டினில் (Austin) நாளை மழை பெய்யுமா என்று ஒரு ஏஜெண்டிடம் நீங்கள் கேட்டால், மாதிரி "எனக்கு ஆஸ்டினின் வானிலை முன்னறிவிப்பு தேவை" என்று நினைக்கலாம். அதன் செயல், நகரத்தின் பெயருடன் ஒரு வானிலை API-ஐ அழைப்பதாகும். கவனிப்பு என்பது ஒரு மூல JSON ஆகத் திரும்ப வரும்: வெப்பநிலை அளவு மற்றும் மழைப்பொழிவு நிகழ்தகவு (precipitation probability). மாதிரி பின்னர் மீண்டும் சிந்திக்கிறது, "வானிலை முன்னறிவிப்பு எழுபது சதவீத மழை வாய்ப்பைக் காட்டுகிறது," அதன் இறுதிச் செயல் அந்தத் தகவலைத் தொகுத்து உங்களுக்கு ஒரு எளிய ஆங்கிலப் பதிலைத் தருவதாகும்.

இந்த அமைப்பு மாதிரியைத் தரவுகளுடன் நிலைநிறுத்துவதால் (grounds the model) இது முக்கியத்துவம் பெறுகிறது. மாதிரி தொடர்வதற்கு முன் ஒரு தேடலை மேற்கொண்டு அதன் முடிவுகளைப் படிக்க வேண்டும் என்றால், அது தானாகவே உண்மைகளை உருவாக்க முடியாது. அடுத்த சிந்தனைக்கு கவனிப்பு என்பது ஒரு கடுமையான கட்டுப்பாடாகச் செயல்படுகிறது. மாதிரி பேசுவதற்கு முன் பார்க்க வேண்டியிருப்பதால், இந்த லூப் தவறான தகவல்களை உருவாக்குவதைக் கடினமாக்குகிறது.

நம்பகமான ஒரு லூப்பை உருவாக்க உங்களுக்குத் தேவையானவை

இந்த முறையைத் தயாரிப்புச் சூழலில் (production) இயக்குவதற்கு ஒரு புத்திசாலித்தனமான புராம்ப்ட் மட்டும் போதாது. உங்களிடம் மூன்று நடைமுறைப் பாதுகாப்புத் தடுப்புகள் (guardrails) இருக்க வேண்டும்.

படிநிலை வரம்பை (step budget) நிர்ணயிக்கவும். லூப் சுழற்சிகளின் அதிகபட்ச எண்ணிக்கையை எப்போதும் வரையறுக்கவும். ஒரு உச்சவரம்பு இல்லையென்றால், ஒரு ஏஜெண்ட் தேடுதல், கவனிப்பு, சிந்தனை, மீண்டும் தேடுதல் எனத் தனது சொந்த வாலையே துரத்திக் கொண்டே இருக்கும்—இது உங்கள் API பட்ஜெட்டை முழுமையாகத் தீர்த்துவிடும். ஒரு படிநிலை வரம்பு செயல்பாட்டை நிறுத்தக் கட்டாயப்படுத்துகிறது. வரம்பு எட்டப்பட்டதும், ஒரு பகுதி முடிவைத் திருப்புவதா, ஒரு மனிதரிடம் ஒப்படைப்பதா அல்லது வெறுமனே தோல்வியடைவதா என்பதை நீங்கள் தீர்மானிக்கலாம்.

குறியீடு செயலாக்கத்தை (code execution) நீங்களே கையாளவும். மொழி மாதிரி கருவிகளை நேரடியாக இயக்குவதில்லை. அது ஒரு கருவியின் பெயரைச் சொல்லி, அளவுருக்களைக் (parameters) குறிப்பிடும் கட்டமைக்கப்பட்ட உரை அல்லது JSON-ஐ வெளியிடுவதன் மூலம் செயல்களைப் பரிந்துரைக்கிறது மட்டுமே. உங்கள் குறியீடு...