ಏಜೆಂಟ್ ಮೆಮೊರಿಯನ್ನು ಪ್ರಾಂಪ್ಟ್ಗೆ ಸುರಿಯುವುದನ್ನು ನಿಲ್ಲಿಸಿ
ಹೆಚ್ಚಿನ ಅಭಿವರ್ಧಕರು ಮುಂದಿನ ಪ್ರಾಂಪ್ಟ್ಗೆ ಎಲ್ಲವನ್ನೂ ಸೇರಿಸುವ ಮೂಲಕ ಏಜೆಂಟ್ ಲೂಪ್ಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತಾರೆ.
ನೀವು ಹಿಂದಿನ ವೀಕ್ಷಣೆಗಳು, ಟೂಲ್ ಕರೆಗಳು (tool calls) ಮತ್ತು ತಾರ್ಕಿಕ ಹಾದಿಗಳನ್ನು (reasoning traces) ಸೇರಿಸುತ್ತೀರಿ. ಪ್ರಾಂಪ್ಟ್ ಒಂದು ಕಸದ ಡಬ್ಬದಂತೆ (junk drawer) ಆಗುವವರೆಗೆ ನೀವು ಡೇಟಾವನ್ನು ಸೇರಿಸುತ್ತಲೇ ಇರುತ್ತೀರಿ. ಮಾಡೆಲ್ ಹೆಚ್ಚು ಮಾಹಿತಿಯನ್ನು ನೋಡುತ್ತದೆ, ಆದರೆ ನೀವು ನಿಯಂತ್ರಣವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ. ಯಾವ ನೆನಪಿನ ತುಣುಕಿನಿಂದ ನಿರ್ದಿಷ್ಟ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳಲ್ಪಟ್ಟಿತು ಎಂಬುದು ನಿಮಗೆ ತಿಳಿಯುವುದಿಲ್ಲ.
AgenticSTS ಎಂಬ ಹೊಸ ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ವಿಭಿನ್ನ ಹಾದಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಇದು ಮೆಮೊರಿಯನ್ನು ಕೇವಲ ದೊಡ್ಡ ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ (context window) ಗಾಗಿ ಮಾಡುವ ಸ್ಪರ್ಧೆಯಾಗಿ ನೋಡದೆ, ಒಂದು ಇಂಟರ್ಫೇಸ್ (interface) ಆಗಿ ಪರಿಗಣಿಸುತ್ತದೆ.
ಈ ಪ್ರಬಂಧವು Slay the Spire 2 ಆಟವನ್ನು ಪರೀಕ್ಷಾ ವೇದಿಕೆಯಾಗಿ ಬಳಸುತ್ತದೆ. ಈ ಪರಿಸರವು ನೂರಾರು ಕಾರ್ಯತಂತ್ರದ ನಿರ್ಧಾರಗಳನ್ನು ಬಯಸುತ್ತದೆ. ಇದು ಕೇವಲ ಒಂದು ಸರಳ ಚಾಟ್ಬಾಟ್ ಅಲ್ಲ.
ಇದರ ಮೂಲ ಪರಿಕಲ್ಪನೆಯೆಂದರೆ: ಮೆಮೊರಿ ಎಂಬುದು ಭವಿಷ್ಯದ ನಿರ್ಧಾರವು ಏನನ್ನು ನೋಡಲು ಅನುಮತಿಸಲಾಗಿದೆ ಎಂಬುದರ ಕುರಿತಾದ ಒಪ್ಪಂದವಾಗಿದೆ.
ಕಚ್ಚಾ ಟ್ರಾನ್ಸ್ಕ್ರಿಪ್ಟ್ಗಳ ಬದಲಿಗೆ, ಲೇಖಕರು ಐದು ನಿರ್ದಿಷ್ಟ ಪದರಗಳನ್ನು (layers) ಬಳಸಿ ಹೊಸ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ರೂಪಿಸುತ್ತಾರೆ:
- ಸ್ಥಿರ ಪ್ರೋಟೋಕಾಲ್ ಸೂಚನೆಗಳು (Fixed protocol instructions)
- ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ ಮತ್ತು ಕ್ರಿಯೆಯ ಸ್ಕೀಮಾಗಳು (Current state and action schemas)
- ಪಡೆದ ಆಟದ ನಿಯಮಗಳು (Retrieved game rules)
- ಹಿಂದಿನ ರನ್ಗಳ ಸಾರಾಂಶಗಳು (Summaries from prior runs)
- ಪ್ರಚೋದಿತ ಕಾರ್ಯತಂತ್ರದ ಕೌಶಲಗಳು (Triggered strategic skills)
ಈ ರಚನೆಯು ಎಲ್ಲವನ್ನೂ ಬದಲಾಯಿಸುತ್ತದೆ. ನೀವು ಪ್ರತಿಯೊಂದು ಪದರವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು, ಸ್ಥಗಿತಗೊಳಿಸಬಹುದು ಅಥವಾ ಅಸಕ್ರಿಯಗೊಳಿಸಬಹುದು. ನೀವು ಮೆಮೊರಿಯನ್ನು ಕೇವಲ ಡೇಟಾದ ರಾಶಿಯಿಂದ ಆಯ್ದ ಪುರಾವೆಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತೀರಿ.
ಅನೇಕ ಪ್ರೊಡಕ್ಷನ್ ಏಜೆಂಟ್ ವೈಫಲ್ಯಗಳು ಮಾಡೆಲ್ ವೈಫಲ್ಯಗಳಲ್ಲ. ಅವು ಕಾಂಟೆಕ್ಸ್ಟ್ ವೈಫಲ್ಯಗಳು. ಏಜೆಂಟ್ ಹಳೆಯ ಸ್ಥಿತಿಯನ್ನು ಹೊಸ ಸ್ಥಿತಿಯೊಂದಿಗೆ ಬೆರೆಸುತ್ತದೆ ಅಥವಾ ಹಳೆಯ ಪ್ರತಿಫಲನಗಳನ್ನು (reflections) ಮುಂದೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ. ನಿಮ್ಮ ಏಕೈಕ ನೀತಿಯು ಕೇವಲ ಹೆಚ್ಚಿನ ಪಠ್ಯವನ್ನು ಸೇರಿಸುವುದಾಗಿದ್ದರೆ, ડીಬಗ್ ಮಾಡುವುದು ಪುರಾತತ್ವ ಶಾಸ್ತ್ರದಂತೆ (archaeology) ಭಾಸವಾಗುತ್ತದೆ.
ಟೈಪ್ ಮಾಡಿದ ಮೆಮೊರಿ ಇಂಟರ್ಫೇಸ್ ನಿಮಗೆ ಹೋಲಿಕೆ ಮಾಡಲು ಏನನ್ನಾದರೂ ನೀಡುತ್ತದೆ.
ದೀರ್ಘಕಾಲದ ಏಜೆಂಟ್ಗಳಿಗೆ, ದೊಡ್ಡ ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಒಂದು ಬಲೆ. ಇದು ಸತ್ಯಗಳು, ಹಳೆಯ ಸತ್ಯಗಳು ಮತ್ತು ವಿಫಲ ಪ್ರಯತ್ನಗಳ ಮಿಶ್ರಣವಾಗುತ್ತದೆ. ವಿಂಡೋ ಎಷ್ಟು ದೊಡ್ಡದಿದೆಯೋ, ಅಷ್ಟು ಸುಲಭವಾಗಿ ಕೆಸರನ್ನು (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