నిజంగా పనిచేసే AI అప్లికేషన్లను నిర్మించడం అనేది సరైన ప్రాంప్ట్ను రూపొందించడం కంటే, మీరు మోడల్కు అందించే సమాచారాన్ని నియంత్రించడంపై ఎక్కువగా ఆధారపడి ఉంటుంది. మీరు ఎప్పుడైనా ఒక అసిస్టెంట్తో సుదీర్ఘమైన చాట్లో ఉండి, పది నిమిషాల క్రితం మీరు చెప్పిన విషయాన్ని అది మర్చిపోయిందని గ్రహించి ఉంటే, కాంటెక్స్ట్ ఇంజనీరింగ్ (context engineering) విఫలమైనప్పుడు ఏం జరుగుతుందో మీరు ఇప్పటికే అనుభవించి ఉంటారు. AIకి జ్ఞాపకశక్తి తక్కువ అని అనుకోవడం సులభం. కానీ వాస్తవానికి, మీరు కాంటెక్స్ట్ విండో (context window) యొక్క కఠినమైన పరిమితులను చేరుకున్నారు.
నమ్మదగిన మరియు వేగంగా స్పందించే వ్యవస్థలను నిర్మించడానికి, మీరు మూడు ప్రాథమిక అంశాలను అర్థం చేసుకోవాలి: టోకెన్లు (tokens), కాంటెక్స్ట్ విండోలు (context windows), మరియు కాంటెక్స్ట్ మరియు మెమరీ మధ్య తేడా.
టోకెన్లే అసలైన కరెన్సీ
టోకెన్ అంటే ఒక పదం కాదు. మీరు ఒక మోడల్కు టెక్స్ట్ను పంపినప్పుడు, ఒక టోకెనైజర్ (tokenizer) దానిని చిన్న చిన్న ముక్కలుగా విడగొడుతుంది. "cat" లేదా "the" వంటి చిన్న సాధారణ పదాలు ఒక్కో టోకెన్ను నింపవచ్చు. "internationalization" వంటి క్లిష్టమైన సాంకేతిక పదం అనేక ముక్కలుగా విడగొట్టబడుతుంది. విరామ చిహ్నాలు (punctuation), ఖాళీలు (spaces) మరియు ప్రత్యేక అక్షరాలు కూడా లెక్కించబడతాయి. ఇది చాలా ముఖ్యం ఎందుకంటే టోకెన్లు అన్నింటినీ నియంత్రిస్తాయి: మీ API బిల్లు, స్పందన వేగం మరియు అవుట్పుట్ నాణ్యత.
పదాలను లెక్కించడం ద్వారా ఖర్చులను అంచనా వేసే డెవలపర్ తప్పుదారి పడుతున్నట్లే. కోడ్ బ్రాకెట్లు మరియు పొడవైన వేరియబుల్ పేర్లతో కూడిన వంద పదాల ప్రాంప్ట్, అంచనా వేసిన దానికంటే చాలా ఎక్కువ టోకెన్లను వినియోగించవచ్చు. అందుకే టోకెనైజర్లు ప్రత్యేక సాధనాలుగా అందుబాటులో ఉన్నాయి. మీరు ఒక ఫీచర్ను విడుదల చేసే ముందు, మీ సాధారణ పేలోడ్లను (payloads) వాటి ద్వారా పరీక్షించండి. సిస్టమ్ సూచనలు (system instructions), ఫార్మాటింగ్ బాయిలర్ప్లేట్ (formatting boilerplate) మరియు చాట్ హిస్టరీ, అసలు యూజర్ క్వెరీ కంటే మీ బడ్జెట్ను ఎక్కువగా ఖర్చు చేస్తాయని మీరు తరచుగా గమనిస్తారు. మొదటి రోజు నుంచే టోకెన్లను ఒక పరిమిత వనరుగా పరిగణించండి.
కాంటెక్స్ట్ విండో అనేది ఒక స్థిరమైన వైట్బోర్డ్ వంటిది
కాంటెక్స్ట్ విండో అనేది ఒకే రిక్వెస్ట్లో మోడల్ చూడగలిగే మొత్తం సమాచారం. దీనిని నిర్ణీత పరిమాణం కలిగిన ఒక వైట్బోర్డ్గా భావించండి. మీరు దీనిని సిస్టమ్ నియమాలు, సంభాషణ చరిత్ర, సేకరించిన పత్రాలు మరియు ప్రస్తుత ప్రశ్నతో నింపవచ్చు. కానీ వైట్బోర్డ్ నిండిపోయిన తర్వాత, ఏదో ఒకటి తగ్గించాల్సి ఉంటుంది. పాత నోట్స్ను తొలగించాలి, వాటిని ఫోటో తీసి సారాంశం చేయాలి, లేదంటే బోర్డు నిండిపోయి సమాచారం కోల్పోతుంది.
ఆధునిక మోడల్స్ కొన్ని వేల నుండి వందల వేల టోకెన్ల వరకు ఉండే కాంటెక్స్ట్ విండోలను అందిస్తున్నాయి. పెద్ద విండో ఉంటే అది అపరిమితమైన స్టోరేజ్ అని అనుకోవడం సహజం. కానీ అది నిజం కాదు. వైట్బోర్డ్కు కూడా అంచులు ఉంటాయి. హిస్టరీ పరిమితిని మించినప్పుడు, అప్లికేషన్ పాత మెసేజ్లను తొలగించాలి లేదా వాటిని కంప్రెస్ (compress) చేయాలి. ఈ పరిమితిని అర్థం చేసుకోవడం వల్ల, మీరు విండోను డేటాబేస్లా కాకుండా, ఒక యాక్టివ్ వర్క్స్పేస్లా (active workspace) చూడటం ప్రారంభిస్తారు.
కాంటెక్స్ట్ అంటే మెమరీ కాదు
అనుభవజ్ఞులైన బిల్డర్లను కూడా అయోమయానికి గురిచేసే విషయం ఇది. మోడల్ స్వతహాగా 'స్టేట్లెస్' (stateless). ఇది నిన్నటి గురించి, గత వారం గురించి లేదా వేరే సెషన్లో పది నిమిషాల క్రితం మీరు చెప్పిన దాని గురించి గుర్తుంచుకోదు. మీకు JavaScript కంటే Python ఇష్టమని లేదా మీకు క్లుప్తమైన సమాధానాలు కావాలని AI గుర్తుంచుకున్నట్లు అనిపిస్తే, ఆ మెమరీ అప్లికేషన్ లేయర్లో (application layer) ఉంటుంది, మోడల్లో కాదు.
అప్లికేషన్ ఆ వాస్తవాలను డేటాబేస్, క్యాష్ (cache) లేదా మెమరీ స్టోర్లో భద్రపరుస్తుంది. ప్రతి కొత్త రిక్వెస్ట్పై, అది సంబంధిత ప్రొఫైల్ డేటాను తిరిగి ప్రాంప్ట్లోకి ఇంజెక్ట్ చేస్తుంది. మోడల్ కేవలం మొదటి అంకం నుండి తన డైలాగులతో కూడిన స్క్రిప్ట్ను చదువుతున్నట్లు మాత్రమే అన్నమాట. దానికి స్వంతంగా శాశ్వత జ్ఞాపకశక్తి ఉండదు. ఈ వ్యత్యాసాన్ని మీరు అర్థం చేసుకున్న తర్వాత, మీ ఆర్కిటెక్చర్ మారుతుంది. మీరు మోడల్ను గుర్తుంచుకోమని అడగడం మానేసి, సరైన సమయంలో సరైన కాంటెక్స్ట్ను తీసుకువచ్చే వ్యవస్థలను రూపొందించడం ప్రారంభిస్తారు.
ఎక్కువ కాంటెక్స్ట్ ఎందుకు వికటించవచ్చు
ఎక్కువ బ్యాక్గ్రౌండ్ సమాచారం ఉంటే మెరుగైన సమాధానాలు వస్తాయని సాధారణంగా అనుకుంటాం. కానీ తరచుగా దానికి విరుద్ధంగా జరుగుతుంది. అతిగా కాంటెక్స్ట్ ఇవ్వడం వల్ల 'నాయిస్' (noise) పెరుగుతుంది. మీకు కేవలం ఒక ఫంక్షన్ మాత్రమే సరిచేయాల్సి ఉన్నప్పుడు, మీరు మోడల్కు మొత్తం కోడ్బేస్ను ఇస్తే, అది అనవసరమైన సమాచారం (static) మధ్యలో అసలైన సమాచారాన్ని (signal) వెతకాల్సి వస్తుంది. పరిశోధకులు "Lost in the Middle" ప్రభావాన్ని గుర్తించారు: మోడల్స్ తరచుగా ప్రాంప్ట్ యొక్క ప్రారంభం మరియు చివరి భాగంలోని వివరాలపై ఎక్కువ దృష్టి పెడతాయి, కానీ మధ్యలో ఉన్న సమాచారం తక్కువగా పరిగణించబడుతుంది లేదా విస్మరించబడుతుంది. ఇది మీరు తెలివైన పదాలతో సరిదిద్దగలిగే బగ్ కాదు. ఇది ట్రాన్స్ఫార్మర్-ఆధారిత (transformer-based) ఆర్కిటెక్చర్లలో ఉండే ఒక నిర్మాణాత్మక ప్రవర్తన.
అనవసరమైన సమాచారంతో కూడిన ప్రాంప్ట్లు మీ ఖర్చులను కూడా పెంచుతాయి. ప్రతి అదనపు టోకెన్కు కంప్యూటేషన్ అవసరం. దీనివల్ల లేటెన్సీ (latency) పెరుగుతుంది, ఖర్చులు పెరుగుతాయి మరియు యూజర్ ఓపిక తగ్గుతుంది. సంబంధం లేని పత్రాలతో నిండిన ప్రాంప్ట్ పరస్పర విరుద్ధమైన అంశాలను తీసుకువస్తుంది, మోడల్ను పక్కదారి పట్టిస్తుంది మరియు సమాధానం తప్పు సమస్యపై దృష్టి పెట్టేలా చేస్తుంది. పరిమాణం (Volume) అనేది ఖచ్చితత్వానికి (precision) శత్రువు.
మెరుగైన కాంటెక్స్ట్ను ఎలా ఇంజనీర్ చేయాలి
మంచి కాంటెక్స్ట్ ఇంజనీరింగ్ అనేది అనవసరమైన వాటిని తొలగించే (ruthless editing) ప్రక్రియ. దానిని ఆచరణలో పెట్టడం ఎలాగో ఇక్కడ చూడండి.
టాస్క్కు అవసరమైన దానిని మాత్రమే పంపండి. ఒక వినియోగదారు మీ రీఫండ్ పాలసీ గురించి అడిగితే, ఎంప్లాయీ హ్యాండ్బుక్, API డాక్యుమెంటేషన్ మరియు గత త్రైమాసిక మార్కెటింగ్ కాపీని చేర్చకండి. సమగ్రత కంటే సందర్భోచితత ముఖ్యం.
సంబంధిత పత్రాలను పొందడానికి RAGని ఉపయోగించండి. Retrieval-Augmented Generation అనేది మీరు ఒక పెద్ద నాలెడ్జ్ బేస్ను శోధించడానికి మరియు అత్యంత సరిపోలే పేరాగ్రాఫ్లను మాత్రమే ప్రాంప్ట్లోకి పంపడానికి అనుమతిస్తుంది. వేల పేజీల మాన్యువల్ను విండోలోకి పంపే బదులు, మీరు మీ పత్రాలను ఎంబెడ్ చేసి, వినియోగదారు యొక్క క్వెరీ ఆధారంగా సెమాంటిక్ సెర్చ్ నిర్వహించి, అత్యంత సంబంధిత మూడు పేరాగ్రాఫ్లను మాత్రమే చేర్చవచ్చు. దీనివల్ల మోడల్కు ఖచ్చితంగా అవసరమైన సమాచారం అందుతుంది మరియు మీ టోకెన్ బడ్జెట్ కూడా ఆదా అవుతుంది.
పాత సంభాషణలను సారాంశం చేయండి. పూర్తి చాట్ ట్రాన్స్క్రిప్ట్లు ఖరీదైనవి మరియు గందరగోళంగా ఉంటాయి. సుదీర్ఘమైన మెసేజ్ హిస్టరీలకు బదులుగా నిరంతర సారాంశాలను (running summaries) ఉపయోగించండి. ఉదాహరణకు, మోడల్కు ముప్పై మెసేజ్లను పంపే బదులు, ఒకే ఒక పేరాగ్రాఫ్ను నిల్వ చేయండి: "వినియోగదారు Django deployment గురించి అడిగారు, static files error ఎదురైంది మరియు permissions సరిచేశారు. ప్రస్తుత సమస్య Postgres 14లో database migration విఫలం కావడం." ఈ సారాంశం వైట్బోర్డ్ను గందరగోళపరచకుండా స్టేట్ను కాపాడుతుంది.
లాంగ్-టర్మ్ మెమరీని యాక్టివ్ చాట్ నుండి వేరు చేయండి. యూజర్ ప్రిఫరెన్స్లు, ప్రాజెక్ట్ సెట్టింగ్లు మరియు అకౌంట్ హిస్టరీ వంటివి ఎక్స్టర్నల్ మెమరీ స్టోర్లో ఉండాలి. ఆ స్టోర్ను ఎంపిక చేసిన విధంగా మాత్రమే క్వెరీ చేయండి. లైవ్ కాంటెక్స్ట్ విండోలో కేవలం ప్రస్తుత టాస్క్ మరియు కొనసాగింపు కోసం అవసరమైన అతి తక్కువ వ్యక్తిగత సమాచారం మాత్రమే ఉండాలి.
ప్రొడక్షన్లో టోకెన్ వినియోగాన్ని పర్యవేక్షించండి. లేటెన్సీ పెరుగుదల (Latency spikes) తరచుగా కాంటెక్స్ట్ పెరగడం వల్ల జరుగుతుంది. రిక్వెస్ట్లు మీ మోడల్ పరిమితికి చేరువవుతున్నప్పుడు అలర్ట్లను సెట్ చేయండి. అనవసరమైన సమాచారాన్ని కలిగి ఉన్న ప్రాంప్ట్లను గుర్తించడానికి లాగ్లను సమీక్షించండి. ఆప్టిమైజేషన్ ఎప్పుడూ ఒకే ప్రశ్నతో మొదలవుతుంది: టాస్క్కు అంతరాయం కలగకుండా మనం దేనిని తొలగించవచ్చు?
అసలైన సారాంశం
ఉత్తమ AI అప్లికేషన్లు పెద్ద కాంటెక్స్ట్ విండోలను కలిగి ఉన్నందున గెలువవు. అవి కాంటెక్స్ట్ను క్రమశిక్షణతో నిర్వహించడం వల్ల గెలుస్తాయి. ఒక వైట్బోర్డ్ అంతా గీతలు గీసి ఉంటే, అది ఎంత పెద్దదైనా ఉపయోగం ఉండదు. సమాచారాన్ని వెలికితీసే (retrieve), సారాంశం చేసే (summarize) మరియు ఫిల్టర్ చేసే వ్యవస్థలను నిర్మించండి. దీనివల్ల మీ వినియోగదారులకు వేగవంతమైన సమాధానాలు అందుతాయి, మీ ఇన్ఫ్రాస్ట్రక్చర్ ఖర్చులు అంచనా వేయదగినవిగా ఉంటాయి మరియు మీ మోడల్లు చివరికి నిజంగా ముఖ్యమైన అంశాలపై దృష్టి పెడతాయి.
మూలం: AI Context Engineering: Tokens, Context Windows, & Memory
కమ్యూనిటీ: GyaanSetu AI on Telegram