ಟರ್ಮಿನಲ್ AI ಗಾಗಿ ಸ್ವಯಂ-ಅಪ್ಡೇಟ್ ಆಗುವ ಜ್ಞಾನ ಕೋಶ
ನಾನು ನನ್ನ ದಿನದ ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು AI ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ನೊಂದಿಗೆ ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಕಳೆಯುತ್ತೇನೆ.
ಒಂದು ಸೆಷನ್ನಲ್ಲಿ ನಾನು ಆಗಾಗ್ಗೆ ಕಠಿಣ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತೇನೆ. ಒಂದು ಸಂಕೀರ್ಣವಾದ ಪರಿಹಾರ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಕಾನ್ಫಿಗರೇಶನ್ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ನಾನು ಕಂಡುಕೊಳ್ಳುತ್ತೇನೆ. ನಂತರ ನಾನು ಟ್ಯಾಬ್ ಅನ್ನು ಮುಚ್ಚಿದಾಗ ಆ ಜ್ಞಾನವು ಮಾಯವಾಗುತ್ತದೆ. ಒಂದು ತಿಂಗಳ ನಂತರ, ನಾನು ಅದೇ ಸಮಸ್ಯೆಯನ್ನು ಮತ್ತೆ ಪರಿಹರಿಸಬೇಕಾಗುತ್ತದೆ.
Claude Code hooks ಬಳಸಿ ನನ್ನ ಅಸಿಸ್ಟೆಂಟ್ ತನ್ನದೇ ಆದ ನೋಟ್ಸ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವಂತೆ ಮಾಡಲು ನಾನು ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೇನೆ.
ಈ ವ್ಯವಸ್ಥೆಯು ಮೂರು ಭಾಗಗಳನ್ನು ಬಳಸುತ್ತದೆ:
- ಸಂದರ್ಭವನ್ನು (context) ಒದಗಿಸಲು ಪ್ರತಿ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ ಸಣ್ಣ ಮಾರ್ಕ್ಡೌನ್ ಜ್ಞಾನ ಕೋಶವನ್ನು ಹುಡುಕುವುದು.
- ಸೆಷನ್ ಮುಗಿದಾಗ ಉಪಯುಕ್ತ ನೋಟ್ಸ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು.
- ಸೆಷನ್ ಪ್ರಾರಂಭವಾದಾಗ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವುದು.
ನಿಮ್ಮ ಕೆಲಸದ ವೇಗವನ್ನು ಕಡಿಮೆ ಮಾಡದೆ ಇದನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ.
1. ರಿಟ್ರಿವಲ್ ಗಾಗಿ UserPromptSubmit ಬಳಸಿ
ನೀವು ಪ್ರಾಂಪ್ಟ್ ಕಳುಹಿಸುವ ಪ್ರತಿ ಬಾರಿಯೂ ಈ ಹೂಕ್ (hook) ಚಲಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಪಠ್ಯವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಮಾಡೆಲ್ ಪ್ರತಿಕ್ರಿಯಿಸುವ ಮೊದಲು ಸಂದರ್ಭವನ್ನು ಸೇರಿಸಬಹುದು.
ನೋಟ್ಸ್ಗಳನ್ನು ಯಾವಾಗ ನೋಡಬೇಕು ಎಂದು ಮಾಡೆಲ್ ನಿರ್ಧರಿಸಲು ಬಿಡಬೇಡಿ. ಸಂಬಂಧಿತ ಫೈಲ್ಗಳನ್ನು ಹುಡುಕಲು grep ನಂತಹ ವೇಗದ ಸರ್ಚ್ ವಿಧಾನವನ್ನು ಬಳಸಿ. ಕೇವಲ ಟಾಪ್ ಐದು ಫಲಿತಾಂಶಗಳನ್ನು ಮಾತ್ರ ಸೇರಿಸಿ. ಇದು ಪ್ರಕ್ರಿಯೆಯನ್ನು 100ms ಗಿಂತ ಕಡಿಮೆ ಇಡುತ್ತದೆ.
ಸರ್ಚ್ ಹೂಕ್ಗಳಿಗಾಗಿ ಎರಡು ನಿಯಮಗಳು:
- ಇದನ್ನು ಅಗ್ಗವಾಗಿಡಿ. ಆರಂಭಿಕ ಹುಡುಕಾಟಕ್ಕಾಗಿ LLM ಬದಲಿಗೆ grep ಬಳಸಿ.
- ಇದನ್ನು ಸರಳವಾಗಿಡಿ. ಕೇವಲ ಶೀರ್ಷಿಕೆಗಳು ಮತ್ತು ಫೈಲ್ ಪಥಗಳನ್ನು (file paths) ಮಾತ್ರ ಸೇರಿಸಿ. ಹೆಚ್ಚಿನ ವಿವರ ಬೇಕಾದಲ್ಲಿ ಮಾಡೆಲ್ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಬಹುದು.
2. ಭಾರೀ ಕೆಲಸಗಳಿಗಾಗಿ Stop hook ಅನ್ನು ತಪ್ಪಿಸಿ
ಅಸಿಸ್ಟೆಂಟ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ಪ್ರತಿ ಬಾರಿಯೂ Stop hook ಚಲಿಸುತ್ತದೆ. ನೀವು ಇಲ್ಲಿ ದೀರ್ಘವಾದ ಕೆಲಸವನ್ನು ಮಾಡಿದರೆ, ನಿಮ್ಮ ಅಸಿಸ್ಟೆಂಟ್ ನಿಧಾನವಾಗುತ್ತದೆ. 30-ಟರ್ನ್ ಸೆಷನ್ 30 ಭಾರೀ ಕೆಲಸಗಳನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ.
ಬದಲಾಗಿ, ಸಂಪೂರ್ಣ ಸೆಷನ್ ಅನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಸೆರೆಹಿಡಿಯಲು SessionEnd ಬಳಸಿ.
3. SessionEnd ಮಿತಿಯನ್ನು ಪರಿಹರಿಸಿ
SessionEnd ಎಂಬುದು ನಾನ್-ಬ್ಲಾಕಿಂಗ್ (non-blocking). ನೀವು ಇಲ್ಲಿ ದೀರ್ಘವಾದ ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ, ಸೆಷನ್ ಮುಕ್ತಾಯಗೊಂಡಾಗ ಸಿಸ್ಟಮ್ ಅದನ್ನು ಕೊಲ್ಲಬಹುದು.
ಇದಕ್ಕೆ ಪರಿಹಾರವೆಂದರೆ ಎರಡು ಹೂಕ್ಗಳನ್ನು ಬಳಸುವುದು:
- SessionEnd: ಟ್ರಾನ್ಸ್ಕ್ರಿಪ್ಟ್ ಪಥವನ್ನು (transcript path) ವೇಗವಾಗಿ ಕ್ಯೂ ಫೈಲ್ಗೆ (queue file) ಸೇರಿಸಿ.
- SessionStart: ಆ ಕ್ಯೂ ಅನ್ನು ಖಾಲಿ ಮಾಡಿ ಮತ್ತು ಭಾರೀ ಕ್ಯಾಪ್ಚರ್ ಕೆಲಸವನ್ನು ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ನಲ್ಲಿ ಚಲಾಯಿಸಿ.
ಮುಂದಿನ ಸೆಷನ್ ಸಕ್ರಿಯವಾಗಿರುವುದರಿಂದ, ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಪ್ರಕ್ರಿಯೆಯು ಮುಂದುವರಿಯುತ್ತದೆ.
4. ಅನಂತ ಲೂಪ್ಗಳನ್ನು ತಡೆಯಿರಿ
ನೋಟ್ಸ್ಗಳನ್ನು ಬರೆಯಲು ನೀವು ಹೆಡ್ಲೆಸ್ AI ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಅದು ನಿಮ್ಮ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ಅನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ. ಅಂದರೆ ಹೊಸ AI ತನ್ನದೇ ಆದ ಹೂಕ್ಗಳನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ. ಇದು ಅಂತ್ಯವಿಲ್ಲದ AI ಕರೆಗಳ ಲೂಪ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ಗಳ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಯಾವಾಗಲೂ ರಿಸರ್ಶನ್ ಗಾರ್ಡ್ (recursion guard) ಅನ್ನು ಸೇರಿಸಿ:
[ -n "$KB_CAPTURE" ] && exit 0
ನಿಮ್ಮ ಬ್ಯಾಕ್ಗ್ರೌಂಡ್ ಕ್ಯಾಪ್ಚರ್ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ KB_CAPTURE=1 ಎಂದು ಸೆಟ್ ಮಾಡಿ.
ಸೆಟಪ್ನ ಸಾರಾಂಶ:
- ತಕ್ಷಣದ ಸಂದರ್ಭದ ಇಂಜೆಕ್ಷನ್ಗಾಗಿ UserPromptSubmit ಬಳಸಿ.
- ಕೆಲಸಗಳನ್ನು ಕ್ಯೂ ಮಾಡಲು SessionEnd ಬಳಸಿ.
- ನಿಜವಾದ ಕೆಲಸವನ್ನು ಮಾಡಲು SessionStart ಬಳಸಿ.
- ಹಣ ಉಳಿಸಲು ನೋಟ್ಸ್ಗಳನ್ನು ಸಾರಾಂಶಗೊಳಿಸಲು ಅಗ್ಗದ ಮಾಡೆಲ್ ಬಳಸಿ.
ಒಂದು ಬಾರಿಯ ಪುನರಾವರ್ತಿತ ಸಮಸ್ಯೆಯ ಪರಿಹಾರವು ಅನೇಕ ಕ್ಯಾಪ್ಚರ್ಗಳ ವೆಚ್ಚವನ್ನು ಸರಿದೂಗಿಸುತ್ತದೆ.
Optional learning community: https://t.me/GyaanSetuAi