ஏஜென்ட் நினைவகத்தை அப்படியே பிராம்ப்ட்டில் திணிப்பதைத் தவிர்க்கவும்
பெரும்பாலான டெவலப்பர்கள் அடுத்தடுத்த பிராம்ப்ட்களுக்கு அனைத்தையும் இணைப்பதன் மூலம் ஏஜென்ட் லூப்களை (agent loops) உருவாக்குகிறார்கள்.
நீங்கள் முந்தைய அவதானிப்புகள், டூல் கால்கள் மற்றும் பகுத்தறிவுத் தடயங்களைச் சேர்க்கிறீர்கள். பிராம்ப்ட் ஒரு குப்பைத் தொட்டியாக மாறும் வரை நீங்கள் தரவுகளைச் சேர்த்துக் கொண்டே இருக்கிறீர்கள். மாடல் அதிகத் தகவல்களைப் பார்க்கிறது, ஆனால் நீங்கள் கட்டுப்பாட்டை இழக்கிறீர்கள். எந்த நினைவகம் ஒரு குறிப்பிட்ட முடிவுக்குக் காரணமாக இருந்தது என்பதை உங்களால் இனி அறிய முடியாது.
AgenticSTS எனப்படும் புதிய ஆய்வறிக்கை ஒரு மாறுபட்ட பாதையை முன்மொழிகிறது. இது நினைவகத்தை மிகப்பெரிய கான்டெக்ஸ்ட் விண்டோவிற்கான (context window) போட்டியாகப் பார்க்காமல், ஒரு இடைமுகமாக (interface) கருதுகிறது.
இந்த ஆய்வறிக்கை Slay the Spire 2 விளையாட்டை ஒரு சோதனைத் தளமாகப் பயன்படுத்துகிறது. இந்தச் சூழல் நூற்றுக்கணக்கான மூலோபாய முடிவுகளைக் கோருகிறது. இது ஒரு சாதாரண சாட்பாட் அல்ல.
இதன் முக்கியக் கருத்து இதுதான்: நினைவகம் என்பது எதிர்கால முடிவு எதைப் பார்க்க அனுமதிக்கப்படுகிறது என்பதற்கான ஒரு ஒப்பந்தம்.
மூலப் பதிவுகளுக்குப் பதிலாக, ஆசிரியர்கள் ஐந்து குறிப்பிட்ட அடுக்குகளைப் பயன்படுத்திப் புதிய பிராம்ப்ட்களை உருவாக்குகிறார்கள்:
- நிலையான புரோட்டோகால் அறிவுறுத்தல்கள்
- தற்போதைய நிலை மற்றும் செயல் திட்டங்கள்
- மீட்டெடுக்கப்பட்ட விளையாட்டு விதிகள்
- முந்தைய ஓட்டங்களின் சுருக்கங்கள்
- தூண்டப்பட்ட மூலோபாயத் திறன்கள்
இந்த அமைப்பு அனைத்தையும் மாற்றுகிறது. நீங்கள் ஒவ்வொரு அடுக்கையும் ஆய்வு செய்யலாம், உறைய வைக்கலாம் அல்லது முடக்கலாம். நீங்கள் நினைவகத்தை ஒரு தரவுத் குவியலில் இருந்து தேர்ந்தெடுக்கப்பட்ட ஆதாரமாக மாற்றுகிறீர்கள்.
பல தயாரிப்பு ஏஜென்ட் தோல்விகள் மாடல் தோல்விகள் அல்ல. அவை கான்டெக்ஸ்ட் தோல்விகள். ஏஜென்ட் பழைய நிலையையும் புதிய நிலையையும் கலந்துவிடுகிறது அல்லது காலாவதியான சிந்தனைகளைத் தொடர்ந்து கொண்டு செல்கிறது. உங்கள் ஒரே கொள்கை கூடுதல் உரையை இணைப்பது மட்டுமே என்றால், டீபக் செய்வது (debugging) தொல்லையாய்வு செய்வது போல இருக்கும்.
ஒரு வகைப்படுத்தப்பட்ட நினைவக இடைமுகம் உங்களுக்கு ஒப்பிடுவதற்கு ஏதேனும் ஒன்றைக் கொடுக்கிறது.
நீண்ட நேரம் இயங்கும் ஏஜென்ட்களுக்கு, ஒரு மிகப்பெரிய கான்டெக்ஸ்ட் விண்டோ ஒரு பொறியாகும். அது உண்மைகள், காலாவதியான உண்மைகள் மற்றும் தோல்வியடைந்த முயற்சிகளின் கலவையாக மாறிவிடும். விண்டோ எவ்வளவு பெரியதாக இருக்கிறதோ, அவ்வளவு எளிதாக படிவுகளை (sediment) நினைவகம் என்று தவறாகக் கருத நேரிடும்.
சிறந்த ஏஜென்ட்களை உருவாக்க, இந்த முறைகளைப் பின்பற்றுங்கள்:
- நிலையான அறிவுறுத்தல்களைத் தற்போதைய நிலையிலிருந்து பிரிக்கவும்
- விதிகளை ஒரு மீட்டெடுப்பு அடுக்கில் (retrieval layer) வைத்திருக்கவும்
- அனுபவங்களை சாட் எச்சங்களாக அல்லாமல், தெளிவான பதிவுகளாகச் சேமிக்கவும்
- மீண்டும் மீண்டும் செய்யப்படும் திருத்தங்களைத் தூண்டப்பட்ட திறன்களாக மாற்றவும்
- சோதனைகளுக்காக ஒவ்வொரு நினைவக அடுக்கையும் நீக்கக்கூடியதாக மாற்றவும்
உங்களால் ஒரு நினைவக அடுக்கை அணைக்க முடியாவிட்டால், அது உண்மையில் உதவுகிறதா இல்லையா என்பது உங்களுக்குத் தெரியாது. அந்த முழுத் தொகுப்பும் சில நேரங்களில் வேலை செய்கிறது என்பதை மட்டுமே நீங்கள் அறிவீர்கள்.
ஏஜென்ட் நினைவகத்தை ஒரு vibes அடுக்காகக் கருதுவதை நிறுத்துங்கள். அடுத்த முடிவிற்கு என்ன செல்கிறது, அது எங்கிருந்து வந்தது மற்றும் அதை எவ்வாறு முடக்குவது என்பதை நீங்கள் துல்லியமாகத் தெரிந்து கொள்ளும் ஒரு அமைப்பை நோக்கி நகரவும்.
உங்கள் ஏஜென்ட் எதை நினைவில் கொள்ள அனுமதிக்கப்பட்டது என்பதை விளக்க முடியாவிட்டால், அதற்கு நினைவகம் இல்லை என்று அர்த்தம். அதற்கு ஒரு அடித்தளத்துடன் கூடிய (basement) பிராம்ப்ட் மட்டுமே உள்ளது.
Source: https://dev.to/komo/stop-dumping-agent-memory-into-the-prompt-58ka
Optional learning community: https://t.me/GyaanSetuAi