ಪ್ರಸ್ತುತ ಪ್ರತಿಯೊಂದು AI ಸಂಭಾಷಣೆಯಲ್ಲೂ ಏಜೆಂಟ್‌ಗಳೇ (Agents) ಪ್ರಾಬಲ್ಯ ಹೊಂದಿದ್ದಾರೆ. ಡೆಮೋಗಳು ಅವುಗಳನ್ನು ಮನುಷ್ಯರ ಸಹಾಯವಿಲ್ಲದೆ ಯೋಚಿಸುವ, ಕಾರ್ಯತಂತ್ರ ರೂಪಿಸುವ ಮತ್ತು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಸ್ವಾಯತ್ತ ಡಿಜಿಟಲ್ ಸಹಾಯಕರಂತೆ ಕಾಣುವಂತೆ ಮಾಡುತ್ತವೆ. ಆದರೆ, ಇಂಟರ್ಫೇಸ್‌ನ ಹೊರಪದರವನ್ನು ತೆಗೆದು ನೋಡಿದರೆ, ನೀವು ಅದಕ್ಕಿಂತ ಸುಲಭವಾದದ್ದನ್ನು ಕಾಣುವಿರಿ. ಏಜೆಂಟ್ ಎಂಬುದು ಕೇವಲ ಒಂದು ಲೂಪ್‌ನೊಳಗೆ ಚಲಿಸುವ ಭಾಷಾ ಮಾದರಿ (language model). ಇದು ಒಂದು ವಿನ್ಯಾಸ ಮಾದರಿಯೇ ಹೊರತು ಪ್ರಜ್ಞೆಯಲ್ಲ. ಈ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯ, ಏಕೆಂದರೆ ಇದು ನೀವು ಈ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುತ್ತೀರಿ, ಡಿಬಗ್ ಮಾಡುತ್ತೀರಿ ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ನಂಬುತ್ತೀರಿ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.

ಏಜೆಂಟ್ ವಾಸ್ತವವಾಗಿ ಎಂದರೇನು

ಸಾಮಾನ್ಯ ಚಾಟ್‌ಬಾಟ್ ಒಂದು ಸಿಂಗಲ್-ಶಾಟ್ ಫಂಕ್ಷನ್ (single-shot function). ನೀವು ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಟೈಪ್ ಮಾಡುತ್ತೀರಿ. ಮಾಡೆಲ್ ಮುಂದಿನ ಟೋಕನ್‌ಗಳನ್ನು ಮುನ್ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ಪಠ್ಯದ ಒಂದು ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಂತರ ಅದು ನಿಲ್ಲುತ್ತದೆ. ತನ್ನ ಉತ್ತರ ನಿಖರವಾಗಿದೆಯೇ ಎಂದು ಅದು ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ. ವೆಬ್ ಲಿಂಕ್ ಕೆಲಸ ಮಾಡುತ್ತಿದೆಯೇ ಅಥವಾ ಲೆಕ್ಕಾಚಾರ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಅದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಅದು ಒಂದೇ ಬಾರಿಗೆ ತನ್ನ ಅತ್ಯುತ್ತಮ ಅಂದಾಜನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಮೌನವಾಗುತ್ತದೆ.

ಏಜೆಂಟ್ ಆ ಸಿಂಗಲ್ ಶಾಟ್ ಅನ್ನು ಪುನರಾವರ್ತಿತ ಚಕ್ರವಾಗಿ ವಿಭಜಿಸುತ್ತದೆ. ಮಾಡೆಲ್ ಇನ್ನೂ ಪಠ್ಯವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಆದರೆ ಈಗ ಅದು ನಿಯಂತ್ರಿತ ಲೂಪ್‌ನೊಳಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಅದು ಹೊರಜಗತ್ತಿನ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು ಮತ್ತು ಏನಾಗುತ್ತಿದೆಯೋ ಅದಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದು.

ಈ ಚಕ್ರವು ಈ ರೀತಿ ಇರುತ್ತದೆ:

  • ಗುರಿಯನ್ನು ಅಂದಾಜಿಸುವುದು ಮತ್ತು ಏನು ಮಾಡಬೇಕೆಂದು ವಿವೇಚಿಸುವುದು.
  • ಒಂದು ಕ್ರಮವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು, ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಟೂಲ್ ಅಥವಾ API ಅನ್ನು ಕರೆಯುವ ಮೂಲಕ.
  • ಆ ಕ್ರಮದ ಫಲಿತಾಂಶವನ್ನು ಗಮನಿಸುವುದು.
  • ಆ ಹೊಸ ಮಾಹಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಮತ್ತೆ ವಿವೇಚಿಸುವುದು.

ಕಾರ್ಯವು ಮುಗಿಯುವವರೆಗೆ ಅಥವಾ ವ್ಯವಸ್ಥೆಯು ಸುರಕ್ಷತಾ ಮಿತಿಯನ್ನು ತಲುಪುವವರೆಗೆ ಈ ಚಕ್ರವು ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. ಇದೇ ಇದರ ಸಂಪೂರ್ಣ ರಹಸ್ಯ. ಇಲ್ಲಿ ಯಾವುದೇ ಗುಪ್ತ ತರ್ಕ ಇಂಜಿನ್ ಇಲ್ಲ. ನೈಜ ಪರಿಕರಗಳಿಂದ (real tools) ಸಿಗುವ ನೈಜ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ತನ್ನದೇ ಹಾದಿಯನ್ನು ತಾನೇ ಸರಿಪಡಿಸಿಕೊಳ್ಳಲು ಮಾಡೆಲ್‌ಗೆ ಅವಕಾಶ ನೀಡುವುದರಿಂದ ಈ ಮ್ಯಾಜಿಕ್ ಸಂಭವಿಸುತ್ತದೆ.

ReAct: Thought-Action-Observation ಚಕ್ರ

ಈ ಲೂಪ್ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ವಿಧಾನವೇ ReAct ಮಾದರಿ, ಇದರರ್ಥ Reason (ವಿವೇಚನೆ) ಪ್ಲಸ್ Act (ಕ್ರಮ). ಲೂಪ್‌ನ ಪ್ರತಿ ಸುತ್ತಿನಲ್ಲಿ, ಮಾಡೆಲ್ ಮೂರು ವಿಭಿನ್ನ ಹಂತಗಳ ಮೂಲಕ ಚಲಿಸುತ್ತದೆ.

ಮೊದಲನೆಯದಾಗಿ, ಮಾಡೆಲ್ ಒಂದು ಆಲೋಚನೆಯನ್ನು (Thought) ಸೃಷ್ಟಿಸುತ್ತದೆ. ಇದು ಪ್ರಸ್ತುತ ಪರಿಸ್ಥಿತಿಯ ಬಗ್ಗೆ ಯೋಚಿಸುತ್ತದೆ, ಮೂಲ ಗುರಿಯನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮುಂದೆ ಏನನ್ನು ತಿಳಿಯಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ಅದು ಒಂದು ಕ್ರಮವನ್ನು (Action) ಆರಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದು ವೆಬ್ ಸರ್ಚ್, ಡೇಟಾಬೇಸ್ ಕ್ವೇರಿ, ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಕರೆ ಅಥವಾ ಫೈಲ್ ಓದುವ ವಿನಂತಿಯಾಗಿರಬಹುದು. ಮೂರನೆಯದಾಗಿ, ಅದು ಒಂದು ಗಮನಣೆಯನ್ನು (Observation) ಪಡೆಯುತ್ತದೆ. ವ್ಯವಸ್ಥೆಯು ಮಾಡೆಲ್‌ನ ಹೊರಗೆ ಆ ಕ್ರಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಕಚ್ಚಾ ಫಲಿತಾಂಶವನ್ನು ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸಕ್ಕೆ (conversation history) ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಂತರ ಮಾಡೆಲ್ ಆ ಹೊಸ ಗಮನಣೆಯನ್ನು ತನ್ನ ಹೊಸ ವಾಸ್ತವವಾಗಿ ಬಳಸಿಕೊಂಡು ಮುಂದಿನ ಲೂಪ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಒಂದು ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ. ನೀವು ಏಜೆಂಟ್‌ಗೆ ನಾಳೆ ಆಸ್ಟಿನ್‌ನಲ್ಲಿ ಮಳೆ ಬರುತ್ತದೆಯೇ ಎಂದು ಕೇಳುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಮಾಡೆಲ್, "ನನಗೆ ಆಸ್ಟಿನ್‌ನ ಹವಾಮಾನ ಮುನ್ಸೂಚನೆ ಬೇಕು" ಎಂದು ಯೋಚಿಸಬಹುದು. ಅದರ ಕ್ರಮವೆಂದರೆ ನಗರದ ಹೆಸರಿನೊಂದಿಗೆ weather API ಅನ್ನು ಕರೆಯುವುದು. ಗಮನಣೆಯು ಕಚ್ಚಾ JSON ರೂಪದಲ್ಲಿ ಬರುತ್ತದೆ: ತಾಪಮಾನದ ರೀಡಿಂಗ್ ಮತ್ತು ಮಳೆಯಾಗುವ ಸಾಧ್ಯತೆ (precipitation probability). ನಂತರ ಮಾಡೆಲ್ ಮತ್ತೆ ಯೋಚಿಸುತ್ತದೆ, "ಮುನ್ಸೂಚನೆಯು ಶೇಕಡಾ ಎಪ್ಪತ್ತು ರಷ್ಟು ಮಳೆಯಾಗುವ ಸಾಧ್ಯತೆಯನ್ನು ತೋರಿಸುತ್ತಿದೆ," ಮತ್ತು ಅದರ ಅಂತಿಮ ಕ್ರಮವು ಅದನ್ನು ನಿಮಗಾಗಿ ಸರಳ ಇಂಗ್ಲಿಷ್ ಉತ್ತರವಾಗಿ ಸಂಶ್ಲೇಷಿಸುವುದಾಗಿರುತ್ತದೆ.

ಈ ರಚನೆಯು ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಮಾಡೆಲ್ ಅನ್ನು ವಾಸ್ತವಕ್ಕೆ ಹತ್ತಿರವಾಗಿಸುತ್ತದೆ (grounds the model). ಮಾಡೆಲ್ ಮುಂದುವರಿಯುವ ಮೊದಲು ಸರ್ಚ್ ಮಾಡಬೇಕಾಗಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಓದಬೇಕಾಗಿ ಬಂದರೆ, ಅದು ಸುಮ್ಮನೆ ಕಾಲ್ಪನಿಕ ಸತ್ಯಗಳನ್ನು ಸೃಷ್ಟಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಗಮನಣೆಯು ಮುಂದಿನ ಆಲೋಚನೆಗೆ ಒಂದು ಕಠಿಣ ನಿರ್ಬಂಧವಾಗಿ (hard constraint) ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಮಾಡೆಲ್ ಮಾತನಾಡುವ ಮೊದಲು ನೋಡಬೇಕಾಗಿರುವುದರಿಂದ, ಈ ಲೂಪ್ ಸುಳ್ಳು ಅಥವಾ ಕಾಲ್ಪನಿಕ ವಿಷಯಗಳನ್ನು ಸೃಷ್ಟಿಸುವುದನ್ನು ಕಷ್ಟವಾಗಿಸುತ್ತದೆ.

ನಂಬಿಕಸ್ತ ಲೂಪ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಬೇಕಾದುದು

ಈ ಮಾದರಿಯನ್ನು ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ (production) ನಡೆಸಲು ಕೇವಲ ಚತುರ ಪ್ರಾಂಪ್ಟ್ ಸಾಕಾಗುವುದಿಲ್ಲ. ನೀವು ಮೂರು ಪ್ರಾಯೋಗಿಕ ಗಾರ್ಡ್‌ರೈಲ್‌ಗಳನ್ನು (guardrails) ಹೊಂದಿರಬೇಕಾಗುತ್ತದೆ.

ಹಂತಗಳ ಬಜೆಟ್ ಅನ್ನು ನಿಗದಿಪಡಿಸಿ (Set a step budget). ಯಾವಾಗಲೂ ಲೂಪ್ ಇಟರೇಶನ್‌ಗಳ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ. ಒಂದು ಮಿತಿಯಿಲ್ಲದಿದ್ದರೆ, ಏಜೆಂಟ್ ತನ್ನದೇ ಚಕ್ರದಲ್ಲಿ ಸುತ್ತುತ್ತಾ ಇರಬಹುದು—ಸರ್ಚ್ ಮಾಡುವುದು, ಗಮನಿಸುವುದು, ವಿವೇಚಿಸುವುದು, ಮತ್ತೆ ಸರ್ಚ್ ಮಾಡುವುದು—ಹೀಗೆ ಮಾಡುತ್ತಾ ನಿಮ್ಮ API ಬಜೆಟ್ ಅನ್ನು ಖಾಲಿ ಮಾಡಬಹುದು. ಹಂತಗಳ ಮಿತಿಯು ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಮಿತಿ ತಲುಪಿದ ನಂತರ, ಭಾಗಶಃ ಫಲಿತಾಂಶವನ್ನು ನೀಡಬೇಕೆ, ಮನುಷ್ಯನ ಸಹಾಯ ಪಡೆಯಬೇಕೆ ಅಥವಾ ಸುಗಮವಾಗಿ ವಿಫಲವಾಗಬೇಕೆ (fail gracefully) ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬಹುದು.

ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಅನ್ನು ನೀವೇ ನಿರ್ವಹಿಸಿ (Handle code execution yourself). ಭಾಷಾ ಮಾದರಿಯು ಟೂಲ್‌ಗಳನ್ನು ರನ್ ಮಾಡುವುದಿಲ್ಲ. ಅದು ಕೇವಲ ಕ್ರಮಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಟೂಲ್ ಹೆಸರನ್ನು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ರಚನಾತ್ಮಕ ಪಠ್ಯ ಅಥವಾ JSON ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುವ ಮೂಲಕ. ನಿಮ್ಮ ಕೋಡ್