ఏజెంట్ మెమరీని ప్రాంప్ట్లో కుమ్మరించడం ఆపండి
చాలా మంది డెవలపర్లు ప్రతి ప్రాంప్ట్కు పాత సమాచారాన్ని కలుపుతూ ఏజెంట్ లూప్లను (agent loops) నిర్మిస్తారు.
మీరు మునుపటి పరిశీలనలు (observations), టూల్ కాల్స్ (tool calls) మరియు రీజనింగ్ ట్రేస్లను (reasoning traces) జోడిస్తారు. ప్రాంప్ట్ ఒక చెత్త డబ్బాగా (junk drawer) మారే వరకు మీరు డేటాను జోడిస్తూనే ఉంటారు. మోడల్ ఎక్కువ సమాచారాన్ని చూస్తుంది, కానీ మీరు నియంత్రణను కోల్పోతారు. ఏ మెమరీ భాగం వల్ల ఒక నిర్దిష్ట నిర్ణయం తీసుకున్నారో మీకు ఇక తెలియదు.
AgenticSTS అనే కొత్త పేపర్ ఒక భిన్నమైన మార్గాన్ని సూచిస్తుంది. ఇది మెమరీని కేవలం పెద్ద కాంటెక్స్ట్ విండో (context window) కోసం చేసే పోటీగా కాకుండా, ఒక ఇంటర్ఫేస్గా పరిగణిస్తుంది.
ఈ పేపర్ Slay the Spire 2 అనే గేమ్ను టెస్ట్బెడ్గా ఉపయోగిస్తుంది. ఈ వాతావరణంలో వందలాది వ్యూహాత్మక నిర్ణయాలు తీసుకోవాల్సి ఉంటుంది. ఇది కేవలం ఒక సాధారణ చాట్ బాట్ కాదు.
దీని ప్రధాన ఉద్దేశ్యం ఇది: భవిష్యత్తు నిర్ణయం దేనిని చూడటానికి అనుమతించబడుతుందో తెలిపే ఒక ఒప్పందమే (contract) మెమరీ.
ముడి ట్రాన్స్క్రిప్ట్లకు (raw transcripts) బదులుగా, రచయితలు ఐదు నిర్దిష్ట పొరలను (layers) ఉపయోగించి కొత్త ప్రాంప్ట్లను రూపొందిస్తారు:
- స్థిరమైన ప్రోటోకాల్ సూచనలు (Fixed protocol instructions)
- ప్రస్తుత స్థితి మరియు యాక్షన్ స్కీమాలు (Current state and action schemas)
- తిరిగి పొందిన గేమ్ నియమాలు (Retrieved game rules)
- మునుపటి రన్ల సారాంశాలు (Summaries from prior runs)
- ట్రిగ్గర్ చేయబడిన వ్యూహాత్మక నైపుణ్యాలు (Triggered strategic skills)
ఈ నిర్మాణం అన్నింటినీ మారుస్తుంది. మీరు ప్రతి పొరను తనిఖీ చేయవచ్చు, ఫ్రీజ్ చేయవచ్చు లేదా నిలిపివేయవచ్చు. మీరు మెమరీని కేవలం డేటా కుప్ప నుండి ఎంపిక చేసిన సాక్ష్యంగా మారుస్తారు.
ఉత్పత్తిలో (production) ఏజెంట్లు విఫలం కావడానికి కారణం మోడల్ లోపాలు కాదు, అవి కాంటెక్స్ట్ లోపాలు. ఏజెంట్ పాత స్థితిని కొత్త స్థితితో కలుపుతుంది లేదా పాత ఆలోచనలను (outdated reflections) ముందుకు తీసుకెళ్తుంది. మీ విధానం కేవలం టెక్స్ట్ను జోడించడం మాత్రమే అయితే, డీబగ్గింగ్ చేయడం పురావస్తు శాస్త్రం (archaeology) లాగా అనిపిస్తుంది.
ఒక టైప్డ్ మెమరీ ఇంటర్ఫేస్ మీకు పోల్చడానికి ఒక మార్గాన్ని ఇస్తుంది.
ఎక్కువ కాలం నడిచే ఏజెంట్లకు, భారీ కాంటెక్స్ట్ విండో ఒక ఉచ్చు వంటిది. అది వాస్తవాలు, పాత వాస్తవాలు మరియు విఫలమైన ప్రయత్నాల మిశ్రమంగా మారుతుంది. విండో ఎంత పెద్దదిగా ఉంటే, పేరుకుపోయిన వ్యర్థాలను (sediment) మెమరీగా పొరపాటుగా భావించడం అంత సులభం అవుతుంది.
మెరుగైన ఏజెంట్లను నిర్మించడానికి, ఈ పద్ధతులను అనుసరించండి:
- స్థిరమైన సూచనలను ప్రస్తుత స్థితి నుండి వేరు చేయండి
- నియమాలను రిట్రీవల్ లేయర్లో (retrieval layer) ఉంచండి
- అనుభవాన్ని చాట్ అవశేషాలుగా కాకుండా స్పష్టమైన రికార్డులుగా నిల్వ చేయండి
- పదేపదే చేసే సవరణలను ట్రిగ్గర్ చేయబడిన నైపుణ్యాలుగా మార్చండి
- పరీక్ష కోసం ప్రతి మెమరీ లేయర్ను తొలగించగలిగేలా చేయండి
మీరు ఒక మెమరీ లేయర్ను ఆపలేకపోతే, అది నిజంగా సహాయపడుతుందో లేదో మీకు తెలియదు. మొత్తం డేటా కుప్ప కొన్నిసార్లు పనిచేస్తుందని మాత్రమే మీకు తెలుస్తుంది.
ఏజెంట్ మెమరీని కేవలం ఒక 'వైబ్స్ లేయర్' (vibes layer) లాగా చూడటం ఆపండి. తదుపరి నిర్ణయంలోకి ఖచ్చితంగా ఏమి వెళ్తుంది, అది ఎక్కడి నుండి వచ్చింది మరియు దానిని ఎలా నిలిపివేయాలో మీకు తెలిసిన వ్యవస్థ వైపు వెళ్లండి.
మీ ఏజెంట్ దేనిని గుర్తుంచుకోవడానికి అనుమతించబడిందో వివరించలేకపోతే, దానికి మెమరీ లేదు. దానికి కేవలం ఒక బేస్మెంట్ (basement) ఉన్న ప్రాంప్ట్ మాత్రమే ఉంది.
Source: https://dev.to/komo/stop-dumping-agent-memory-into-the-prompt-58ka
Optional learning community: https://t.me/GyaanSetuAi