Foreman ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ (LLM) ಏಜೆಂಟ್ಗಳನ್ನು ನೇಟಿವ್ Kubernetes ಸಂಪನ್ಮೂಲಗಳನ್ನಾಗಿ (native Kubernetes resources) ಪರಿವರ್ತಿಸುತ್ತದೆ, ಇದು ತಂಡಗಳು ವೆಚ್ಚ ಮತ್ತು ಸುರಕ್ಷತೆಯನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ನಿಯಂತ್ರಣದಲ್ಲಿಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತಾ, AI-ಸೃಷ್ಟಿಸಿದ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಡಕ್ಷನ್ನಲ್ಲಿ ರನ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಇಂದಿನ ડેವ್ ವರ್ಕ್ಫ್ಲೋಗೆ (dev workflow) ಈ ಕಲ್ಪನೆ ಹೇಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ
ಉದ್ಯಮಗಳು ಕೋಡ್ ಬರೆಯಬಲ್ಲ LLMಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡುತ್ತಿವೆ, ಆದರೆ ಹೆಚ್ಚಿನ ಅನುಷ್ಠಾನಗಳು ಮಾದರಿಯನ್ನು (model) ನಂಬಲರ್ಹವಾದ 'ಬ್ಲಾಕ್ ಬಾಕ್ಸ್' (black box) ಎಂದು ಪರಿಗಣಿಸುತ್ತವೆ. ಮಾದರಿಯಿಂದ ಬರುವ ಕೇವಲ ಒಂದು “done” ಸಿಗ್ನಲ್ ಪರೀಕ್ಷಿಸದ ಬದಲಾವಣೆಗಳನ್ನು ನೇರವಾಗಿ ರೆಪೊಸಿಟರಿಗೆ (repository) ತಳ್ಳಬಹುದು, ಇದು ಭದ್ರತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯ ಕಾಳಜಿಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಕ್ಲೌಡ್ನಲ್ಲಿ AI ಸೇವೆಗಳನ್ನು ರನ್ ಮಾಡುವುದು ವೇಗವಾಗಿ ದುಬಾರಿಯಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ CI ಪೈಪ್ಲೈನ್ಗಳಿಂದ ಒಂದೇ ಮಾದರಿಯನ್ನು ಪದೇ ಪದೇ ಕರೆಯುವಾಗ ಇದು ಸಂಭವಿಸುತ್ತದೆ.
ಇಡೀ ಕೋಡಿಂಗ್ ಲೂಪ್ ಅನ್ನು Kubernetes ಕ್ಲಸ್ಟರ್ನ ಒಳಗೆ ಅಳವಡಿಸುವುದು Foreman ನ ಪರಿಹಾರವಾಗಿದೆ. Foreman, Kubernetes ಸಂಪನ್ಮೂಲಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಇದನ್ನು ಸಾಧ್ಯವಾಗಿಸುವ ನಾಲ್ಕು ಪ್ರಮುಖ ಆಬ್ಜೆಕ್ಟ್ಗಳು
- Agent – ಇದು ಕೆಲಸಗಾರನನ್ನು (worker) ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಇದು ಕರೆಯಬೇಕಾದ LLM ಅನ್ನು ಹೆಸರಿಸುತ್ತದೆ, ಮಾದರಿಯು ಬಳಸಬಹುದಾದ ಪರಿಕರಗಳ ಪಟ್ಟಿಯನ್ನು (ಉದಾಹರಣೆಗೆ, file-write ಅಥವಾ git-push) ನೀಡುತ್ತದೆ ಮತ್ತು ಮಾದರಿ ಕರೆಗಳಿಗಾಗಿ ಬಜೆಟ್ ಅನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಪಾತ್ರಗಳನ್ನು (roles) ಜೋಡಿಸಲಾಗುತ್ತದೆ; ಕೋಡರ್ ಏಜೆಂಟ್ ಕೋಡ್ ಬರೆಯುತ್ತದೆ, ವೆರಿಫೈಯರ್ ಏಜೆಂಟ್ ಅದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.
- Workload – ಬಳಕೆದಾರರು ಸೃಷ್ಟಿಸಿದ ಕೆಲಸದ ಘಟಕ. ಇದು ಉನ್ನತ ಮಟ್ಟದ ಉದ್ದೇಶವನ್ನು (ಉದಾಹರಣೆಗೆ, “module X ಗಾಗಿ ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳನ್ನು ಸೇರಿಸಿ”), ಗುರಿ ರೆಪೊಸಿಟರಿಯ ಉಲ್ಲೇಖ ಮತ್ತು ಕೆಲಸವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದ ಏಜೆಂಟ್ಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.
- AgenticTask – Workload ಸೃಷ್ಟಿಸುವ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯ. ಕೆಲಸ ಮುಂದುವರಿಯುತ್ತಿದ್ದಂತೆ, ಪ್ರತಿ AgenticTask ಸ್ಥಿತಿಯ ಅಪ್ಡೇಟ್ಗಳನ್ನು ದಾಖಲಿಸುತ್ತದೆ, ಇದು ಆಪರೇಟರ್ಗಳು ಪೈಪ್ಲೈನ್ ಅನ್ನು ನೈಜ ಸಮಯದಲ್ಲಿ (real time) ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
- FleetNode – ಕಾರ್ಯಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ರನ್ ಮಾಡುವ Kubernetes ನೋಡ್. ಅಂತರ್ನಿರ್ಮಿತ ಶೆಡ್ಯೂಲರ್ (scheduler) ಬಾಕಿ ಇರುವ AgenticTask ಗಳನ್ನು ಅಗತ್ಯವಿರುವ ಪಾತ್ರ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೊಂದಿರುವ FleetNode ಗಳಿಗೆ ಹೊಂದಿಸುತ್ತದೆ.
ಪರಿಶೀಲನೆಯು ಕುರುಡು ನಂಬಿಕೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ
Foreman ಮಾದರಿಯ ಔಟ್ಪುಟ್ ಸರಿಯಾಗಿದೆ ಎಂದು ಭಾವಿಸುವುದಿಲ್ಲ. ಕೋಡರ್ ಏಜೆಂಟ್ ತನ್ನ ಕೆಲಸವನ್ನು ಮುಗಿಸಿದಾಗ, ಅದು ಅಂತಿಮ ಫಲಿತಾಂಶದ ಬದಲಿಗೆ ವಿನಂತಿಯನ್ನು (request) ಕಳುಹಿಸುತ್ತದೆ. ವೆರಿಫೈಯರ್—ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಮತ್ತೊಂದು LLM ಆಗಿರದೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಕ್ರಿಪ್ಟ್ (deterministic script) ಆಗಿರುತ್ತದೆ—ಕೋಡ್ ಅನ್ನು ಲಿಂಟರ್ಗಳು (linters), ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳು ಅಥವಾ ಪೂರ್ಣ ಬಿಲ್ಡ್ಗಳ ಮೂಲಕ ರನ್ ಮಾಡುತ್ತದೆ. ಆ ಪರಿಶೀಲನೆಗಳು ಪಾಸಾದರೆ ಮಾತ್ರ Foreman ಹೊಸ ಬ್ರಾಂಚ್ ಅನ್ನು ರೆಪೊಸಿಟರಿಗೆ ಬರೆಯುತ್ತದೆ.
ವೆರಿಫೈಯರ್ ವಿಫಲವಾದರೆ, ಕಾರ್ಯವನ್ನು ತಿರಸ್ಕರಿಸಲಾಗಿದೆ (rejected) ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಬದಲಾವಣೆಗಳು ಎಂದಿಗೂ ಅನ್ವಯವಾಗುವುದಿಲ್ಲ. ಈ ಪ್ರತ್ಯೇಕತೆಯು ಮಾದರಿಯು ಸೃಜನಾತ್ಮಕವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಆದರೆ ಸುರಕ್ಷತಾ ಜಾಲವು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನವ ನಿಯಂತ್ರಣದಲ್ಲಿರುತ್ತದೆ.
ಕ್ಲಸ್ಟರ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಇನ್ಸ್ಟಾಲ್ ಮಾಡುವುದು
- Helm ಬಳಸಿ LLMKube core chart ಅನ್ನು ನಿಯೋಜಿಸಿ (deploy).
- Foreman chart ಅನ್ನು ಸಹ Helm ಮೂಲಕ ನಿಯೋಜಿಸಿ.
- ಏಜೆಂಟ್ ಮೋಡ್ ಅನ್ನು “native” ಗೆ ಬದಲಾಯಿಸಿ, ಇದರಿಂದ ನೈಜ request-response ಲೂಪ್ ಸಕ್ರಿಯಗೊಳ್ಳುತ್ತದೆ.
- ಕೆಲಸವನ್ನು ಹೋಸ್ಟ್ ಮಾಡುವ FleetNodes ಗಳಿಗೆ ಪಾತ್ರಗಳನ್ನು (coder, verifier) ನಿಯೋಜಿಸಿ.
ಎರಡು ಕ್ರೆಡೆನ್ಷಿಯಲ್ ಸೆಟ್ಗಳು (credential sets) ಅಗತ್ಯವಿವೆ: ಇಶ್ಯೂಗಳನ್ನು ಓದಲು ಮತ್ತು ಬ್ರಾಂಚ್ಗಳನ್ನು ಪುಶ್ ಮಾಡಲು git ಕ್ರೆಡೆನ್ಷಿಯಲ್ಗಳು, ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಲಾದ API ಅಥವಾ ಸೆಲ್ಫ್-ಹೋಸ್ಟ್ ಮಾಡಲಾದ ಇನ್ಫರೆನ್ಸ್ ಸೇವೆಯನ್ನು ಕರೆಯಲು ಮಾಡೆಲ್ ಕ್ರೆಡೆನ್ಷಿಯಲ್ಗಳು.
ನೀವು ವಾಸ್ತವವಾಗಿ ನಿಯಂತ್ರಿಸಬಹುದಾದ ವೆಚ್ಚ ಮತ್ತು ಭದ್ರತೆಯ ಆಯ್ಕೆಗಳು
ಏಜೆಂಟ್ ವ್ಯಾಖ್ಯಾನದಿಂದ ಪರಿಕರಗಳನ್ನು (tools) ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ಮಾದರಿಯ ಅಧಿಕಾರವನ್ನು ಮಿತಿಗೊಳಿಸಲು Foreman ಆಪರೇಟರ್ಗಳಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. “bash” ಅಥವಾ “write_file” ಅನ್ನು ತೆಗೆದುಹಾಕುವುದರಿಂದ ಮಾದರಿಯು ಅನಗತ್ಯ ಶೆಲ್ ಕಮಾಂಡ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಅಥವಾ ನಿಗದಿತ ವರ್ಕ್ಸ್ಪೇಸ್ನ ಹೊರಗೆ ಬರೆಯುವುದನ್ನು ತಡೆಯುತ್ತದೆ.
ಟರ್ನ್ ಲಿಮಿಟ್ (turn limit) ಪ್ರತಿ ಕಾರ್ಯಕ್ಕೆ ಮಾದರಿಯ ಕರೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ, ಇದು ನೇರವಾಗಿ ವೆಚ್ಚವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ (context window)—ಮಾಡೆಲ್ ಎಷ್ಟು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ನೋಡುತ್ತದೆ ಎಂಬುದನ್ನು—ಹೊಂದಿಸುವುದರಿಂದ ಟೋಕನ್ ಬಳಕೆಯನ್ನು ಮತ್ತಷ್ಟು ಕಡಿಮೆ ಮಾಡಬಹುದು. ಮಾದರಿಯು ಸ್ಥಳೀಯವಾಗಿ (locally) ಆನ್-ಪ್ರೆಮ್ ಹಾರ್ಡ್ವೇರ್ನಲ್ಲಿ ರನ್ ಆಗುವಾಗ, ಯಾವುದೇ ಡೇಟಾ ಸಂಸ್ಥೆಯನ್ನು ಬಿಟ್ಟು ಹೊರಗೆ ಹೋಗುವುದಿಲ್ಲ, ಇದು ಕಟ್ಟುನಿಟ್ಟಿನ ಡೇಟಾ-ಪ್ರೈವೆಸಿ ನೀತಿಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ.
ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಎಲ್ಲಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಿ ಇನ್ನೂ ಹಿನ್ನಡೆ ಅನುಭವಿಸುತ್ತದೆ
Foreman ಯಾಂತ್ರಿಕವಾದ ಮತ್ತು ಸ್ಪಷ್ಟ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿರುವ ಕೆಲಸಗಳಲ್ಲಿ ಅತ್ಯುತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:
- ದಾಖಲಿಸಲಾದ ಬಗ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದು.
- ಕಾಣೆಯಾದ ಟೆಸ್ಟ್ ಕೇಸ್ಗಳನ್ನು ಸೇರಿಸುವುದು.
- ಸ್ಪಷ್ಟತೆ ಅಥವಾ ಶೈಲಿಗಾಗಿ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡುವುದು.
ಈ ಕಾರ್ಯಗಳು ವೆರಿಫೈಯರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದಾದ ಸ್ಪಷ್ಟ ಯಶಸ್ಸಿನ ಮಾನದಂಡಗಳನ್ನು ಹೊಂದಿವೆ. ಉನ್ನತ ಮಟ್ಟದ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಮರುವಿನ್ಯಾಸಗಳು ಅಥವಾ “ಸರಿಯಾದತನವು” ಮಾನವ ತೀರ್ಪಿನ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಅಸ್ಪಷ್ಟ ಫೀಚರ್ ಕೆಲಸಗಳಲ್ಲಿ ಈ ವ್ಯವಸ್ಥೆಯು ಇನ್ನೂ ಕಷ್ಟಪಡುತ್ತಿದೆ.
ಸಾರಾಂಶ
LLM-ಚಾಲಿತ ಕೋಡರ್ಗಳನ್ನು ಪ್ರಥಮ ದರ್ಜೆಯ Kubernetes ಸಂಪನ್ಮೂಲಗಳಾಗಿ ಪರಿಗಣಿಸುವ ಮೂಲಕ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ವೆರಿಫಿಕೇಶನ್ ಹಂತವನ್ನು ಜಾರಿಗೆ ತರುವ ಮೂಲಕ, Foreman ವೆಚ್ಚವನ್ನು ದೃಶ್ಯೀಕರಿಸುವ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ನಿಯಂತ್ರಣದಲ್ಲಿಡುವ ಮೂಲಕ ಪ್ರೊಡಕ್ಷನ್ AI ಕೋಡ್ ಜನರೇಶನ್ಗೆ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ. ಇದು ಎಲ್ಲಾ ಅಭಿವೃದ್ಧಿ ಕೆಲಸಗಳಿಗೆ ಒಂದು ಮ್ಯಾಜಿಕ್ ಪರಿಹಾರವಲ್ಲ, ಆದರೆ ಪುನರಾವರ್ತಿತ ಮತ್ತು ಪರೀಕ್ಷಿಸಬಹುದಾದ ಕಾರ್ಯಗಳಿಗಾಗಿ ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲೌಡ್-ನೇಟಿವ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ನೈಸರ್ಗಿಕವಾಗಿ ಹೊಂದಿಕೆಯಾಗುವ ಆಡಿಟಬಲ್ ವರ್ಕ್ಫ್ಲೋವನ್ನು ಒದಗಿಸುತ್ತದೆ.