ನನ್ನ ಕೋಡಿಂಗ್ ಏಜೆಂಟ್ ಸೆಷನ್ಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಂಡಿತು, ಕೆಲಸವನ್ನಲ್ಲ
ಒಂದು ಕೋಡಿಂಗ್ ಏಜೆಂಟ್ ಸಂಭಾಷಣೆಯ ದಾರಿಯನ್ನು (thread) ಜೀವಂತವಾಗಿಡಬಹುದು, ಆದರೂ ಅದು ಮರೆಗುಳಿತನದಿಂದ ಕೂಡಿದಂತೆ ಅನಿಸಬಹುದು.
CliGate ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ ನಾನು ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದೆ. ನಾನು ಸೆಷನ್ ನಿರಂತರತೆಯನ್ನು (session continuity) ಸರಿಪಡಿಸಿದೆ, ಆದರೆ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳು ನಿಧಾನವಾಗಿಯೇ ಇದ್ದವು.
ಏಜೆಂಟ್ ಸಂಭಾಷಣೆಯನ್ನು ನೆನಪಿಟ್ಟುಕೊಂಡಿತು, ಆದರೆ ಕೆಲಸವನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲಿಲ್ಲ.
ಸೆಷನ್ ನಿರಂತರತೆಯು ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದು ಈ ಕೆಳಗಿನಂತಹ ಅನುಸರಣಾ ಆದೇಶಗಳನ್ನು (follow-up commands) ಅನುಮತಿಸುತ್ತದೆ:
- continue (ಮುಂದುವರಿಸು)
- do the same for this file (ಇದೇ ಕೆಲಸವನ್ನು ಈ ಫೈಲ್ಗೂ ಮಾಡು)
- retry that (ಅದನ್ನು ಮತ್ತೆ ಪ್ರಯತ್ನಿಸು)
- explain the error (ದೋಷವನ್ನು ವಿವರಿಸು)
ಇದು ಕೆಲಸದ ಹರಿವಿಗೆ (flow) ಮುಖ್ಯವಾಗುತ್ತದೆ. ಆದರೆ ನೀವು ಕೆಲವು ದಿನಗಳ ನಂತರ ಅದೇ ಕೆಲಸದ ಕ್ರಮವನ್ನು (workflow) ಪುನರಾವರ್ತಿಸಿದಾಗ ಇದು ವಿಫಲವಾಗುತ್ತದೆ.
ಯಾವ ಬಟನ್ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಅಥವಾ ಯಾವ ಹಂತವು ಅಡೆತಡೆ (dead end) ಎಂಬುದು ಏಜೆಂಟ್ಗೆ ತಿಳಿದಿದ್ದರೆ, ಕೇವಲ ಒಂದು ತೆರೆದ ಸೆಷನ್ ಸಾಕಾಗುವುದಿಲ್ಲ. ಹಿಂದಿನ ಪ್ರಯತ್ನವು ಏಕೆ ಯಶಸ್ವಿಯಾಯಿತು ಎಂಬುದನ್ನು ಏಜೆಂಟ್ ನೆನಪಿಸಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ.
ಮೊದಲ ಪ್ರಯತ್ನವು ಅತ್ಯಂತ ವೆಚ್ಚದಾಯಕವಾಗಿರುತ್ತದೆ. ಆಗಲೇ ಏಜೆಂಟ್ ಸಣ್ಣ ವಿವರಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ:
- ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೆನುವಿನಲ್ಲಿ ಕ್ರಿಯೆಯು ಅಡಗಿದೆ
- ಎಡಿಟರ್ ಒಂದು iframe ಆಗಿದೆ
- ಒಂದು ಪ್ರಾಜೆಕ್ಟ್ಗೆ ನಿರ್ದಿಷ್ಟ ಪ್ರತಿಕ್ರಿಯೆಯ ಶೈಲಿಗಳು ಬೇಕಾಗುತ್ತವೆ
- ಎನ್ವಿರಾನ್ಮೆಂಟ್ URL ಪ್ರೊಡಕ್ಷನ್ನಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ
ನನ್ನ ಪರಿಹಾರದ ಮೊದಲು, ಈ ವಿವರಗಳು ಕೇವಲ ರಾಗ್ ಲಾಗ್ಗಳಾಗಿದ್ದವು (raw logs). ಏಜೆಂಟ್ಗೆ ಇತಿಹಾಸವಿತ್ತು, ಆದರೆ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ನೆನಪಿನ ಶಕ್ತಿ ಇರಲಿಲ್ಲ. ಅದು ಪ್ರತಿ ಬಾರಿಯೂ ಅದೇ ಸತ್ಯಗಳನ್ನು ಮರುಶೋಧಿಸಬೇಕಾಗುತ್ತಿತ್ತು. ಅದು ಬುದ್ಧಿವಂತಿಕೆಯಲ್ಲ. ಅದು ಒಂದೇ ವೆಚ್ಚವನ್ನು ಎರಡು ಬಾರಿ ಪಾವತಿಸಿದಂತೆ.
ಹೆಚ್ಚಿನ ಇತಿಹಾಸವನ್ನು ಉಳಿಸಿ, ಮಾಡೆಲ್ ಅದನ್ನು ಬಳಸುತ್ತದೆ ಎಂದು ಭಾವಿಸುವುದು ತಪ್ಪು ವಿಧಾನವಾಗಿದೆ. ಇದು ಗೊಂದಲವನ್ನು (noise) ಸೃಷ್ಟಿಸುತ್ತದೆ.
ನನಗೆ ಸಣ್ಣದಾದ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಪದರ (layer) ಅಗತ್ಯವಿತ್ತು. ನಾನು ಎಲ್ಲವನ್ನೂ ಉಳಿಸುವುದರಿಂದ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಉಳಿಸುವುದಕ್ಕೆ ಬದಲಾಯಿಸಿದೆ:
- procedures (ಪ್ರಕ್ರಿಯೆಗಳು): ಅತ್ಯುತ್ತಮ ಹಂತಗಳು ಮತ್ತು ತಿಳಿದಿರುವ ಅಡೆತಡೆಗಳು
- facts (ಸತ್ಯಗಳು): URLಗಳು, ನಿಯಮಗಳು ಅಥವಾ ಸೆಟ್ಟಿಂಗ್ಗಳು
- directives (ನಿರ್ದೇಶನಗಳು): ಕೆಲಸಗಳನ್ನು ನೀವು ಹೇಗೆ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ ಎಂಬುದು
- references (ಉಲ್ಲೇಖಗಳು): ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಎಲ್ಲಿದೆ ಎಂಬುದು
ಇದು ವ್ಯವಸ್ಥೆಯನ್ನು ಬದಲಾಯಿಸಿತು. ಒಂದು ಬೃಹತ್ ಸಂಭಾಷಣೆಯ ದಾಖಲೆಯನ್ನು (transcript) ಓದುವ ಬದಲು, ಅಸಿಸ್ಟೆಂಟ್ ಫೈಲ್ ಆಧಾರಿತ ಮೆಮೊರಿ ಪದರವನ್ನು ಬಳಸುತ್ತದೆ.
ಇಂಟರ್ಫೇಸ್ಗಳು ಬದಲಾಗುತ್ತವೆ ಮತ್ತು ಬಟನ್ಗಳು ಚಲಿಸುತ್ತಿರುತ್ತವೆ ಎಂಬ ಕಾರಣದಿಂದ ನನಗೆ ಪರಿಪೂರ್ಣವಾದ ಮರುಕಳಿಸುವಿಕೆ (replay) ಬೇಕಾಗಿರಲಿಲ್ಲ. ನನಗೆ ಒಂದು ಲೂಪ್ (loop) ಬೇಕಿತ್ತು:
- ಹಿಂದಿನ ಅತ್ಯುತ್ತಮ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ
- ಮೊದಲು ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ
- ಪ್ರತಿ ಹಂತವನ್ನು ಪರಿಶೀಲಿಸಿ
- ಅದು ವಿಫಲವಾದರೆ, ಮತ್ತೆ ಅನ್ವೇಷಣೆಗೆ ಹಿಂತಿರುಗಿ
- ಯಶಸ್ವಿಯಾದ ನಂತರ ನೆನಪಿನ ಶಕ್ತಿಯನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಿ
ನಾನು ಸ್ಥಿರ ನಿಯಮಗಳನ್ನು (standing rules) ಸೆಷನ್ ಇತಿಹಾಸದಿಂದ ಪ್ರತ್ಯೇಕಿಸಿದೆ. "ಪ್ರೊಡಕ್ಷನ್ ಡೇಟಾವನ್ನು ಮುಟ್ಟಬೇಡಿ" ಎಂಬಂತಹ ನಿಯಮಗಳು ಸಂಭಾಷಣೆಯ ಸಂದರ್ಭಗಳಲ್ಲ (context). ಅವು ಕಾರ್ಯಾಚರಣೆಯ ನಿಯಮಗಳು (operating rules). ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು ಅಸಿಸ್ಟೆಂಟ್ ಅನ್ನು ಊಹಿಸಬಹುದಾದಂತೆ (predictable) ಮಾಡುತ್ತದೆ.
ಫಲಿತಾಂಶ: ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳು ಸಂಕ್ಷಿಪ್ತವಾದವು. ಅಸಿಸ್ಟೆಂಟ್ ವೇಗವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಖಾಲಿ ತಾಂತ್ರಿಕ ಮಾದರಿಯೊಂದಿಗೆ (empty tactical model) ಪ್ರಾರಂಭಿಸುವುದಿಲ್ಲ.
ನೀವು ಕೋಡಿಂಗ್ ಏಜೆಂಟ್ಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದರೆ, ಸಂಭಾಷಣೆಯ ದಾರಿಯನ್ನು (thread) ಕಲಿಕೆಯೊಂದಿಗೆ ಗೊಂದಲ ಮಾಡಿಕೊಳ್ಳಬೇಡಿ.
- ಸೆಷನ್ ನಿರಂತರತೆಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ಮೆಮೊರಿ ಪುನರಾವರ್ತಿತ ಕೆಲಸಕ್ಕೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಸೆಷನ್ ಸಂಭಾಷಣೆಯನ್ನು ಜೀವಂತವಾಗಿಡುತ್ತದೆ. ಮೆಮೊರಿ ಪದರವು ಕಲಿಕೆಗಳನ್ನು ಜೀವಂತವಾಗಿಡುತ್ತದೆ.
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯು ಸಂಭಾಷಣೆಯ ದಾರಿಯನ್ನು ನೆನಪಿಡುತ್ತಿದೆಯೇ ಅಥವಾ ಯಶಸ್ವಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನೆನಪಿಡುತ್ತಿದೆಯೇ?
Source: https://dev.to/codekingai/my-coding-agent-remembered-sessions-not-work-that-was-the-bug-2fig