ಮಾಡೆಲ್ನಿಂದ ಏಜೆಂಟ್ಗೆ: ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಗೆ ಕಂಪ್ಯೂಟರ್ ಪರಿಸರವನ್ನು ಸಜ್ಜುಗೊಳಿಸುವುದು
ಬೊ ಕ್ಸು, ಡ್ಯಾನಿ ಜಾಂಗ್ ಮತ್ತು ರೋಹಿತ್ ಅರುಣಾಚಲಂ ಅವರಿಂದ
ನಾವು ಪ್ರಸ್ತುತ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಲ್ಲಿ ಅತ್ಯುತ್ತಮವಾಗಿರುವ ಮಾಡೆಲ್ಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಸಂಕೀರ್ಣ ವರ್ಕ್ಫ್ಲೋಗಳನ್ನು ನಿಭಾಯಿಸಲು ಸಾಮರ್ಥ್ಯವಿರುವ ಏಜೆಂಟ್ಗಳನ್ನು ಬಳಸುವತ್ತ ಶಿಫ್ಟ್ ಆಗುತ್ತಿದ್ದೇವೆ. ಮಾಡೆಲ್ಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವ ಮೂಲಕ, ನೀವು ತರಬೇತಿ ಪಡೆದ ಬುದ್ಧಿವಂತಿಕೆಗೆ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಮಾಡೆಲ್ಗೆ ಕಂಪ್ಯೂಟರ್ ಪರಿಸರವನ್ನು ಒದಗಿಸುವುದರಿಂದ ಸೇವೆಗಳನ್ನು ಚಾಲನೆ ಮಾಡುವುದು, APIಗಳಿಂದ ಡೇಟಾವನ್ನು ವಿನಂತಿಸುವುದು ಅಥವಾ ಸ್ಪ್ರೆಡ್ಶೀಟ್ಗಳು ಅಥವಾ ವರದಿಗಳಂತಹ ಇನ್ನಷ್ಟು ಉಪಯುಕ್ತ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ಗಳನ್ನು ರಚಿಸುವುದು ಮುಂತಾದ ಬಹಳ ವಿಶಾಲ ಶ್ರೇಣಿಯ ಉಪಯೋಗ ಸಂದರ್ಭಗಳನ್ನು ಸಾಧಿಸಬಹುದು.
ಏಜೆಂಟ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿದಾಗ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳು ಎದುರಾಗುತ್ತವೆ: ಮಧ್ಯಂತರ ಫೈಲ್ಗಳನ್ನು ಎಲ್ಲಿ ಇಡಬೇಕು, ದೊಡ್ಡ ಟೇಬಲ್ಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್ಗೆ ಪೇಸ್ಟ್ ಮಾಡುವುದನ್ನು ಹೇಗೆ ತಪ್ಪಿಸಬೇಕು, ಭದ್ರತಾ ತಲೆನೋವು ಉಂಟುಮಾಡದೇ ವರ್ಕ್ಫ್ಲೋಗೆ ನೆಟ್ವರ್ಕ್ ಪ್ರವೇಶವನ್ನು ಹೇಗೆ ನೀಡಬೇಕು ಮತ್ತು ನೀವು ಸ್ವತಃ ವರ್ಕ್ಫ್ಲೋ ಸಿಸ್ಟಮ್ ನಿರ್ಮಿಸದೇ ಟೈಮ್ಔಟ್ಗಳು ಮತ್ತು ಮರುಪ್ರಯತ್ನಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು.
ಡೆವಲಪರ್ಗಳು ತಮ್ಮದೇ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಎನ್ವೈರನ್ಮೆಂಟ್ಗಳನ್ನು ನಿರ್ಮಿಸಬೇಕೆಂಬ ಹೊಣೆಗಾರಿಕೆಯನ್ನು ಅವರ ಮೇಲೆ ಹಾಕುವ ಬದಲು, ನೈಜ ಜಗತ್ತಿನ ಕಾರ್ಯಗಳನ್ನು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಂಪ್ಯೂಟರ್ ಎನ್ವೈರನ್ಮೆಂಟ್ನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಗಳ API(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಅನ್ನು ಸಜ್ಜುಗೊಳಿಸಲು ಅಗತ್ಯವಾದ ಘಟಕಗಳನ್ನು ನಾವು ನಿರ್ಮಿಸಿದ್ದೇವೆ.
OpenAI ಯ ಪ್ರತಿಕ್ರಿಯೆಗಳ API, ಶೆಲ್ ಟೂಲ್ ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಲಾದ ಕಂಟೇನರ್ ವರ್ಕ್ಸ್ಪೇಸ್ ಜೊತೆಯಲ್ಲಿ, ಈ ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಮಾಡೆಲ್ ಹಂತಗಳು ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸುತ್ತದೆ; ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಅವುಗಳನ್ನು ಇನ್ಪುಟ್ಗಳು ಮತ್ತು ಔಟ್ಪುಟ್ಗಳಿಗಾಗಿ ಫೈಲ್ಸಿಸ್ಟಮ್ ಹೊಂದಿರುವ ಐಸೋಲೇಟೆಡ್ ಪರಿಸರದಲ್ಲಿ, ಐಚ್ಛಿಕ ರಚನಾತ್ಮಕ ಸಂಗ್ರಹಣೆ (SQLite ನಂತಹದು) ಮತ್ತು ನಿರ್ಬಂಧಿತ ನೆಟ್ವರ್ಕ್ ಪ್ರವೇಶದೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ಏಜೆಂಟ್ಗಳಿಗಾಗಿ ನಾವು ಕಂಪ್ಯೂಟರ್ ಪರಿಸರವನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತೇವೆ ಮತ್ತು ವೇಗವಾದ, ಹೆಚ್ಚು ಪುನರಾವರ್ತಿಸಬಹುದಾದ ಮತ್ತು ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಪ್ರೊಡಕ್ಷನ್ ವರ್ಕ್ಫ್ಲೋಗಳಿಗೆ ಇದನ್ನು ಹೇಗೆ ಬಳಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಕೆಲವು ಆರಂಭಿಕ ಪಾಠಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ.
ಒಂದು ಉತ್ತಮ ಏಜೆಂಟ್ ವರ್ಕ್ಫ್ಲೋ ಒಂದು ಕಟ್ಟುನಿಟ್ಟಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಲೂಪ್ನೊಂದಿಗೆ ಆರಂಭವಾಗುತ್ತದೆ: ಮಾಡೆಲ್ ಫೈಲ್ಗಳನ್ನು ಓದುವುದು ಅಥವಾ API ಮೂಲಕ ಡೇಟಾವನ್ನು ಫೆಚ್ ಮಾಡುವುದಂತಹ ಒಂದು ಕ್ರಿಯೆಯನ್ನು ಪ್ರಸ್ತಾಪಿಸುತ್ತದೆ, ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಅದನ್ನು ನಡೆಸುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಫೀಡ್ ಆಗುತ್ತದೆ. ನಾವು ಶೆಲ್ ಟೂಲ್ ನಿಂದ ಆರಂಭಿಸುತ್ತೇವೆ—ಈ ಲೂಪ್ ಕಾರ್ಯದಲ್ಲಿರುವುದನ್ನು ನೋಡಲು ಅತ್ಯಂತ ಸರಳವಾದ ಮಾರ್ಗ—ಮತ್ತು ನಂತರ ಕಂಟೇನರ್ ವರ್ಕ್ಸ್ಪೇಸ್, ನೆಟ್ವರ್ಕಿಂಗ್, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೌಶಲ್ಯಗಳು ಮತ್ತು ಸಂದರ್ಭ ಸಂಕ್ಷೇಪಣೆಯನ್ನು ಒಳಗೊಂಡಂತೆ ವಿವರಿಸುತ್ತೇವೆ.
ಶೆಲ್ ಟೂಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮೊದಲು ಭಾಷಾ ಮಾಡೆಲ್ ಸಾಮಾನ್ಯವಾಗಿ ಟೂಲ್ಗಳನ್ನು ಹೇಗೆ ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಉಪಯುಕ್ತ: ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದಾಗಲಿ ಅಥವಾ ಕಂಪ್ಯೂಟರ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವುದಾಗಲಿ. ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ, ಒಂದು ಮಾಡೆಲ್ಗೆ ಉಪಕರಣಗಳನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಪರಿಣಾಮಗಳು ಏನೆಂಬುದರ ಉದಾಹರಣೆಗಳನ್ನು ಹಂತ ಹಂತವಾಗಿ ತೋರಿಸಲಾಗುತ್ತದೆ. ಇದು ಮಾಡೆಲ್ಗೆ ಟೂಲ್ ಅನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಬಳಸಬೇಕು ಎಂದು ನಿರ್ಧರಿಸಲು ಕಲಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಾವು “ಟೂಲ್ ಬಳಸುವುದು” ಎಂದು ಹೇಳುವಾಗ, ನಮ್ಮ ಅರ್ಥ ಮಾಡೆಲ್ ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಟೂಲ್ ಕಾಲ್ ಅನ್ನು ಪ್ರಸ್ತಾಪಿಸುತ್ತದೆ. ಅದು ಸ್ವತಃ ಆ ಕಾಲ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಶೆಲ್ ಟೂಲ್ ಮಾಡೆಲ್ ಅನ್ನು ನಾಟಕೀಯವಾಗಿ ಇನ್ನಷ್ಟು ಶಕ್ತಿಶಾಲಿಯಾಗಿಸುತ್ತದೆ: ಇದು ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ಕಂಪ್ಯೂಟರ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿ, ಪಠ್ಯವನ್ನು ಹುಡುಕುವುದರಿಂದ ಹಿಡಿದು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ API ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುವವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಪರಿಚಿತ ಯುನಿಕ್ಸ್ ಉಪಕರಣಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಲಾದ ನಮ್ಮ ಶೆಲ್ ಟೂಲ್ ಔಟ್ ಆಫ್ ದ ಬಾಕ್ಸ್ ಲಭ್ಯವಿರುವ grep, curl ಮತ್ತು awk ಮುಂತಾದ ಉಪಯುಕ್ತತೆಗಳ ಜೊತೆ ನೀವು ನಿರೀಕ್ಷಿಸುವ ಯಾವುದನ್ನಾದರೂ ಮಾಡಬಹುದು.
ನಮ್ಮ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಹೋಲಿಸಿದರೆ, ಅದು ಕೇವಲ Python ಅನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಶೆಲ್ ಟೂಲ್ವು Go ಅಥವಾ Java ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸುವುದು ಅಥವಾ NodeJS ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮುಂತಾದ ಬಹಳ ವಿಶಾಲವಾದ ಬಳಕೆ ಪ್ರಕರಣಗಳ ಶ್ರೇಣಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಈ ಲವಚಿಕತೆ ಮಾಡೆಲ್ಗೆ ಸಂಕೀರ್ಣ ಏಜೆಂಟ್ ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
ಸ್ವತಃ, ಮಾಡೆಲ್ ಶೆಲ್ ಆಜ್ಞೆಗಳನ್ನು ಮಾತ್ರ ಪ್ರಸ್ತಾಪಿಸಬಹುದು, ಆದರೆ ಈ ಆಜ್ಞೆಗಳನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ? ಕಾರ್ಯ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ, ಮಾಡೆಲ್ ಔಟ್ಪುಟ್ ಪಡೆಯಲು, ಸಾಧನಗಳನ್ನು ಕಾಲ್ ಮಾಡಲು ಮತ್ತು ಸಾಧನದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಲೂಪ್ನಲ್ಲಿ ಮತ್ತೆ ಮಾಡೆಲ್ಗೆ ಹಿಂತಿರುಗಿಸಲು ನಮಗೆ ಒಂದು ಆಯೋಜಕ ಬೇಕಾಗಿದೆ.
ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಡೆವಲಪರ್ಗಳು OpenAI ಮಾಡೆಲ್ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ವಿಧಾನವಾಗಿದೆ. ಕಸ್ಟಮ್ ಟೂಲ್ಗಳೊಂದಿಗೆ ಬಳಸಿದಾಗ, ಪ್ರತಿಕ್ರಿಯೆಗಳ API ನಿಯಂತ್ರಣವನ್ನು ಗ್ರಾಹಕನಿಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಗ್ರಾಹಕನಿಗೆ ಟೂಲ್ಗಳನ್ನು ಚಾಲನೆ ಮಾಡಲು ತನ್ನದೇ ಹಾರ್ನೆಸ್ ಅಗತ್ಯವಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ API ಕೂಡ ಔಟ್ ಆಫ್ ದ ಬಾಕ್ಸ್ ಆಗಿಯೇ ಮಾಡೆಲ್ ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಲಾದ ಟೂಲ್ಗಳ ನಡುವೆ ಆಯೋಜಿಸಬಹುದು.
ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಅದು ಮಾಡೆಲ್ ಸಂದರ್ಭವನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ: ಬಳಕೆದಾರರ ಪ್ರಾಂಪ್ಟ್, ಹಿಂದಿನ ಸಂಭಾಷಣೆಯ ಸ್ಥಿತಿ ಮತ್ತು ಟೂಲ್ ಸೂಚನೆಗಳು. ಶೆಲ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ ಶೆಲ್ ಪರಿಕರವನ್ನು ಬಳಸುವುದನ್ನು ಉಲ್ಲೇಖಿಸಬೇಕು ಮತ್ತು ಆಯ್ಕೆಮಾಡಿದ ಮಾಡೆಲ್ ಶೆಲ್ ಆಜ್ಞೆಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಲು ತರಬೇತಿ ಪಡೆದಿರಬೇಕು—GPT‑5.2 ಮತ್ತು ನಂತರದ ಮಾಡೆಲ್ಗಳು ಇದಕ್ಕಾಗಿ ತರಬೇತಿ ಪಡೆದಿವೆ. ಈ ಎಲ್ಲಾ ಸಂದರ್ಭದೊಂದಿಗೆ, ಮಾಡೆಲ್ ಮುಂದಿನ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದು ಶೆಲ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಿದರೆ, ಇದು ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಸೇವೆಗೆ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಶೆಲ್ ಆಜ್ಞೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. API ಸೇವೆಯು ಆ ಆಜ್ಞೆಗಳನ್ನು ಕಂಟೇನರ್ ರನ್ಟೈಮ್ಗೆ ಫಾರ್ವರ್ಡ್ ಮಾಡುತ್ತದೆ, ಶೆಲ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ವಿನಂತಿಯ ಕಾನ್ಟೆಕ್ಸ್ಟ್ನಲ್ಲಿ ಅದನ್ನು ಮಾಡೆಲ್ಗೆ ಫೀಡ್ ಮಾಡುತ್ತದೆ. ಮಾಡೆಲ್ ನಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಬಹುದು, ಫಾಲೋ-ಅಪ್ ಆಜ್ಞೆಗಳನ್ನು ನೀಡಬಹುದು ಅಥವಾ ಅಂತಿಮ ಉತ್ತರವನ್ನು ಉತ್ಪಾದಿಸಬಹುದು. ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಹೆಚ್ಚುವರಿ ಶೆಲ್ ಆಜ್ಞೆಗಳಿಲ್ಲದೆ ಮಾಡೆಲ್ ಒಂದು ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವವರೆಗೆ ಈ ಲೂಪ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಶೆಲ್ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಅದು ಕಂಟೇನರ್ ಸೇವೆಗೆ ಸ್ಟ್ರೀಮಿಂಗ್ ಸಂಪರ್ಕವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಔಟ್ಪುಟ್ ಉತ್ಪಾದನೆಯಾಗುತ್ತಿದ್ದಂತೆ, API ಅದನ್ನು ನೈಜ ಸಮಯಕ್ಕೆ ಸಮೀಪವಾಗಿ ಮಾಡೆಲ್ಗೆ ರಿಲೇ ಮಾಡುತ್ತದೆ, ಇದರಿಂದ ಮಾಡೆಲ್ ಇನ್ನಷ್ಟು ಔಟ್ಪುಟ್ಗಾಗಿ ಕಾಯಬೇಕೇ, ಮತ್ತೊಂದು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬೇಕೇ ಅಥವಾ ಅಂತಿಮ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಮುಂದಾಗಬೇಕೇ ಎಂದು ನಿರ್ಧರಿಸಬಹುದು.
ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಶೆಲ್ ಆಜ್ಞೆಯ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ
ಮಾಡೆಲ್ ಒಂದು ಹಂತದಲ್ಲಿ ಅನೇಕ ಶೆಲ್ ಆಜ್ಞೆಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಬಹುದು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಪ್ರತ್ಯೇಕ ಕಂಟೇನರ್ ಸೆಷನ್ಗಳನ್ನು ಬಳಸಿ ಅವುಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಪ್ರತಿ ಸೆಷನ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ ಮತ್ತು API ಆ ಸ್ಟ್ರೀಮ್ಗಳನ್ನು ಸಂದರ್ಭವಾಗಿ ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಟೂಲ್ ಔಟ್ಪುಟ್ಗಳಾಗಿ ಮಲ್ಟಿಪ್ಲೆಕ್ಸ್ ಮಾಡುತ್ತದೆ. ಬೇರೆ ಮಾತಿನಲ್ಲಿ, ಏಜೆಂಟ್ ಲೂಪ್ ಫೈಲ್ಗಳನ್ನು ಹುಡುಕುವುದು, ಡೇಟಾವನ್ನು ಪಡೆಯುವುದು ಮತ್ತು ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಮಾನ್ಯಗೊಳಿಸುವುದು ಮುಂತಾದ ಕೆಲಸಗಳನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸಬಹುದು.
ಆಜ್ಞೆಯು ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಅಥವಾ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವಾಗ, ಶೆಲ್ ಔಟ್ಪುಟ್ ತುಂಬಾ ದೊಡ್ಡದಾಗಬಹುದು ಮತ್ತು ಉಪಯುಕ್ತ ಸಂಕೇತಗಳನ್ನು ಸೇರಿಸದೇ ಸಂದರ್ಭ ಬಜೆಟ್ಗಳನ್ನು ಬಳಸಿ ಮುಗಿಸಬಹುದು. ಇದನ್ನು ನಿಯಂತ್ರಿಸಲು, ಮಾಡೆಲ್ ಪ್ರತಿ ಆಜ್ಞೆಗೆ ಔಟ್ಪುಟ್ ಮಿತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಆ ಮಿತಿಯನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಔಟ್ಪುಟ್ನ ಆರಂಭ ಮತ್ತು ಅಂತ್ಯ ಎರಡನ್ನೂ ಉಳಿಸುವ ಮಿತಿಗೊಳಿಸಿದ ಫಲಿತಾಂಶವನ್ನು ಮರಳಿಸುತ್ತದೆ, ಜೊತೆಗೆ ಬಿಡಲಾದ ವಿಷಯವನ್ನು ಗುರುತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಔಟ್ಪುಟ್ ಅನ್ನು 1,000 ಅಕ್ಷರಗಳಿಗೆ ಮಿತಿಗೊಳಿಸಬಹುದು, ಆರಂಭ ಮತ್ತು ಅಂತ್ಯವನ್ನು ಉಳಿಸಿಕೊಂಡು:
ಆರಂಭದಲ್ಲಿ ಪಠ್ಯ ... 1000 ಅಕ್ಷರಗಳನ್ನು ಕಡಿತಗೊಳಿಸಲಾಗಿದೆ ... ಅಂತ್ಯದಲ್ಲಿ ಪಠ್ಯ
ಒಟ್ಟಾಗಿ, ಸಮಕಾಲೀನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಮಿತಿಗೊಳಿಸಿದ ಔಟ್ಪುಟ್ ಏಜೆಂಟ್ ಲೂಪ್ ಅನ್ನು ವೇಗವಾಗಿಯೂ ಸನ್ನಿವೇಶ-ಕಾರ್ಯಕ್ಷಮವಾಗಿಯೂ ಮಾಡುತ್ತವೆ, ಆದ್ದರಿಂದ ಮಾಡೆಲ್ ಕಚ್ಚಾ ಟರ್ಮಿನಲ್ ಲಾಗ್ಗಳಿಂದ ಮಿಗಿಲಾಗಿ ಒತ್ತಡಗೊಳ್ಳುವ ಬದಲು ಸಂಬಂಧಿತ ಫಲಿತಾಂಶಗಳ ಮೇಲೆ ರೀಜನಿಂಗ್ ಮುಂದುವರಿಸಬಹುದು.
ಏಜೆಂಟ್ ಲೂಪ್ಗಳೊಂದಿಗಿನ ಒಂದು ಸಾಧ್ಯ ಸಮಸ್ಯೆ ಎಂದರೆ ಕಾರ್ಯಗಳು ದೀರ್ಘಕಾಲದವರೆಗೆ ನಡೆಯುತ್ತವೆ. ದೀರ್ಘಕಾಲ ನಡೆಯುವ ಕಾರ್ಯಗಳು ಸಂದರ್ಭ ವಿಂಡೋವನ್ನು ತುಂಬುತ್ತವೆ, ಇದು ತಿರುವುಗಳಾದ್ಯಂತ ಮತ್ತು ಏಜೆಂಟ್ಗಳಾದ್ಯಂತ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸಲು ಮುಖ್ಯವಾಗಿದೆ. ಒಂದು ಏಜೆಂಟ್ ಒಂದು ಸ್ಕಿಲ್ ಅನ್ನು ಕರೆದು, ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆದು, ಟೂಲ್ ಕಾಲ್ಗಳು ಮತ್ತು ರೀಜನಿಂಗ್ ಸಾರಾಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತಿರುವುದನ್ನು ಕಲ್ಪಿಸಿ, ಸೀಮಿತ ಸಂದರ್ಭ ವಿಂಡೋ ಶೀಘ್ರವೇ ತುಂಬುತ್ತದೆ. ಏಜೆಂಟ್ ಮುಂದುವರಿದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವಾಗ ಪ್ರಮುಖ ಸಂದರ್ಭವನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದನ್ನು ತಪ್ಪಿಸಲು, ಮುಖ್ಯ ವಿವರಗಳನ್ನು ಉಳಿಸಿಕೊಂಡು ಅನಗತ್ಯವಾದ ಯಾವುದನ್ನಾದರೂ ತೆಗೆದುಹಾಕುವ ಮಾರ್ಗ ನಮಗೆ ಬೇಕಾಗಿದೆ. ಡೆವಲಪರ್ಗಳು ಕಸ್ಟಮ್ ಸಾರಾಂಶೀಕರಣ ಅಥವಾ ಸ್ಥಿತಿ-ಕೊಂಡೊಯ್ಯುವ ವ್ಯವಸ್ಥೆಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿ ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿರುವ ಬದಲು, ಮಾಡೆಲ್ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಅದಕ್ಕೆ ಹೇಗೆ ತರಬೇತಿ ನೀಡಲಾಗಿದೆ ಎಂಬುದಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಯಲ್ಲಿ ನಾವು ನೇಟಿವ್ ಸಂಕ್ಷೇಪಣೆಯನ್ನು ಸೇರಿಸಿದ್ದೇವೆ.
ನಮ್ಮ ಇತ್ತೀಚಿನ ಮಾಡೆಲ್ಗಳು ಹಿಂದಿನ ಸಂಭಾಷಣೆ ಸ್ಥಿತಿಯನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಎನ್ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಟೋಕನ್-ಎಫಿಷಿಯಂಟ್ ಪ್ರತಿನಿಧಾನದಲ್ಲಿ ಪ್ರಮುಖ ಹಿಂದಿನ ಸ್ಥಿತಿಯನ್ನು ಕಾಪಾಡುವ ಸಂಕ್ಷೇಪಣೆ ಐಟಂ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ತರಬೇತುಗೊಂಡಿವೆ. ಸಂಕ್ಷೇಪಣೆಯ ನಂತರ, ಮುಂದಿನ ಸಂದರ್ಭ ವಿಂಡೋ ಈ ಸಂಕ್ಷೇಪಣೆ ಐಟಂ ಮತ್ತು ಹಿಂದಿನ ವಿಂಡೋದ ಹೆಚ್ಚಿನ-ಮೌಲ್ಯದ ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದು ವಿಂಡೋ ಗಡಿಗಳಾದ್ಯಂತವೂ ವರ್ಕ್ಫ್ಲೋಗಳು ಸಮ್ಮತವಾಗಿ ಮುಂದುವರಿಯಲು ಅನುಮತಿಸುತ್ತದೆ, ವಿಸ್ತೃತ ಬಹು-ಹಂತದ ಮತ್ತು ಉಪಕರಣ-ಆಧಾರಿತ ಸೆಷನ್ಗಳಲ್ಲಿಯೂ ಸಹ. Codex ಈ ಯಾಂತ್ರಿಕತೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ ದೀರ್ಘಕಾಲೀನ ಕೋಡಿಂಗ್ ಕಾರ್ಯಗಳು ಮತ್ತು ಪುನರಾವರ್ತಿತ ಸಾಧನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಗುಣಮಟ್ಟ ಕುಗ್ಗಿಸದೆ ನಿರ್ವಹಿಸಲು.
ಕಾಂಪ್ಯಾಕ್ಷನ್ ಸರ್ವರ್ನಲ್ಲಿ ಬಿಲ್ಟ್-ಇನ್ ಆಗಿ ಅಥವಾ ಸ್ವತಂತ್ರ `/compact` ಎಂಡ್ಪಾಯಿಂಟ್ ಮೂಲಕ ಲಭ್ಯವಿದೆ. ಸರ್ವರ್-ಸೈಡ್ ಕಾಂಪ್ಯಾಕ್ಷನ್ ನಿಮಗೆ ಒಂದು ಥ್ರೆಶೋಲ್ಡ್ ಅನ್ನು ಸಂರಚಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ ಮತ್ತು ಸಿಸ್ಟಮ್ ಕಾಂಪ್ಯಾಕ್ಷನ್ ಸಮಯವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, ಸಂಕೀರ್ಣ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಲಾಜಿಕ್ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ. ಇದು ಸಂಕ್ಷೇಪಣೆಗೆ ಮೊದಲು ತಕ್ಷಣ ಸಂಭವಿಸುವ ಸಣ್ಣ ಮಿತಿಮೀರಿಕೆಗಳನ್ನು ಸಹಿಸಲು ಸ್ವಲ್ಪ ದೊಡ್ಡ ಪರಿಣಾಮಕಾರಿ ಇನ್ಪುಟ್ ಸಂದರ್ಭ ವಿಂಡೋವನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಮಿತಿಯ ಸಮೀಪದಲ್ಲಿರುವ ವಿನಂತಿಗಳನ್ನು ತಿರಸ್ಕರಿಸುವ ಬದಲು ಇನ್ನೂ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಸಂಕ್ಷೇಪಿಸಬಹುದು. ಮಾಡೆಲ್ ತರಬೇತಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದ್ದಂತೆ, ಪ್ರತಿಯೊಂದು OpenAI ಮಾಡೆಲ್ ಬಿಡುಗಡೆಗೂ ಜೊತೆಯಾಗಿ ನೇಟಿವ್ ಸಂಕ್ಷೇಪಣೆ ಪರಿಹಾರವೂ ವಿಕಸನಗೊಳ್ಳುತ್ತದೆ.
Codex ಸಂಕ್ಷೇಪಣೆ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡಿತು, ಜೊತೆಗೆ ಅದರ ಆರಂಭಿಕ ಬಳಕೆದಾರನಾಗಿ ಸಹ ಕಾರ್ಯನಿರ್ವಹಿಸಿತು. ಒಂದು Codex ಉದಾಹರಣೆ ಕಾಂಪ್ಯಾಕ್ಷನ್ ದೋಷವನ್ನು ಎದುರಿಸಿದಾಗ, ನಾವು ತನಿಖೆ ಮಾಡಲು ಎರಡನೇ ಉದಾಹರಣೆಯನ್ನು ಸ್ಪಿನ್ ಅಪ್ ಮಾಡುತ್ತಿದ್ದೆವು. ಫಲಿತಾಂಶವೆಂದರೆ, ಸಮಸ್ಯೆಯ ಮೇಲೆ ಕೆಲಸ ಮಾಡುವುದರಿಂದಲೇ Codex ಗೆ ನೇಟಿವ್, ಪರಿಣಾಮಕಾರಿ ಸಂಕ್ಷೇಪಣೆ ವ್ಯವಸ್ಥೆ ದೊರಕಿತು. Codex ತನ್ನನ್ನೇ ಪರಿಶೀಲಿಸಿ ಪರಿಷ್ಕರಿಸಿಕೊಳ್ಳುವ ಈ ಸಾಮರ್ಥ್ಯವು OpenAI ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರ ವಿಶೇಷವಾಗಿ ಆಸಕ್ತಿದಾಯಕ ಭಾಗವಾಗಿ ಪರಿಣಮಿಸಿದೆ. ಬಹುತೇಕ ಟೂಲ್ಗಳಿಗೆ ಬಳಕೆದಾರರು ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ಕಲಿಯುವುದು ಮಾತ್ರ ಅಗತ್ಯ; Codex ನಮ್ಮ ಜೊತೆಯಲ್ಲಿ ಕಲಿಯುತ್ತದೆ.
ಈಗ, ಸ್ಥಿತಿ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ನೋಡೋಣ. ಕಂಟೇನರ್ ಕಮಾಂಡ್ಗಳನ್ನು ರನ್ ಮಾಡಲು ಮಾತ್ರವಲ್ಲ, ಮಾಡೆಲ್ಗಾಗಿ ಕೆಲಸದ ಸಂದರ್ಭವೂ ಆಗಿದೆ. ಕಂಟೇನರ್ ಒಳಗೆ, ಮಾಡೆಲ್ ಫೈಲ್ಗಳನ್ನು ಓದಬಹುದು, ಡೇಟಾಬೇಸ್ಗಳನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು ಮತ್ತು ನೆಟ್ವರ್ಕ್ ನೀತಿ ನಿಯಂತ್ರಣಗಳ ಅಡಿಯಲ್ಲಿ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
ಕಂಟೇನರ್ ಸಂದರ್ಭದ ಮೊದಲ ಭಾಗವು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಲು, ಸಂಘಟಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಬಳಸುವ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಆಗಿದೆ. ಲಭ್ಯವಿರುವ ಡೇಟಾದ ನಕ್ಷೆಯನ್ನು ಮಾಡೆಲ್ಗೆ ನೀಡಲು ಮತ್ತು ವ್ಯಾಪಕ, ಶಬ್ದಭರಿತ ಸ್ಕ್ಯಾನ್ಗಳನ್ನು ಮಾಡುವ ಬದಲು ಗುರಿಯಿಟ್ಟ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡಲು ನಾವು ಕಂಟೇನರ್ ಮತ್ತು ಫೈಲ್(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) APIಗಳನ್ನು ನಿರ್ಮಿಸಿದ್ದೇವೆ.
ಸಾಮಾನ್ಯ ತಡೆ ಪ್ಯಾಟರ್ನ್ ಎಂದರೆ ಎಲ್ಲಾ ಇನ್ಪುಟ್ ಅನ್ನು ನೇರವಾಗಿ ಪ್ರಾಂಪ್ಟ್ ಸಂದರ್ಭಕ್ಕೆ ತುಂಬುವುದು. ಇನ್ಪುಟ್ಗಳು ಹೆಚ್ಚಾದಂತೆ, ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಅತಿಯಾಗಿ ತುಂಬುವುದು ದುಬಾರಿಯಾಗುತ್ತದೆ ಮತ್ತು ಮಾಡೆಲ್ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಉತ್ತಮ ಮಾದರಿಯೆಂದರೆ ಕಂಟೇನರ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ನಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ಟೇಜ್ ಮಾಡಿ, ಶೆಲ್ ಆಜ್ಞೆಗಳ ಮೂಲಕ ಏನು ತೆರೆಯಬೇಕು, ಪಾರ್ಸ್ ಮಾಡಬೇಕು ಅಥವಾ ಪರಿವರ್ತಿಸಬೇಕು ಎಂಬುದನ್ನು ಮಾಡೆಲ್ ನಿರ್ಧರಿಸಲು ಬಿಡುವುದು. ಮಾನವರಂತೆ, ಮಾಡೆಲ್ಗಳು ಸಹ ಸಂಘಟಿತ ಮಾಹಿತಿಯೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ.
ಕಂಟೇನರ್ ಸಂದರ್ಭದ ಎರಡನೇ ಭಾಗವು ಡೇಟಾಬೇಸ್ಗಳು. ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಡೆವಲಪರ್ಗಳು ರಚಿತ ಡೇಟಾವನ್ನು ಡೇಟಾಬೇಸ್ಗಳಲ್ಲಿ SQLite ಆಗಿ ಸಂಗ್ರಹಿಸಿ ಅವುಗಳನ್ನು ಪ್ರಶ್ನಿಸುವಂತೆ ನಾವು ಸೂಚಿಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ಸಂಪೂರ್ಣ ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಅನ್ನು ಪ್ರಾಂಪ್ಟ್ಗೆ ಕಾಪಿ ಮಾಡುವ ಬದಲು, ನೀವು ಮಾಡೆಲ್ಗೆ ಟೇಬಲ್ಗಳ ವಿವರಣೆಯನ್ನು—ಯಾವ ಕಾಲಮ್ಗಳು ಇವೆ ಮತ್ತು ಅವುಗಳ ಅರ್ಥ ಏನು—ನೀಡಬಹುದು ಮತ್ತು ಅದಕ್ಕೆ ಬೇಕಾದ ಸಾಲುಗಳನ್ನು ಅದು ತೆಗೆದುಕೊಳ್ಳಲು ಬಿಡಬಹುದು.
ಉದಾಹರಣೆಗೆ, ನೀವು, “ಈ ತ್ರೈಮಾಸಿಕದಲ್ಲಿ ಯಾವ ಉತ್ಪನ್ನಗಳ ಮಾರಾಟ ಕುಸಿತಗೊಂಡಿದೆ?” ಎಂದು ಕೇಳಿದರೆ, ಮಾಡೆಲ್ ಸಂಪೂರ್ಣ ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವ ಬದಲು ಕೇವಲ ಸಂಬಂಧಿತ ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಕ್ವೆರಿ ಮಾಡಬಹುದು. ಇದು ವೇಗವಾಗಿ, ಕಡಿಮೆ ವೆಚ್ಚದಲ್ಲಿ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳಿಗೆ ಹೆಚ್ಚು ವಿಸ್ತರಿಸಬಹುದಾಗಿದೆ.
ಕಂಟೇನರ್ ಕಾಂಟೆಕ್ಸ್ಟ್ನ ಮೂರನೇ ಭಾಗವು ನೆಟ್ವರ್ಕ್ ಪ್ರವೇಶವಾಗಿದೆ, ಇದು ಏಜೆಂಟ್ ವರ್ಕ್ಲೋಡ್ಗಳ ಅತ್ಯಗತ್ಯ ಭಾಗವಾಗಿದೆ. ಏಜೆಂಟ್ ವರ್ಕ್ಫ್ಲೋಗೆ ಲೈವ್ ಡೇಟಾವನ್ನು ಪಡೆಯಬೇಕಾಗಬಹುದು, ಬಾಹ್ಯ APIಗಳನ್ನು ಕರೆ ಮಾಡಬೇಕಾಗಬಹುದು ಅಥವಾ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಇನ್ಸ್ಟಾಲ್ ಮಾಡಬೇಕಾಗಬಹುದು. ಅದೇ ಸಮಯದಲ್ಲಿ, ಕಂಟೇನರ್ಗಳಿಗೆ ನಿರ್ಬಂಧರಹಿತ ಇಂಟರ್ನೆಟ್ ಪ್ರವೇಶ ನೀಡುವುದು ಅಪಾಯಕಾರಿಯಾಗಬಹುದು: ಅದು ಮಾಹಿತಿಯನ್ನು ಬಾಹ್ಯ ವೆಬ್ಸೈಟ್ಗಳಿಗೆ ಬಹಿರಂಗಪಡಿಸಬಹುದು, ಸಂವೇದನಶೀಲ ಆಂತರಿಕ ಅಥವಾ ತೃತೀಯ-ಪಕ್ಷ ಸಿಸ್ಟಮ್ಗಳನ್ನು ಅನಾಯಾಸವಾಗಿ ಸ್ಪರ್ಶಿಸಬಹುದು ಅಥವಾ ಕ್ರೆಡೆನ್ಶಿಯಲ್ ಸೋರಿಕೆಗಳು ಮತ್ತು ಡೇಟಾ ಎಕ್ಸ್ಫಿಲ್ಟ್ರೇಷನ್ ವಿರುದ್ಧ ರಕ್ಷಣೆ ಕಷ್ಟವಾಗಿಸಬಹುದು.
ಏಜೆಂಟ್ಗಳ ಉಪಯುಕ್ತತೆಯನ್ನು ಮಿತಿಗೊಳಿಸದೆ ಈ ಚಿಂತೆಗಳನ್ನು ಪರಿಹರಿಸಲು, ಸೈಡ್ಕಾರ್ ಇಗ್ರೆಸ್ ಪ್ರಾಕ್ಸಿಯನ್ನು ಬಳಸಲು ನಾವು ಹೋಸ್ಟೆಡ್ ಕಂಟೇನರ್ಗಳನ್ನು ನಿರ್ಮಿಸಿದ್ದೇವೆ. ಎಲ್ಲಾ ಔಟ್ಬೌಂಡ್ ನೆಟ್ವರ್ಕ್ ವಿನಂತಿಗಳು ಅನುಮತಿ ಪಟ್ಟಿಗಳು ಮತ್ತು ಪ್ರವೇಶ ನಿಯಂತ್ರಣಗಳನ್ನು ಜಾರಿಗೆ ತರುವುದರ ಜೊತೆಗೆ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಗೋಚರವಾಗಿರಿಸುವ ಕೇಂದ್ರಿತ ನೀತಿ ಪದರದ ಮೂಲಕ ಹರಿಯುತ್ತವೆ. ರುಜುವಾತುಗಳಿಗಾಗಿ, ನಾವು ಎಗ್ರೆಸ್ನಲ್ಲಿ ಡೊಮೇನ್-ವ್ಯಾಪ್ತಿಯ ಸೀಕ್ರೆಟ್ ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಮಾಡೆಲ್ ಮತ್ತು ಕಂಟೇನರ್ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ಗಳನ್ನು ಮಾತ್ರ ನೋಡುತ್ತವೆ, ಆದರೆ ಕಚ್ಚಾ ಸೀಕ್ರೆಟ್ ಮೌಲ್ಯಗಳು ಮಾಡೆಲ್ಗೆ ಗೋಚರಿಸುವ ಸಂದರ್ಭದ ಹೊರಗೇ ಉಳಿಯುತ್ತವೆ ಮತ್ತು ಅನುಮೋದಿತ ಗಮ್ಯಸ್ಥಾನಗಳಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸಲಾಗುತ್ತವೆ. ಇದು ಲೀಕೆಜ್ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಜೊತೆಗೆ ಇನ್ನೂ ದೃಢೀಕೃತ ಬಾಹ್ಯ ಕರೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ಶೆಲ್ ಆಜ್ಞೆಗಳು ಶಕ್ತಿಶಾಲಿಯಾಗಿವೆ, ಆದರೆ ಅನೇಕ ಕಾರ್ಯಗಳು ಅದೇ ಬಹು-ಹಂತದ ಮಾದರಿಗಳನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತವೆ. ಏಜೆಂಟ್ಗಳು ಪ್ರತಿಯೊಂದು ರನ್ನಲ್ಲಿ ವರ್ಕ್ಫ್ಲೋವನ್ನು ಮರುಶೋಧಿಸಬೇಕಾಗುತ್ತದೆ—ಮರುಯೋಜನೆ ಮಾಡುವುದು, ಕಮಾಂಡ್ಗಳನ್ನು ಮರುಜಾರಿ ಮಾಡುವುದು ಮತ್ತು ಸಂಪ್ರದಾಯಗಳನ್ನು ಮರುಕಲಿಯುವುದು—ಇದರಿಂದ ಅಸಂಗತ ಫಲಿತಾಂಶಗಳು ಮತ್ತು ವ್ಯರ್ಥವಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಉಂಟಾಗುತ್ತದೆ. ಏಜೆಂಟ್ ಕೌಶಲ್ಯಗಳು(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಆ ಪ್ಯಾಟರ್ನ್ಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ, ಸಂಯೋಜಿಸಬಹುದಾದ ನಿರ್ಮಾಣ ಘಟಕಗಳಾಗಿ ಪ್ಯಾಕೇಜ್ ಮಾಡುತ್ತವೆ. ನಿಖರವಾಗಿ ಹೇಳುವುದಾದರೆ, ಒಂದು ಕೌಶಲ್ಯವು ‘SKILL.md(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ)’ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಫೋಲ್ಡರ್ ಬಂಡಲ್ ಆಗಿದೆ (ಮೆಟಾಡೇಟಾ ಮತ್ತು ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ) ಜೊತೆಗೆ API ಸ್ಪೆಕ್ಸ್ ಮತ್ತು UI ಆಸ್ತಿಗಳಂತಹ ಯಾವುದೇ ಬೆಂಬಲಿಸುವ ಸಂಪನ್ಮೂಲಗಳು.
ಈ ರಚನೆ ನಾವು ಹಿಂದೆಯೇ ವಿವರಿಸಿದ ರನ್ಟೈಮ್ ವಾಸ್ತುಶಿಲ್ಪಕ್ಕೆ ಸಹಜವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. ಕಂಟೇನರ್ ಸ್ಥಿರ ಫೈಲ್ಗಳು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಶೆಲ್ ಉಪಕರಣವು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಎರಡೂ ಸಿದ್ಧವಾಗಿರುವುದರಿಂದ, ಮಾಡೆಲ್ ಅಗತ್ಯವಿದ್ದಾಗ ಶೆಲ್ ಆಜ್ಞೆಗಳು (`ls`, `cat`, etc.) ಬಳಸಿ ಕೌಶಲ್ಯ ಫೈಲ್ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು, ಸೂಚನೆಗಳನ್ನು ಅರ್ಥೈಸಬಹುದು ಮತ್ತು ಅದೇ ಏಜೆಂಟ್ ಲೂಪ್ನಲ್ಲಿ ಕೌಶಲ್ಯ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
OpenAI ಪ್ಲ್ಯಾಟ್ಫಾರ್ಮ್ನಲ್ಲಿ ಕೌಶಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಾವು API(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಗಳನ್ನು ಒದಗಿಸುತ್ತೇವೆ. ಡೆವಲಪರ್ಗಳು ಕೌಶಲ್ಯ ಫೋಲ್ಡರ್ಗಳನ್ನು ಆವೃತ್ತಿಯ ಬಂಡಲ್ಗಳಾಗಿ ಅಪ್ಲೋಡ್ ಮಾಡಿ ಸಂಗ್ರಹಿಸುತ್ತಾರೆ, ಅವುಗಳನ್ನು ನಂತರ ಕೌಶಲ್ಯ ID ಮೂಲಕ ಹಿಂಪಡೆಯಬಹುದು. ಮಾಡೆಲ್ಗೆ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಕಳುಹಿಸುವ ಮೊದಲು, ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಕೌಶಲ್ಯವನ್ನು ಲೋಡ್ ಮಾಡಿ ಅದನ್ನು ಮಾಡೆಲ್ ಸಂದರ್ಭದಲ್ಲಿಗೆ ಸೇರಿಸುತ್ತದೆ. ಈ ಅನುಕ್ರಮವು ನಿರ್ಧಿಷ್ಟವಾಗಿದೆ:
- ಹೆಸರು ಮತ್ತು ವಿವರಣೆಯನ್ನು ಒಳಗೊಂಡಂತೆ ಕೌಶಲ್ಯ ಮೆಟಾಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ.
- ಕೌಶಲ್ಯ ಬಂಡಲ್ ಅನ್ನು ಪಡೆಯಿರಿ, ಅದನ್ನು ಕಂಟೇನರ್ಗೆ ಕಾಪಿ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿ.
- ಕೌಶಲ್ಯ ಮೆಟಾಡೇಟಾ ಮತ್ತು ಕಂಟೇನರ್ ಪಾತ್ನೊಂದಿಗೆ ಮಾಡೆಲ್ ಸಂದರ್ಭವನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಿ.
ಒಂದು ಕೌಶಲ್ಯವು ಸಂಬಂಧಿತವಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವಾಗ, ಮಾಡೆಲ್ ಕ್ರಮೇಣ ಅದರ ಸೂಚನೆಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ ಮತ್ತು ಕಂಟೇನರ್ನಲ್ಲಿ ಶೆಲ್ ಆಜ್ಞೆಗಳ ಮೂಲಕ ಅದರ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
ಎಲ್ಲಾ ಭಾಗಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಿ ಹೇಳುವುದಾದರೆ: ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಆರ್ಕೆಸ್ಟ್ರೇಷನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಶೆಲ್ ಟೂಲ್ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಹೊಸ್ಟೆಡ್ ಕಂಟೇನರ್ ಸ್ಥಿರ ರನ್ಟೈಮ್ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಕೌಶಲ್ಯಗಳ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ವರ್ಕ್ಫ್ಲೋ ತರ್ಕವನ್ನು ಪದರಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸಂಕ್ಷೇಪಣೆ ಒಂದು ಏಜೆಂಟ್ಗೆ ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭದೊಂದಿಗೆ ದೀರ್ಘಕಾಲ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ.
ಈ ಪ್ರಿಮಿಟಿವ್ಗಳೊಂದಿಗೆ, ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಅಂತ್ಯದಿಂದ ಅಂತ್ಯಕ್ಕೆ ವರ್ಕ್ಫ್ಲೋ ಆಗಿ ವಿಸ್ತರಿಸಬಹುದು: ಸರಿಯಾದ ಕೌಶಲ್ಯವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು, ಡೇಟಾವನ್ನು ಪಡೆದುಕೊಳ್ಳುವುದು, ಅದನ್ನು ಸ್ಥಳೀಯ ರಚಿತ ಸ್ಥಿತಿಯಾಗಿ ಪರಿವರ್ತಿಸುವುದು, ಅದನ್ನು ದಕ್ಷವಾಗಿ ಕ್ವೇರಿ ಮಾಡುವುದು ಮತ್ತು ಬಾಳಿಕೆ ಬರುವ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ಗಳನ್ನು ರಚಿಸುವುದು.
ಕೆಳಗಿನ ರೇಖಾಚಿತ್ರವು ಲೈವ್ ಡೇಟಾದಿಂದ ಸ್ಪ್ರೆಡ್ಶೀಟ್ ರಚಿಸಲು ಈ ಸಿಸ್ಟಮ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.
ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಒಂದು ಏಜೆಂಟಿಕ್ ಕಾರ್ಯವನ್ನು ಆಯೋಜಿಸುತ್ತದೆ
ಶೆಲ್ ಟೂಲ್ ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ಅನ್ನು ಎಂಡ್-ಟು-ಎಂಡ್ ವರ್ಕ್ಫ್ಲೋಗಳಿಗಾಗಿ ಸಂಯೋಜಿಸುವ ಆಳವಾದ ಉದಾಹರಣೆಗೆ, ಪ್ರತಿಕ್ರಿಯೆಗಳ API ಮೂಲಕ ಒಂದು ಸ್ಕಿಲ್ ಅನ್ನು ಪ್ಯಾಕೇಜ್ ಮಾಡಿ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ವಿವರಿಸುವ ನಮ್ಮ ಡೆವಲಪರ್ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಮತ್ತು ಕುಕ್ಬುಕ್(ಹೊಸ ಕಿಟಕಿಯಲ್ಲಿ ತೆರೆಯುತ್ತದೆ) ಅನ್ನು ನೋಡಿ.
ಈ ಪ್ರಿಮಿಟಿವ್ಗಳ ಸೆಟ್ನೊಂದಿಗೆ ಡೆವಲಪರ್ಗಳು ಏನು ನಿರ್ಮಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೋಡಲು ನಾವು ಉತ್ಸುಕರಾಗಿದ್ದೇವೆ. ಭಾಷಾ ಮಾಡೆಲ್ಗಳು ಪಠ್ಯ, ಚಿತ್ರಗಳು ಮತ್ತು ಆಡಿಯೊವನ್ನು ರಚಿಸುವುದಕ್ಕಿಂತಲೂ ಹೆಚ್ಚಿನದನ್ನು ಮಾಡಲು ಉದ್ದೇಶಿಸಲ್ಪಟ್ಟಿವೆ–ನಾವು ನಮ್ಮ ವೇದಿಕೆಯನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಸಂಕೀರ್ಣ, ನೈಜ-ಪ್ರಪಂಚದ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸುವಲ್ಲಿ ಇನ್ನಷ್ಟು ಸಮರ್ಥವಾಗುವಂತೆ ಮುಂದುವರಿಸಿ ವಿಕಸನಗೊಳಿಸುತ್ತೇವೆ.
