ai-agents-for-beginners

(ಈ ಪಾಠದ ವೀಡಿಯೋವನ್ನು ನೋಡಲು ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ)

ಎಐ ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಮೆಟಾಕಾಗ್ನಿಷನ್

ಪರಿಚಯ

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

ಕಲಿಕೆಯ ಗುರಿಗಳು

ಈ ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನೀವು ಸಾಧ್ಯವಾಗಲಿದೆ:

ಏಜೆಂಟ್ ನಿರೀಕ್ಷೆಗಳಲ್ಲಿ ತರ್ಕ ಸರಕಿಗಳು ಹೊಂದಿರುವ ಪರಿಣಾಮಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು.
ಆತ್ಮ-ಸರಿ ಮಾಡಿಕೊಳ್ಳುವ ಏಜೆಂಟ್‌ಗಳಿಗೆ ಯೋಜನೆ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ತಂತ್ರಗಳನ್ನು ಬಳಸುವುದು.
ಕಾರ್ಯಗಳನ್ನು ಸಾಧಿಸಲು ಕೋಡ್ ಅನ್ನು ಕManipulateಸುವ ನಿಮ್ಮದೇ ಏಜೆಂಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು.

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಮಾಹಿತಿ

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಎಂಬುದು ತನ್ನದೇ ಯೋಚನೆಯ ಬಗ್ಗೆ ಯೋಚಿಸುವ ಉನ್ನತ ಮಟ್ಟದ ಜ್ಞಾನಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಎಐ ಏಜೆಂಟ್‌ಗಳಿಗಾಗಿ ಇದು ಸ್ವಯಂ ಜಾಗೃತಿ ಮತ್ತು ಮುಂಗಡ ಅನುಭವಗಳ ಆಧಾರದ ಮೇಲೆ ತನ್ನ ಕ್ರಿಯೆಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಸರಿಹೊಂದಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುವುದಾಗಿದೆ. ಮೆಟಾಕಾಗ್ನಿಷನ್, ಅಂದರೆ “ಯೋಚನೆಯ ಬಗ್ಗೆ ಯೋಚನೆ,” ಏಜೆಂಟಿಕ್ ಎಐ ವ್ಯವಸ್ಥೆಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಮಹತ್ವಪೂರ್ಣ ಸಂಪ್ರದಾಯವಾಗಿದೆ. ಇದು ಎಐ ವ್ಯವಸ್ಥೆಗಳು ತಮ್ಮದೇ ಆಂತರಿಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಜಾಗರೂಕಗೊಳ್ಳುವ ಹಾಗೂ ತಮ್ಮ ವರ್ತನೆಯನ್ನು ನೋಡಿಕೊಳ್ಳುವುದು, ನಿಯಂತ್ರಿಸುವುದು ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವುದಕ್ಕೆ ಸಾಧ್ಯವಾಗಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ. ನಾವು ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ನೋಡಿ ಅಥವಾ ಮನಸ್ಸಿನ ಸ್ಥಿತಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಂತೆ. ಈ ಸ್ವಯಂ ಜಾಗೃತಿ ಎಐ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಉತ್ತಮ ನಿರ್ಧಾರಮಾಡುವಲ್ಲಿ, ದೋಷಗಳನ್ನು ಗುರುತಿಸುವಲ್ಲಿ ಮತ್ತು ಸಮಯದೊಂದಿಗೆ ತಮ್ಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುವಲ್ಲಿ ಸಹಾಯ ಮಾಡಬಹುದು- ಟ್ಯೂರಿಂಗ್ ಪರೀಕ್ಷೆ ಹಾಗೂ ಎಐ takeover ಬಗ್ಗೆ ಚರ್ಚೆಗೆ ಪುನಃ ಸಂಪರ್ಕಿಸಿದೆ.

ಏಜೆಂಟಿಕ್ ಎಐ ವ್ಯವಸ್ಥೆಗಳ ಪ್ರেক্ষಾಪದಲ್ಲಿ, ಮೆಟಾಕಾಗ್ನಿಷನ್ ಹಲವು ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ:

ಪಾರದರ್ಶಕತೆ: ಎಐ ವ್ಯವಸ್ಥೆಗಳು ತಮ್ಮ ತರ್ಕ ಮತ್ತು ನಿರ್ಧಾರಗಳನ್ನು ವಿವರಿಸಲು ಸಾಧ್ಯವಾಗಬೇಕು.
ತರ್ಕ: ಎಐ ವ್ಯವಸ್ಥೆಗಳು ಮಾಹಿತಿಯನ್ನು ಸಂಯೋಜಿಸಿ ಒಳ್ಳೆಯ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು.
ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ: ಹೊಸ ಪರಿಸರಗಳು ಮತ್ತು ಬದಲಾಗುವ ಶರತ್ತುಗಳಿಗೆ ಸರಿಹೊಂದುವಿಕೆ.
ಗ್ರಹಿಕೆ: ಪರಿಸರದಿಂದ ಡೇಟಾವನ್ನು ಗುರುತಿಸುವ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ನಿಖರತೆಯ ಬೆಳವಣಿಗೆ.

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅಂದರೆ ಏನು?

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅಥವಾ “ಯೋಚನೆಯ ಬಗ್ಗೆ ಯೋಚನೆ” ಅನ್ನುವುದು ಸ್ವಯಂ ಜಾಗೃತಿ ಮತ್ತು ತನ್ನ ಜ್ಞಾನಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆಗಳ ಸ್ವ-ನಿಯಂತ್ರಣಕ್ಕೇ ಸಂಬಂಧಿಸಿದ ಉನ್ನತ ಮಟ್ಟದ ಜ್ಞಾನಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆ. ಎಐ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಮೆಟಾಕಾಗ್ನಿಷನ್ ಏಜೆಂಟ್‌ಗಳಿಗೆ ತಮ್ಮ ತಂತ್ರಗಳು ಮತ್ತು ಕ್ರಮಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ ಸರಿಹೊಂದಿಸಲು ಶಕ್ತಿ ನೀಡುತ್ತದೆ, ಇದರಿಂದ ಸಮಸ್ಯೆ ನಿವಾರಣೆ ಮತ್ತು ನಿರ್ಧಾರಮಾಡುವ ಸಾಮರ್ಥ್ಯಗಳು ಸುಧಾರಿಸುವುದು. ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅರ್ಥಮಾಡಿಕೊಂಡು, ನೀವು ಹೆಚ್ಚಿನ ಬುದ್ದಿವಂತಿಕೆಗೈಯುವ, ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ದಕ್ಷವಾಗಿರುವ ಎಐ ಏಜೆಂಟ್‌ಗಳನ್ನು ವಿನ್ಯಾಸ ಮಾಡಬಹುದು. ಸತ್ಯ ಮೆಟಾಕಾಗ್ನಿಷನ್‌ನಲ್ಲಿ, ನೀವು ಎಐ ತನ್ನದೇ ತರ್ಕವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಯೋಚಿಸುತ್ತಿರುವುದನ್ನು ನೋಡುತ್ತೀರಿ.

ಉದಾಹರಣೆ: “ನಾನು ಕಡಿಮೆ ಬೆಲೆಯ ವಿಮಾನಗಳನ್ನು ಪ್ರಾಥಮಿಕತೆಯನ್ನಾಡಿದ್ದೇನೆ ಏಕೆಂದರೆ… ನೇರ ವಿಮಾನಗಳನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳುತ್ತಿದ್ದಿರಬಹುದು, ಆದ್ದರಿಂದ ನಾನೆ ಮತ್ತೆ ಪರಿಶೀಲಿಸುವೆ.” ಆಯಾ ಮಾರ್ಗವನ್ನು ಹೇಗೆ ಅಥವಾ ಏಕೆ ಆಯ್ದುಕೊಂಡಿದೆ ಎಂಬುದನ್ನು ಗಮನದಲ್ಲಿಡುವುದು.

ಕಳೆದ ಬಾರಿ ಬಳಕೆದಾರ ಪ್ರಾಧಾನ್ಯತೆಗಳ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿಸಿದ್ದರಿಂದ ದೋಷಗಳನ್ನು ಮಾಡಿದೆ ಎಂದು ಗಮನಿಸಿ, ಆದ್ದರಿಂದ ಅಂತಿಮ ಶಿಫಾರಸ್ಸಿನೇ ಅಲ್ಲದೇ ನಿರ್ಧಾರ ತಂತ್ರವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
ಮಾದರಿಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು, ಉದಾಹರಣೆಗೆ “ಬಳಕೆದಾರರು ‘ಅತಿಯಾಗಿ ಜನಸಂಭ್ರಮ’ ಎಂದು ಹೇಳುವಾಗ ಎರಳಿಗೆ ಕೆಲವು ಆಕರ್ಷಣೆಗಳನ್ನು ತೆಗೆದುಹಾಕುವಂತಾಗದೇ, ಎಲ್ಲಾಗಲೂ ಜನಪ್ರಿಯತೆ ಅನ್ವಯಿಸಿ ‘ಮುಖ್ಯ ಆಕರ್ಷಣೆಗಳನ್ನು’ ಆಯ್ಕೆಮಾಡುವ ವಿಧಾನ ದೋಷಸ್ಪದವಾಗಿದೆ ಎಂದು ಪ್ರತಿಬಿಂಬಿಸುವುದು.”

ಎಐ ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಮೆಟಾಕಾಗ್ನಿಷನ್ ಮಹತ್ವ

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಎಐ ಏಜೆಂಟ್ ವಿನ್ಯಾಸದಲ್ಲಿ ಅನೇಕ ಕಾರಣಗಳಿಗಾಗಿ ಪ್ರಮುಖ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ:

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಮಹತ್ವ

ಸ್ವ-ಪರಿಶೀಲನೆ: ಏಜೆಂಟ್‌ಗಳು ತಮ್ಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೊದಲು ವಿಮರ್ಶಿಸಿ ಉತ್ತಮಗೊಳಿಸಲು ಜಾಗರೂಕಗೊಳ್ಳುತ್ತಾರೆ.
ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ: ಕಳೆದ ಅನುಭವಗಳು ಮತ್ತು ಬದಲಾಗುವ ಪರಿಸರಗಳನ್ನು ಆಧರಿಸಿ ಕಾರ್ಯತಂತ್ರಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.
ದೋಷ ಸರಿಪಡಿ: ಸ್ವಯಂಚಾಲಿತವಾಗಿ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿದು ಸರಿಪಡಿಸುವ ಮೂಲಕ, ಹೆಚ್ಚು ನಿಖರ ಫಲಿತಾಂಶಗಳತ್ತ ಸಾಗುವುದು.
ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ: ಸಮಯ ಮತ್ತು ಗಣಕ ಶಕ್ತಿಯಂತಹ ಸಂಪನ್ಮೂಲಗಳ ಬಳಕೆಯನ್ನು ಯೋಜನೆ ಮತ್ತು ಮೌಲ್ಯಮಾಪನದಿಂದ ಉತ್ತಮಗೊಳಿಸುವುದು.

ಎಐ ಏಜೆಂಟ್‌ನ ಅಂಶಗಳು

ಮೆಟಾಕಾಗ್ನಿಟಿವ್ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಜಿಗಿ ಹೋಗುವುದಕ್ಕೆ ಮುಂಚೆ, ಎಐ ಏಜೆಂಟ್‌ನ അടിസ്ഥാന ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅನಿವಾರ्य. ಒಂದು ಎಐ ಏಜೆಂಟ್ ಸಾಮಾನ್ಯವಾಗಿ ಇವುಗಳಿಂದ ಕೂಡಿರುತ್ತದೆ:

ವ್ಯಕ್ತಿತ್ವ: ಏಜೆಂಟ್‌ನ ವ್ಯಕ್ತಿತ್ವ ಮತ್ತು ಲಕ್ಷಣಗಳು, ಅದು ಬಳಕೆದಾರರೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.
ಉಪಕರಣಗಳು: ಏಜೆಂಟ್‌ಗಳು ನಿರ್ವಹಿಸಬಲ್ಲ ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು.
ಕೌಶಲ್ಯಗಳು: ಏಜೆಂಟ್ ಹೊಂದಿರುವ ಜ್ಞಾನ ಮತ್ತು ಪರಿಣತಿ.

ಈ ಅಂಶಗಳು ಸೇರಿ ವಿಶಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು “ಪರಿಣತಿಮೈಲು ಘಟಕ” ರಚಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ಪ್ರವಾಸ ನಿಯೋಜಕನನ್ನು ಪರಿಗಣಿಸಿ, ಅ ಆತ್ಮಕಾಲೀನ ಡೇಟಾ ಮತ್ತು ಹಿಂದಿನ ಗ್ರಾಹಕರ ಪ್ರಯಾಣ ಅನುಭವಗಳ ಆಧಾರದ ಮೇಲೆ ತನ್ನ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಸುವ ಸೇವೆ.

ಉದಾಹರಣೆ: ಪ್ರವಾಸ ನಿಯೋಜಕ ಸೇವೆಯಲ್ಲಿ ಮೆಟಾಕಾಗ್ನಿಷನ್

ನೀವು ಎಐ ಚಾಲಿತ ಪ್ರವಾಸ ನಿಯೋಜಕ ಸೇವೆಯನ್ನು ವಿನ್ಯಾಸ ಮಾಡುತ್ತಿದ್ದೀರಾ ಎಂದು ಭಾವಿಸಿ. ಈ ಏಜೆಂಟ್ “ಪ್ರವಾಸ ನಿಯೋಜಕ” ಬಳಕೆದಾರರು ತಮ್ಮ ರಜೆಗಳಿಗೆ ಯೋಜನೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಮೆಟಾಕಾಗ್ನಿಷನ್ ಸೇರಿಸಲು, ಪ್ರವಾಸ ನಿಯೋಜಕ ತನ್ನ ಕ್ರಿಯೆಗಳನ್ನು ಸ್ವ-ಜಾಗೃತಿ ಮತ್ತು ಹಿಂದಿನ ಅನುಭವಗಳ ಆಧಾರದ ಮೇಲೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ ಸರಿಹೊಂದಿಸಬೇಕು. ಇಲ್ಲಿದೆ ಮೆಟಾಕಾಗ್ನಿಷನ್ ಹೇಗೆ ಪಾತ್ರ ವಹಿಸಬಹುದು:

ಪ್ರಸ್ತುತ ಕಾರ್ಯ

ಪ್ರಸ್ತುತ ಕಾರ್ಯ ಬಳಕೆದಾರನಿಗೆ ಪ್ಯಾರಿಸ್‌ಗೆ ಪ್ರವಾಸ ಯೋಜಿಸಲು ಸಹಾಯ ಮಾಡುವುದು.

ಕಾರ್ಯ ಪೂರ್ಣಗೊಳಿಸುವ ಹಂತಗಳು

ಬಳಕೆದಾರನ ಪ್ರಾಧಾನ್ಯತೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ: ಪ್ರಯಾಣ ದಿನಾಂಕಗಳು, ಬಜೆಟ್, ಆಸಕ್ತಿಗಳು (ಉದಾ: ಮ್ಯೂಸಿಯಂಗಳು, ಆಹಾರ, ಖರೀದಿ) ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಕೇಳಿ.
ಮಾಹಿತಿಯನ್ನು ತೆಗೆಯಿರಿ: ಬಳಕೆದಾರರ ಪ್ರಾಧಾನ್ಯತೆಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ವಿಮಾನ ಆಯ್ಕೆಗಳು, ವಸತಿಯಿಂದ, ಆಕರ್ಷಣೆಗಳು ಮತ್ತು ಊಟಗಾರರುಗಳನ್ನು ಹುಡುಕಿ.
ಶಿಫಾರಸ್ಸುಗಳನ್ನು ರಚಿಸಿ: ವಿಮಾನ ವಿವರಗಳು, ಹೋಟೆಲ್ ಬುಕ್ಕಿಂಗ್‌ಗಳು ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಲಾದ ಚಟುವಟಿಕೆಗಳೊಂದಿಗೆ ವೈಯಕ್ತಿಕ ಪಠ್ಯಕ್ರಮವನ್ನು ಒದಗಿಸಿ.
ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರದ ಮೇಲೆ ಸರಿಹೊಂದಿಸಿ: ಬಳಕೆದಾರರಿಂದ ಪ್ರತಿಕ್ರಿಯೆ ಕೇಳಿ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ.

ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳು

ವಿಮಾನ ಮತ್ತು ಹೋಟೆಲ್ ಬುಕ್ಕಿಂಗ್ ಡೇಟಾಬೇಸ್‌ಗಳ ಪ್ರವೇಶ.
ಪ್ಯಾರಿಸ್ ಆಕರ್ಷಣೆಗಳು ಮತ್ತು ಊಟಗಾರರ ಮಾಹಿತಿಗಳು.
ಹಿಂದಿನ ಸಂವಹನಗಳಿಂದ ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯ ಡೇಟಾವು.

ಅನುಭವ ಮತ್ತು ಸ್ವ-ಪರಿಶೀಲನೆ

ಪ್ರವಾಸ ನಿಯೋಜಕ ತನ್ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಮತ್ತು ಹಿಂದಿನ ಅನುಭವಗಳಿಂದ ಕಲಿಯಲು ಮೆಟಾಕಾಗ್ನಿಷನ್ ಬಳಕೆ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆ:

ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆ ವಿಶ್ಲೇಷಣೆ: ಯಾವ ಶಿಫಾರಸ್ಸುಗಳು ಸಹಾಯಕವಾಗಿದ್ದವು ಮತ್ತು ಯಾವವು ಸಹಾಯಕವಾಗಿರಲಿಲ್ಲ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಮರ್ಶಿಸುತ್ತದೆ. ಮುಂದೆ ಶಿಫಾರಸುಗಳನ್ನು ಸರಿಹೊಂದಿಸುತ್ತದೆ.
ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ: ಹಿಂದೆ ಬಳಕೆದಾರ “ಜನಸಂಭ್ರಮ ಇರುವ ಜಾಗಗಳು ಇಷ್ಟವಿಲ್ಲ” ಎಂದು ಹೇಳಿದ್ದರೆ, ಪ್ರವಾಸ ನಿಯೋಜಕ ಪ್ರಖ್ಯಾತ ಪ್ರವಾಸಿ ಸ್ಥಳಗಳನ್ನು ಜನಸಂಭ್ರಮ ಸಮಯಗಳಲ್ಲಿ ಶಿಫಾರಸು ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
ದೋಷ ಸರಿಪಡಿ: ತಪ್ಪಾಗಿ ತುಂಬಾ ಬುಕ್ ಆದ ಹೋಟೆಲ್ ಅನ್ನು ಶಿಫಾರಸು ಮಾಡಿರುವುದಾದರೆ, ಮುಂದುವರೆಯುವ ಮೊದಲು ಲಭ್ಯತಾ ಪರಿಶೀಲನೆ ಒಳಗೊಂಡಂತೆ ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸಲು ಕಲಿಯುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಡೆವಲಪರ್ ಉದಾಹರಣೆ

ಮೆಟಾಕಾಗ್ನಿಷನ್‌ನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರವಾಸ ನಿಯೋಜಕ ಕೋಡ್ ಉದಾಹರಣೆ ಹೀಗಿದೆ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # ಪREFERENCE ಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಮಾನ, ಹೋಟೆಲು ಮತ್ತು ಆಕರ್ಷಣೆಗಳನ್ನು ಹುಡುಕಿ
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಮತ್ತು ಭವಿಷ್ಯದ ಶಿಫಾರಸುಗಳನ್ನು ಹೊಂದಿಸಿ
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# ಉದಾಹರಣೆಯ ಬಳಕೆ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

ಮೆಟಾಕಾಗ್ನಿಷನ್ ವ್ಯವಹಾರ

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

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ಪ್ರವಾಸ ನಿಯೋಜಕ ಹೆಚ್ಚು ವೈಯಕ್ತಿಕಗೊಳಿಸಿದ ಮತ್ತು ನಿಖರವಾದ ಪ್ರವಾಸ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಬಹುದು, ಇದರಿಂದ ಒಟ್ಟು ಬಳಕೆದಾರ ಅನುಭವ ಸುಧಾರಿಸುತ್ತದೆ.

2. ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಯೋಜನೆ

ಯೋಜನೆ ಎಐ ಏಜೆಂಟ್ ವರ್ತನೆಯಲ್ಲಿ ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಇದು ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ಅಗತ್ಯವಿರುವ ಹಂತಗಳನ್ನು ನಿರ್ಧರಿಸುವದು, ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ, ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಸಾಧ್ಯವಿರುವ ಅడ్డೇತಲುಗಳನ್ನು ಪರಿಗಣಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ.

ಯೋಜನೆಯ ಅಂಶಗಳು

ಪ್ರಸ್ತುತ ಕಾರ್ಯ: ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಿ.
ಕಾರ್ಯ ಪೂರ್ಣಗೊಳಿಸುವ ಹಂತಗಳು: ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಣೀಯ ಹಂತಗಳಾಗಿ ಹಂಚಿಕೊಳ್ಳಿ.
ಅಗತ್ಯ ಸಂಪನ್ಮೂಲಗಳು: ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಗುರುತಿಸಿ.
ಅನುಭವ: ಹಿಂದಿನ ಅನುಭವಗಳನ್ನು ಯೋಜನೆ ಮಾಡಲು ಬಳಸಿಕೊಳ್ಳಿ.

ಉದಾಹರಣೆ: ಪ್ರವಾಸ ನಿಯೋಜಕನು ಬಳಕೆದಾರನಿಗೆ ಅವರ ಪ್ರಯಾಣವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಯೋಜಿಸಲು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಹಂತಗಳನ್ನು ಇಲ್ಲಿವೆ:

ಪ್ರವಾಸ ನಿಯೋಜಕರ ಹಂತಗಳು

ಬಳಕೆದಾರನ ಪ್ರಾಧಾನ್ಯತೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ
- ಬಳಕೆದಾರನ ಪ್ರಯಾಣ ದಿನಾಂಕಗಳು, ಬಜೆಟ್, ಆಸಕ್ತಿಗಳು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳ ವಿವರಗಳನ್ನು ಕೇಳಿ.
- ಉದಾಹರಣೆಗಳು: “ನೀವು ಯಾವಾಗ ಪ್ರಯಾಣ ಮಾಡಲು ಯೋಚಿಸುತ್ತಿದ್ದೀರಿ?” “ನಿಮ್ಮ ಬಜೆಟ್ ಶ್ರೇಣಿ ಏನು?” “ರಜೆಯಲ್ಲಿನ ಯಾವ ಚಟುವಟಿಕೆಗಳನ್ನು ನೀವು ಆಸ್ವಾದಿಸುತ್ತೀರಿ?”
ಮಾಹಿತಿಯನ್ನು ತೆಗೆಯಿರಿ
- ಬಳಕೆದಾರ ಪ್ರಾಧಾನ್ಯತೆಗಳ ಆಧಾರದ ಮೇಲೆ ಸಂಬಂಧಿತ ಪ್ರಯಾಣ ಆಯ್ಕೆಗಳು ಹುಡುಕಿ.
- ವಿಮಾನಗಳು: ಬಳಕೆದಾರನ ಬಜೆಟ್ ಮತ್ತು ಪ್ರಯಾಣ ದಿನಾಂಕಗಳಿಗೆ ಹೊಂದಿಕೊಂಡಿರುವ ವಿಮಾನಗಳನ್ನು ಹುಡುಕಿ.
- ವಸತಿ: ಸ್ಥಳ, ಬೆಲೆ ಮತ್ತು ಸೌಕರ್ಯಗಳಿಗೆ ಅನುಗುಣವಾದ ಹೋಟೆಲುಗಳು ಅಥವಾ ಬಾಡಿಗೆ ಮನೆಗಳನ್ನು ಹುಡುಕಿ.
- ಆಕರ್ಷಣೆಗಳು ಮತ್ತು ಊಟಗಾರರು: ಬಳಕೆದಾರ ಆಸಕ್ತಿಗೆ ಹೊಂದಿಕೊಂಡಿರುವ ಜನಪ್ರಿಯ ಆಕರ್ಷಣೆಗಳು, ಚಟುವಟಿಕೆಗಳು ಮತ್ತು ಆಹಾರ ಆಯ್ಕೆಗಳು.
ಶಿಫಾರಸುಗಳನ್ನು ರಚಿಸಿ
- ಸಂಗ್ರಹಿಸಿದ ಮಾಹಿತಿಯನ್ನು ವೈಯಕ್ತಿಕ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ಸಂಯೋಜಿಸಿ.
- ವಿಮಾನ ಆಯ್ಕೆಗಳು, ಹೋಟೆಲ್ ಬುಕ್ಕಿಂಗ್‌ಗಳು ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಲಾದ ಚಟುವಟಿಕೆಗಳ ವಿವರಗಳನ್ನು ಒದಗಿಸಿ, ಬಳಕೆದಾರರ ಪ್ರಾಧಾನ್ಯತೆಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಸುಧಾರಿಸಿ.
ಬಳಕೆದಾರನಿಗೆ ಪಠ್ಯಕ್ರಮವನ್ನು present ಮಾಡಿ
- ಪ್ರಸ್ತಾಪಿತ ಪಠ್ಯಕ್ರಮವನ್ನು ಬಳಕೆದಾರನ ವಿಮರ್ಶೆಗೆ ಹಂಚಿಕೊಳ್ಳಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ಯಾರಿಸಿಗೆ ಪ್ರಯಾಣಕ್ಕೆ ಇಲ್ಲಿದೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಪಠ್ಯಕ್ರಮ. ಇದರಲ್ಲಿ ವಿಮಾನ ವಿವರಗಳು, ಹೋಟೆಲ್ ಬುಕ್ಕಿಂಗ್‌ಗಳು ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಿದ ಚಟುವಟಿಕೆಗಳು ಮತ್ತು ಊಟಗಾರರ ಪಟ್ಟಿವೆ. ನಿಮ್ಮ ಅಭಿಪ್ರಾಯ ಹೇಳಿ!”
ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸಂಗ್ರಹಿಸಿ
- ಪ್ರಸ್ತಾಪಿತ ಪಠ್ಯಕ್ರಮದ ಬಗ್ಗೆ ಬಳಕೆದಾರನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕೇಳಿ.
- ಉದಾಹರಣೆಗಳು: “ನಿಮಗೆ ವಿಮಾನ ಆಯ್ಕೆಗಳು பிடಿಸುತ್ತಿದೆಯೇ?” “ಹೋಟೆಲ್ ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸೂಕ್ತವೇ?” “ನೀವು ಸೇರಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು ಬಯಸುವ ಯಾವುದೇ ಚಟುವಟಿಕೆಗಳಿವೆಯೇ?”
ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರದ ಮೇಲೆ ಸರಿಹೊಂದಿಸಿ
- ಬಳಕೆದಾರನ ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರಿತವಾಗಿ ಪಠ್ಯಕ್ರಮವನ್ನು ಬದಲಾಯಿಸಿ.
- ವಿಮಾನ, ವಸತಿ ಮತ್ತು ಚಟುವಟಿಕೆ ಶಿಫಾರಸುಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಅಗತ್ಯವಾದ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ.
ಅಂತಿಮ ದೃಢೀಕರಣ
- ಬೆಳವಣಿಗೆಯಾದ ಪಠ್ಯಕ್ರಮವನ್ನು ಬಳಕೆದಾರನಿಗೆ ಅಂತಿಮ ದೃಢೀಕರಣಕ್ಕೆ ಒದಗಿಸಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿಕೊಂಡು ಇಲ್ಲಿದೆ ನವೀಕೃತ ಪಠ್ಯಕ್ರಮ. ಎಲ್ಲವೂ ನಿಮಗೆ ತೃಪ್ತಿದಾಯಕವೆನಿಸುತ್ತದೆ?”
ಬುಕ್ಕಿಂಗ್ ಮಾಡಿ ದೃಢೀಕರಿಸಿ
- ಬಳಕೆದಾರನು ಪಠ್ಯಕ್ರಮವನ್ನು ಅನುಮೋದಿಸಿದಾಗ, ವಿಮಾನಗಳು, ವಸತಿ ಮತ್ತು ಪೂರ್ವ ಯೋಜಿತ ಚಟುವಟಿಕೆಗಳ ಬುಕ್ಕಿಂಗ್‌ಗಳನ್ನು ಮುಂದುವರಿಸಿ.
- ದೃಢೀಕರಣ ವಿವರಗಳನ್ನು ಬಳಕೆದಾರನಿಗೆ ಕಳುಹಿಸಿ.
ನಿರಂತರ ಬೆಂಬಲ ಒದಗಿಸಿ
- ಅವರ ಪ್ರಯಾಣದ ವೇಳೆಯಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆಗಳು ಅಥವಾ ಹೆಚ್ಚುವರಿ ವಿನಂತಿಗಳಿಗೆ ಸಹಾಯ ಮಾಡಲು ಲಭ್ಯವಿರಲಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ರಯಾಣದ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವ ಸಹಾಯ ಬೇಕಾದರೂ, ಯಾವುದೇ ಸಮಯದಲ್ಲಾದರೂ ನನ್ನನ್ನು ಸಂಪರ್ಕಿಸಿ!”

ಉದಾಹರಣೆಯ ಸಂವಾದ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# ಬೂಕಿಂಗ್ ವಿನಂತಿಯ ಒಳಗಿನ ಉದಾಹರಣಾ ಬಳಕೆ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. ತಿದ್ದುಪಡಿ RAG ವ್ಯವಸ್ಥೆ

ಮೊದಲಿಗೆ RAG ಉಪಕರಣ ಮತ್ತು ಪ್ರೀ-ಎಂಪ್ಟಿವ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಲೋಡ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ

RAG ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್ ಲೋಡಿಂಗ್

retrieval-Augmented Generation (RAG)

RAG ಒಂದು ವಿಚಾರಣಾ ವ್ಯವಸ್ಥೆಯನ್ನು ಜನರೇಟಿವ್ ಮಾದರಿಯೊಡನೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಒಂದು ಪ್ರಶ್ನೆ ಹಾಕಿದಾಗ, ವಿಚಾರಣಾ ವ್ಯವಸ್ಥೆ ಸಂಬಂಧಿಸಿದ ದಾಖಲೆಗಳು ಅಥವಾ ಡೇಟಾವನ್ನು বহಿರ್ಗತ ಮೂಲದಿಂದ ತರಬೇತು ಮಾಡುತ್ತದೆ, ಮತ್ತು ಈ ತರಬೇತಾದ ಮಾಹಿತಿಯನ್ನು ಜನರೇಟಿವ್ ಮಾದರಿಗೆ ಒಳಪಡಿಸುವ ಮೂಲಕ ಉತ್ತಮವಾಗಿ ಸान್ಧರ್ಭಿಕ ಮತ್ತು ನಿಖರ ಉತ್ತರಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

RAG ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಏಜೆಂಟ್ ಜ್ಞಾನ ಆಧಾರದಿಂದ ಸಂಬಂಧಿಸಿದ ಮಾಹಿತಿಯನ್ನು ತರಬೇತು ಮಾಡಿ ಸೂಕ್ತ ಉತ್ತರಗಳು ಅಥವಾ ಕ್ರಮಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ತಿದ್ದುಪಡಿ RAG ವಿಧಾನ

ತಿದ್ದುಪಡಿ RAG ವಿಧಾನವು ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸಲು ಮತ್ತು ಎಐ ಏಜೆಂಟ್‌ಗಳ ನಿಖರತೆಯನ್ನು ಸುಧಾರಿಸಲು RAG ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಇದರಲ್ಲಿ ಹೀಗೆ ಇದೆ:

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರ: ಏಜೆಂಟ್ ಸಂಬಂಧಿಸಿದ ಮಾಹಿತಿಯನ್ನು ತರಲು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಂಪ್ಟುಗಳನ್ನು ಬಳಸುವುದು.
ಉಪಕರಣ: ಏಜೆಂಟ್ ತರಬೇತು ಮಾಡಿದ ಮಾಹಿತಿಯ ಪ್ರಾಸಂಗಿಕತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಮತ್ತು ನಿಖರ ಉತ್ತರಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಗಣಿತನಿಯಾಗಿ ಅನುಷ್ಠಾನಗೊಳ್ಳುವ ವಿಧಾನಗಳು.
ಮೌಲ್ಯಮಾಪನ: ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿಯಮಿತವಾಗಿ ಅಳೆಯುವುದು ಮತ್ತು ನಿಖರ ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು.

ಉದಾಹರಣೆ: ಶೋಧ ಏಜೆಂಟ್‌ನಲ್ಲಿ ತಿದ್ದುಪಡಿ RAG

ವೆಬ್‌ನಿಂದ ಮಾಹಿತಿಯನ್ನು ತರಲು ಶೋಧ ಏಜೆಂಟ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ತಿದ್ದುಪಡಿ RAG ವಿಧಾನವು ಹೀಗೆ ಇರಬಹುದು:

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರ: ಬಳಕೆದಾರನ ಇನ್‌ಪುಟ್ ಆಧಾರಿತ ಶೋಧ ಪ್ರಶ್ನೆಗಳನ್ನು ರೂಪಿಸುವುದು.
ಉಪಕರಣ: ಶೋಧ ಫಲಿತಾಂಶಗಳನ್ನು ವಿಂಗಡಿಸಲು ಸಹಜ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ಮತ್ತು ಯಂತ್ರ ಅಧ್ಯಯನ ಅನ್ವಯಿಸು.
ಮೌಲ್ಯಮಾಪನ: ಸಂಬಂಧಿಸಿದ מידעದಲ್ಲಿ ಇರುವುದು ತಪ್ಪುಗಳನ್ನು ಹುಡುಕಿ ಖಂಡಿಸಿ ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು.

ಪ್ರವಾಸ ನಿಯೋಜಕದಲ್ಲಿ ತಿದ್ದುಪಡಿ RAG

ತಿದ್ದುಪಡಿ RAG (Retrieval-Augmented Generation) ಎಐ ಯೋಗ್ಯತೆಯನ್ನು ಹೆಚ್ಚು ನಿಖರವಾದ ಮತ್ತು ಪ್ರಾಸಂಗಿಕ ಪ್ರವಾಸ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಲು ಮಾಹಿತಿ ತರಲು ಮತ್ತು ಉತ್ಪಾದಿಸಲು ಸಾಕ್ಷಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ತಪ್ಪುಗಳನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ. ಹೇಗೆ ಪ್ರವಾಸ ನಿಯೋಜಕ ತಿದ್ದುಪಡಿ RAG ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ನೋಡೋಣ.

ಇದರಲ್ಲಿ ಇಲ್ಲಿವೆ:

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರ: ಸಂಬಧಿಸಿದ ಮಾಹಿತಿಯನ್ನು ತರಲು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಬಳಸುವುದು.
ಉಪಕರಣ: ತನಿಖಾ ಮಾಹಿತಿಯ ಪ್ರಾಸಂಗಿಕತಾ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ನಿಖರ ಉತ್ತರಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಗಣಿತ ಅನುಷ್ಠಾನ.
ಮೌಲ್ಯಮಾಪನ: ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಲಂಬವಾಗಿ ಅಳೆಯುವ ಮತ್ತು ಅದರ ನಿಖರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ ಪ್ರಕ್ರಿಯೆ.

ಪ್ರವಾಸ ನಿಯೋಜಕದಲ್ಲಿ ತಿದ್ದುಪಡಿ RAG ಅನುಷ್ಠಾನ ಹಂತಗಳು

ಪ್ರಾರಂಭಿಕ ಬಳಕೆದಾರ ಸಂವಾದ
- ಪ್ರವಾಸ ನಿಯೋಜಕ ಬಳಕೆದಾರನಿಂದ ಗುರಿ, ಪ್ರಯಾಣ ದಿನಾಂಕಗಳು, ಬಜೆಟ್ ಮತ್ತು ಆಸಕ್ತಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
- ಉದಾಹರಣೆ:
```
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
```
ಮಾಹಿತಿಯನ್ನು ತರಬೇತು ಮಾಡಿ
- ಬಳಕೆದಾರರ ಪ್ರಾಧಾನ್ಯತೆಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಮಾನಗಳು, ವಸತಿ, ಆಕರ್ಷಣೆಗಳು ಮತ್ತು ಊಟಗಾರರ ಮಾಹಿತಿ ತರಲಾಗುತ್ತದೆ.
- ಉದಾಹರಣೆ:
```
flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
```
ಆರಂಭಿಕ ಶಿಫಾರಸುಗಳನ್ನು ರಚಿಸಿ
- ಪ್ರವಾಸ ನಿಯೋಜಕ ತರಬೇತು ಮಾಹಿತಿಯಿಂದ ವೈಯಕ್ತಿಕ ಪಠ್ಯಕ್ರಮವನ್ನು ರಚಿಸುತ್ತದೆ.
- ಉದಾಹರಣೆ:
```
itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
```
ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆ ಸಂಗ್ರಹಿಸಿ
- ಪ್ರವಾಸ ನಿಯೋಜಕ ಆರಂಭಿಕ ಶಿಫಾರಸುಗಳ ಬಗ್ಗೆ ಬಳಕೆದಾರಿಂದ ಪ್ರತಿಕ್ರಿಯೆ ಕೇಳುತ್ತದೆ.
- ಉದಾಹರಣೆ:
```
feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
```
ತಿದ್ದುಪಡಿ RAG ಪ್ರಕ್ರಿಯೆ
- ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರ: ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಶೋಧ ಪ್ರಶ್ನೆಗಳನ್ನು ರೂಪಿಸುತ್ತದೆ.
  - ಉದಾಹರಣೆ:
    if "disliked" in feedback: preferences["avoid"] = feedback["disliked"]
- ಉಪಕರಣ: ಹೊಸ ಶೋಧ ಫಲಿತಾಂಶಗಳನ್ನು ವರ್ಗಾವಣೆ ಮತ್ತು ಗಾತ್ರಹರಿಸುವ算法ಗಳನ್ನು ಬಳಸಿ, ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಪ್ರಾಸಂಗಿಕತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
  - ಉದಾಹರಣೆ:
    new_attractions = search_attractions(preferences) new_itinerary = create_itinerary(flights, hotels, new_attractions) print("Updated Itinerary:", new_itinerary)
- ಮೌಲ್ಯಮಾಪನ: ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಶಿಫಾರಸುಗಳ ಪ್ರಾಸಂಗಿಕತೆ ಮತ್ತು ನಿಖರತೆಯನ್ನು ನಿಯಮಿತವಾಗಿ ಪರೀಕ್ಷಿಸಿ ಅಗತ್ಯ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುತ್ತದೆ.
  - ಉದಾಹರಣೆ:
    def adjust_preferences(preferences, feedback): if "liked" in feedback: preferences["favorites"] = feedback["liked"] if "disliked" in feedback: preferences["avoid"] = feedback["disliked"] return preferences preferences = adjust_preferences(preferences, feedback)

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ

ಪ್ರವಾಸ ನಿಯೋಜಕದಲ್ಲಿ ತಿದ್ದುಪಡಿ RAG ವಿಧಾನವನ್ನು ಸೇರಿಸುವ ಸರಳ ಪೈಥಾನ್ ಕೋಡ್ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# ಉದಾಹರಣೆಯ ಬಳಕೆ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

ಪ್ರೀ-ಎಂಪ್ಟಿವ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಲೋಡ್

ಪೂರ್ವಸಿದ್ಧಿ ಸಂದರ್ಭ ಲೋಡ್ ಅನುವಾದಿಸುತ್ತದೆ ಮಾದರಿಗೆ ಪ್ರಶ್ನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡುವ ಮೊದಲು ಸಂಬಂಧಿತ ಸಂದರ್ಭದಲ್ಲಿ ಅಥವಾ ಹಿನ್ನಲೆ ಮಾಹಿತಿಯನ್ನು ಲೋಡ್ ಮಾಡುವುದು. ಇದರ ಅರ್ಥ, ಮಾದರಿಗೆ ಆರಂಭಿನಿಂದಲೂ ಈ ಮಾಹಿತಿಯನ್ನು ಪ್ರವೇಶ ಇದೆ, ಇದು ಪ್ರಕ್ರಿಯೆಯ دوران ಹೆಚ್ಚುವರಿ ಡೇಟಾವನ್ನು ಹುಡುಕದೇ ಹೆಚ್ಚು ತಿಳಿವಳಿಕೆ ಹೊಂದಿದ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು.

ಇಲ್ಲಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪೂರ್ವಸಿದ್ಧಿ ಸಂದರ್ಭ ಲೋಡ್ ಹೇಗಿರಬಹುದು ಎಂಬ ಸರಳ ಉದಾಹರಣೆಯಾಗಿದೆ:

class TravelAgent:
    def __init__(self):
        # ಜನಪ್ರಿಯ ಗंतव्यಗಳು ಮತ್ತು ಅವುಗಳ ಮಾಹಿತಿಯನ್ನು ಪೂರ್ವಭಾವಿಯಾಗಿ ಲೋಡ್ ಮಾಡು
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # ಪೂರ್ವಭಾವಿಯಾಗಿ ಲೋಡ್ ಮಾಡಿದ ಸ೦ದರ್ಭದಿಂದ ಗಮ್ಯಸ್ಥಳ ಮಾಹಿತಿಯನ್ನು ಪಡೆದು ಕೊಳ್ಳಿ
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# ಉದಾಹರಣೆಯ ಬಳಕೆ
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

ವಿವರಣೆ

ಪ್ರಾರಂಭಿಕ ಸ್ಥಾಪನೆ (__init__ ವಿಧಾನ): TravelAgent ವರ್ಗವು ಪ್ಯಾರಿಸ್, ಟೋಕಿಯೋ, ನ್ಯೂಯಾರ್ಕ್, ಮತ್ತು ಸಿಡ್ನಿ ಮುಂತಾದ ಜನಪ್ರಿಯ ಗಮ್ಯಸ್ಥಳಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯಿಂದ ಕೂಡಿದ অভিধಾನವನ್ನು ಪೂರ್ವಲೋಡ್ ಮಾಡುತ್ತದೆ. ಈ অভিধಾನದಲ್ಲಿ ದೇಶ, ಕರೆನ್ಸಿ, ಭಾಷೆ, ಮತ್ತು ಪ್ರಮುಖ ಆಕರ್ಷಣೆಗಳ ವಿವರಗಳು ಸೇರಿವೆ.
ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವುದು (get_destination_info ವಿಧಾನ): ಬಳಕೆದಾರನು ನಿರ್ದಿಷ್ಟ ಗಮ್ಯಸ್ಥಳದ ಬಗ್ಗೆ ಪ್ರಶ್ನಿಸುವಾಗ, get_destination_info ವಿಧಾನವು ಪೂರ್ವಲೋಡ್ ಮಾಡಲಾದ ಸಂದರ್ಭ অভিধಾನದಿಂದ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ತರುತ್ತದೆ.

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

ಗುರಿಯನ್ನು ಸಹಿತ ಯೋಜನೆಯನ್ನು ಬೈಸ್ಟ್‌ಸ್ಟ್ರಾಪ್ ಮಾಡಿ ಪುನರಾವೃತ್ತಿ ಮೊದಲು

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

ಇಲ್ಲಿದೆ ನೀವು ಪೈಥಾನ್‌ನಲ್ಲಿ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ಗೆ ಗುರಿಯನ್ನು ಸಹಿತ ಬೈಸ್ಟ್‌ಸ್ಟ್ರಾಪ್ ಹೇಗೆ ಮಾಡಬಹುದು ಎಂಬುದರ ಉದಾಹರಣೆ:

ದೃಶ್ಯ

ಒಂದು ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಗ್ರಾಹಕರಿಗಾಗಿ ಕಸ್ಟಮೈಸ್ ಮಾಡಲಾದ ಸೇರಿಕೆಯೊಂದನ್ನು ರೂಪಿಸಲು ಬಯಸುತ್ತಾರೆ. ಗುರಿ ಗ್ರಾಹಕರ ಸಂತೃಪ್ತಿಯನ್ನು ಮಿತಿಯಲ್ಲೂ ಮತ್ತು ಪ್ರಾವೀಣ್ಯತೆಯಲ್ಲೂ ಗರಿಷ್ಠಗೊಳಿಸುವ ಪ್ರಯಾಣ ಕಾರ್ಯಪಟ್ಟಿ ರಚಿಸುವುದಾಗಿದೆ.

ಹಂತಗಳು

ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳು ಮತ್ತು ಬಜೆಟ್ ನಿಗದಿ ಮಾಡಿ.
ಈ ಇಚ್ಛೆಗಳ ಆಧಾರದಲ್ಲಿ ಪ್ರಾಥಮಿَّಕ ಯೋಜನೆಯನ್ನು ಬೈಸ್ಟ್‌ಸ್ಟ್ರಾಪ್ ಮಾಡಿ.
ಗ್ರಾಹಕರ ಸಂತೃಪ್ತಿಗಾಗಿ ಯೋಜನೆಯನ್ನು ಪುನರಾವೃತ್ತಿ ಮಾಡಿ ಸುಧಾರಿಸಿ.

ಪೈಥಾನ್ ಕೋಡ್

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# ಉದಾಹರಣೆ ಬಳಕೆ
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

ಕೋಡ್ ವಿವರಣೆ

ಪ್ರಾರಂಭಿಕ ಸ್ಥಾಪನೆ (__init__ ವಿಧಾನ): TravelAgent ವರ್ಗವು ಸಾಧ್ಯವಿರುವ ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಪ್ರತಿಯೊಂದು ಹೆಸರು, ವೆಚ್ಚ ಮತ್ತು ಚಟುವಟಿಕೆ ಪ್ರಕಾರದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ.
ಬೈಸ್ಟ್‌ಸ್ಟ್ರಾಪ್ ಯೋಜನೆ (bootstrap_plan ವಿಧಾನ): ಈ ವಿಧಾನ ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳು ಮತ್ತು ಬಜೆಟ್ ಆಧರಿಸಿ ಪ್ರಾಥಮಿَّಕ ಪ್ರಯಾಣ ಯೋಜನೆಯನ್ನು ರೂಪಿಸುತ್ತದೆ. ಇದು ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯನ್ನು ಪುನರಾವೃತ್ತಿ ಮಾಡಿ, ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳಿಗೆ ಹೊಂದಾಣಿಕೆಯುಳ್ಳ ಮತ್ತು ಬಜೆಟ್ ಗೆ ಜೋಡಿಸುವ ಪ್ರದೇಶಗಳನ್ನು ಯೋಜನೆಗೆ ಸೇರಿಸುತ್ತದೆ.
ಇಚ್ಛೆಗಳ ಜೊತೆಯಾಟ (match_preferences ವಿಧಾನ): ಈ ವಿಧಾನ ಗಮ್ಯಸ್ಥಳವು ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
ಯೋಜನೆಯನ್ನು ಪುನರಾವೃತ್ತಿ (iterate_plan ವಿಧಾನ): ಈ ವಿಧಾನ ಪ್ರಾಥಮಿَّಕ ಯೋಜನೆಯನ್ನು ಸುಧಾರಿಸಿ, ಪ್ರತಿ ಗಮ್ಯಸ್ಥಳವನ್ನು ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯುಳ್ಳದ್ದುಗಳಿಂದ ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳು ಮತ್ತು ಬಜೆಟ್ ಮಿತಿಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು.
ವೆಚ್ಚ ಲೆಕ್ಕಿಸು (calculate_cost ವಿಧಾನ): ಈ ವಿಧಾನ ಪ್ರಸ್ತುತ ಯೋಜನೆಯ ಒಟ್ಟು ವೆಚ್ಚವನ್ನು ಲೆಕ್ಕಿಸುತ್ತದೆ, ಹೊಸ ಗಮ್ಯಸ್ಥಳ ಸೇರ್ಪಡೆಗಾಗಿ.

ಉದಾಹರಣಾ ಬಳಕೆ

ಪ್ರಾಥಮಿَّಕ ಯೋಜನೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಪ್ರಾಥಮಿَّಕ ಯೋಜನೆಯನ್ನು ಗ್ರಾಹಕರ ಸೈಟ್ಸೀಯಿಂಗ್ ಇಚ್ಛೆ ಮತ್ತು $2000 ಬಜೆಟ್ ಆಧಾರಿಸಿ ರೂಪಿಸುತ್ತದೆ.
ಸುಧಾರಿತ ಯೋಜನೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಯೋಜನೆಯನ್ನು ಪುನರಾವೃತ್ತಿ ಮಾಡಿ, ಗ್ರಾಹಕರ ಇಚ್ಛೆಗಳ ಮತ್ತು ಬಜೆಟ್ ಆಧಾರಿತವಾಗಿ ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.

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

LLM ಅನ್ನು ರಿ-ರ್ಯಾಂಕಿಂಗ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು ಉಪಯೋಗಿಸುವುದು

ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳನ್ನು (LLMs) ರಿ-ರ್ಯಾಂಕಿಂಗ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು ಬಳಸಬಹುದು, ಹುಡುಕಲಾದ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳ ಪ್ರಸ್ತುತತೆ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಮೂಲಕ. ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದು ಹೀಗಿದೆ:

ಹುಟ್ಟುವಿಕೆ: ಪ್ರಾಥಮಿَّಕ ಹುಡುಕಾಟ ಹಂತವು ಪ್ರಶ್ನೆಯ ಆಧಾರದಲ್ಲಿ ಅಭ್ಯರ್ಥಿ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳ ಅಥವಾ ಪ್ರತಿಕ್ರಿಯೆಗಳ ಗುಂಪನ್ನು ತರುತ್ತದೆ.

ರಿ-ರ್ಯಾಂಕಿಂಗ್: LLM ಈ ಅಭ್ಯರ್ಥಿಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ, ಸಂಬಂಧಿತತೆ ಮತ್ತು ಗುಣಮಟ್ಟ ಆಧರಿಸಿ ಮರು-ರ್ಯಾಂಕ್ ಮಾಡುತ್ತದೆ. ಈ ಹಂತವು ಅತ್ಯಂತ ಸಂಬಂಧಿತ ಮತ್ತು ಉತ್ತಮ ინფორმೇಶನ್ ಮೊದಲಿಗೆ ತೋರಿಸಲು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಸ್ಕೋರ್ ಮಾಡುವುದು: LLM ಪ್ರತಿ ಅಭ್ಯರ್ಥಿಗೆ ಅಂಕಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅವುಗಳ ಸಂಬಂಧಿತತೆ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತವೆ. ಇದು ಬಳಕೆದಾರರಿಗಾಗಿ ಉತ್ತಮ ಪ್ರತಿಕ್ರಿಯೆ ಅಥವಾ ಡಾಕ್ಯುಮೆಂಟ್ ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

LLM ಗಳನ್ನು ರಿ-ರ್ಯಾಂಕಿಂಗ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು ಬಳಸುವ ಮೂಲಕ, ಸಿಸ್ಟಮ್ ಹೆಚ್ಚು ನಿಖರ ಮತ್ತು ಸಂದರ್ಭಾನುಕೂಲ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಬಹುದು, ಬಳಕೆದಾರರ ಒಟ್ಟು ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಇಲ್ಲಿದೆ ಹೀಗೇ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಯಾಣ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ರಿ-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು LLMನ್ನು ಹೇಗೆ ಉಪಯೋಗಿಸಬಹುದು ಎಂಬ ಪೈಥಾನ್ ಉದಾಹರಣೆ:

ದೃಶ್ಯ - ಇಚ್ಛೆಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಯಾಣ

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಗ್ರಾಹಕರಿಗೆ ಅವರ ಇಚ್ಛೆಗಳ ಆಧಾರಿತ ಉತ್ತಮ ಪ್ರಯಾಣ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಶಿಫಾರಸು ಮಾಡಿಬೆರಗುತಿದ್ದಾರೆ. LLM ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡುವ ಮೂಲಕ ಅತ್ಯಂತ ಸಂಬಂಧಿತ ಆಯ್ಕೆಗಳು ಪ್ರಸ್ತುತಪಡಿಸುವಲ್ಲಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಹಂತಗಳು:

ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ.
ಸಾಧ್ಯವಿರುವ ಪ್ರಯಾಣ ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಿರಿ.
ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳ ಆಧಾರದ ಮೇಲೆ LLM ಬಳಸಿ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಿ.

ಹೀಗೇ ನೀವು ಹಳೆಯ ಉದಾಹರಣೆಯನ್ನು Azure OpenAI ಸೇವೆಗಳ ಬಳಕೆಗೆ ಹೇಗೆ ನವೀಕರಿಸಬಹುದು:

ಅಗತ್ಯತೆಗಳು

ನಿಮ್ಮ ಬಳಿ ಒಂದು Azure ಸಬ್‌ಸ್ಕ್ರಿಪ್ಶನ್ ಇರಬೇಕು.
Azure OpenAI ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಿ ಮತ್ತು ನಿಮ್ಮ API ಕೀ ಪಡೆಯಿರಿ.

ಪೈಥಾನ್ ಕೋಡ್ ಉದಾಹರಣೆ

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # ಅಜೂರ್ ಓಪನ್‌ಎಐಗಾಗಿ ಪ್ರಾಂಪ್ಟ್ ರಚಿಸಿ
        prompt = self.generate_prompt(preferences)
        
        # ವಿನಂತಿಗಾಗಿ ಶೀರ್ಸಿಕೆಗಳು ಮತ್ತು ಪೇಲೋಡ್ ನಿರ್ಧರಿಸಿ
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # ರೀ-ರ್ಯಾಂಕ್ ಮತ್ತು ಅಂಕಿತ ಗಮ್ಯಸ್ಥಾನಗಳನ್ನು ಪಡೆಯಲು ಅಜೂರ್ ಓಪನ್‌ಎಐ ಎಪಿಐ ಕರೆ ಮಾಡು
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # ಶಿಫಾರಸುಗಳನ್ನು ತೆಗದುಕೊಂಡು ಹಿಂತಿರುಗಿಸಿ
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# ಉದಾಹರಣೆಯ ಬಳಕೆ
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

ಕೋಡ್ ವಿವರಣೆ - ಇಚ್ಛೆಗಳ ಪ್ರಭಾರಿಯು

ಪ್ರಾರಂಭಿಕ ಸ್ಥಾಪನೆ: TravelAgent ವರ್ಗವು ಸಾಧ್ಯವಿರುವ ಪ್ರಯಾಣ ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಪ್ರತಿಯೊಂದು ಹೆಸರು ಮತ್ತು ವಿವರಣೆ ಇದ್ದು.
ಶಿಫಾರಸು ಪಡೆಯುವುದು (get_recommendations ವಿಧಾನ): ಈ ವಿಧಾನ ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳ ಆಧಾರದ ಮೇಲೆ Azure OpenAI ಸೇವೆಗೆ ಪ್ರಾಂಪ್ಟ್ ಸೃಷ್ಟಿಸಿ, HTTP POST ವಿನಂತಿಯನ್ನು ಮಾಡಿ, ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಿದ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಪಡೆಯುತ್ತದೆ.
ಪ್ರಾಂಪ್ಟ್ ಸೃಷ್ಟಿಸುವುದು (generate_prompt ವಿಧಾನ): ಈ ವಿಧಾನ ಬಳಕೆದಾರರ ಇಚ್ಛೆ ಮತ್ತು ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡ ಪ್ರಾಂಪ್ಟ್ Azure OpenAI ಗೆ ರಚಿಸುತ್ತದೆ. ಇದರಿಂದ ಮಾದರಿ ನೀಡಲಾದ ಇಚ್ಛೆಗಳ ಆಧಾರದ ಮೇಲೆ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡುತ್ತದೆ.
API ಕರೆ: requests ಲೈಬ್ರರಿ ಬಳಸಿ Azure OpenAI APIಕ್ಕೆ HTTP POST ವಿನಂತಿ ಮಾಡುತ್ತದೆ. ಪ್ರತ್ಯುತ್ತರವು ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
ಉದಾಹರಣಾ ಬಳಕೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳು (ಉದಾಹರಣೆಗೆ ಸೈಟ್ಸೀಯಿಂಗ್ ಮತ್ತು ವೈವಿಧ್ಯಮಯ ಸಂಸ್ಕೃತಿ ಆಸಕ್ತಿ) ಸಂಗ್ರಹಿಸಿ, Azure OpenAI ಸೇವೆಯ ಮೂಲಕ ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಿದ ಶಿಫಾರಸುಗಳನ್ನು ಪಡೆಯುತ್ತದೆ.

ನಿಮ್ಮ ಸತ್ಯ Azure OpenAI API ಕೀ your_azure_openai_api_key ಮೂಲಕ ಮತ್ತು ನಿಮ್ಮ Azure OpenAI ತಯಾರಿಕೆಯ ನಿಖರ ಎಂಡ್‌ಪಾಯಿಂಟ್ URL https://your-endpoint.com/... ಮೂಲಕ ಬದಲಾಯಿಸಬೇಕು.

LLMಯನ್ನು ಮರು-ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು ಬಳಸುವುದರಿಂದ, ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಗ್ರಾಹಕರಿಗೆ ಹೆಚ್ಚು ವೈಯಕ್ತಿಕಗೊಳಿಸಿದ ಮತ್ತು ಸಂಬಂಧಿಸಿದ ಪ್ರಯಾಣ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಬಹುದು, ಒಟ್ಟು ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

RAG: ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನ vs ಸಾಧನ

Retrieval-Augmented Generation (RAG) AI ಏಜೆಂಟ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನ ಮತ್ತು ಸಾಧನ ಎರಡೂ ಆಗಬಹುದು. ಈ ಇಬ್ಬರ ನಡುವಿನ ಭೇದವನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ RAG ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಸಹಾಯ ಮಾಡಬಹುದು.

ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನವಾಗಿ RAG

ಇದು ಏನು?

ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನದ ರೂಪದಲ್ಲಿ, RAG ಪ್ರಮುಖ ಮಾಹಿತಿ ಹುಡುಕಲು ನಿರ್ದಿಷ್ಟ ಪ್ರಶ್ನೆಗಳು ಅಥವಾ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವಿಕೆಯಾಗಿದೆ. ಈ ಮಾಹಿತಿಯನ್ನು ನಂತರ ಪ್ರತಿಕ್ರಿಯೆಗಳು ಅಥವಾ ಕ್ರಿಯೆಗಳು ಉತ್ಪಾದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

ಪ್ರಾಂಪ್ಟ್ ರಚನೆ ಮಾಡಿ: ಕಾರ್ಯ ಅಥವಾ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಆಧರಿಸಿದ ಸಮರ್ಥಿತ ವಿಭಜಿತ ಪ್ರಾಂಪ್ಟ್‌ಗಳು ಅಥವಾ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ.
ಮಾಹಿತಿ ಹುಡುಕಿ: ಇನ್ನಷ್ಟು ಮಾಹಿತಿagi ಪೂರ್ವದ ಜ್ಞಾನ ಆಧಾರ ಅಥವಾ ತಡದಿಂದ ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ಹುಡುಕಿ.
ಪ್ರತಿಕ್ರಿಯೆ ರಚಿಸಿ: ಹುಡುಕಲಾದ ಮಾಹಿತಿಯನ್ನು ಜನರೇಟಿವ್ AI ಮಾದರಿಗಳೊಂದಿಗೆ ಮಿಶ್ರಣ ಮಾಡಿ ಸಮಗ್ರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸೃಷ್ಟಿ ಮಾಡಿ.

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಉದಾಹರಣೆ:

ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್: “ನಾನು ಪ್ಯಾರಿಸಿನ ಮ್ಯೂಸಿಯಂಗಳನ್ನು ಭೇಟಿ ಮಾಡಬಯಸುತ್ತೇನೆ.”
ಪ್ರಾಂಪ್ಟ್: “ಪ್ಯಾರಿಸಿನ ಟಾಪ್ ಮ್ಯೂಸಿಯಂಗಳನ್ನು ಹುಡುಕಿ.”
ಮಾಹಿತಿ ಪಡೆದಿದೆ: Louvre ಮ್ಯೂಸಿಯಂ, Musée d’Orsay, ಇತ್ಯಾದಿ ವಿವರಗಳು.
ರಚಿಸಿದ ಪ್ರತಿಕ್ರಿಯೆ: “ಇಲ್ಲಿ ಕೆಲವು ಪ್ಯಾರಿಸಿನ ಅತ್ಯುತ್ತಮ ಮ್ಯೂಸಿಯಂಗಳಿವೆ: Louvre ಮ್ಯೂಸಿಯಂ, Musée d’Orsay, ಮತ್ತು Centre Pompidou.”

ಸಾಧನವಾಗಿ RAG

ಇದು ಏನು?

ಸಾಧನವಾಗಿ, RAG ಒಂದು ಸಮಗ್ರ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದು, ಹುಡುಕಾಟ ಮತ್ತು ರಚನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ, ಅಭಿವೃದ್ಧಿಪರರಿಗೆ ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಕೈಯಿಂದ ಪ್ರಾಂಪ್ಟ್ ರೂಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲದೆ ಸಂಕೀರ್ಣ AI ಕಾರ್ಯಕ್ಷಮತೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಸುಲಭ ಮಾಡುತ್ತದೆ.

ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

ಒಗ್ಗೂಡಿಕೆ: AI ಏಜೆಂಟ್ ಆರ್ಕಿಟೆಕ್ಷಚರ್ ಒಳಗೆ RAG ಅನ್ನು ನೇರವಾಗಿ ಸಂಯೋಜಿಸಿ, ಇದು ಹುಡುಕಾಟ ಮತ್ತು ರಚನೆ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.
ಸ್ವಯಂಚಾಲನೆ: ಪ್ರಯೋಗಾತ್ಮಕ ಹಂತಗಳಿಗೆ ಪ್ರತ್ಯೇಕ ಪ್ರಾಂಪ್ಟ್ ನೀಡದೆ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಸ್ವೀಕರಿಸುವುದರಿಂದ ಅಂತಿಮ ಪ್ರತಿಕ್ರಿಯೆ ರಚಿಸುವವರೆಗೂ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ.
ಕಾರ್ಯಕ್ಷಮತೆ: ಹುಡುಕಾಟ ಮತ್ತು ರಚನೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುವ ಮೂಲಕ ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ವೇಗವಾಗಿ ಮತ್ತು ನಿಖರವಾಗಿ ಪ್ರತಿಕ್ರಿಯೆ ನೀಡುತ್ತದೆ.

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಉದಾಹರಣೆ:

ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್: “ನಾನು ಪ್ಯಾರಿಸಿನ ಮ್ಯೂಸಿಯಂಗಳಲ್ಲಿ ಭೇಟಿ ಮಾಡಬಯಸುತ್ತೇನೆ.”
RAG ಸಾಧನ: ಮ್ಯೂಸಿಯಂಗಳ ಮಾಹಿತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ರಚಿಸುತ್ತದೆ.
ರಚಿಸಿದ ಪ್ರತಿಕ್ರಿಯೆ: “ಇಲ್ಲಿ ಕೆಲವು ಪ್ಯಾರಿಸಿನ ಅತ್ಯುತ್ತಮ ಮ್ಯೂಸಿಯಂಗಳಿವೆ: Louvre ಮ್ಯೂಸಿಯಂ, Musée d’Orsay, ಮತ್ತು Centre Pompidou.”

ಹೋಲಿಕೆ

ಅಂಶ	ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನ	ಸಾಧನ
ಮ್ಯಾನುಯಲ್ ವಿ. ಸ್ವಯಂಚಾಲಿತ	ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಕೈಯಿಂದ ಪ್ರಾಂಪ್ಟ್ ರೂಪಿಸುವಿಕೆ.	ಹುಡುಕಾಟ ಮತ್ತು ರಚನೆಗಾಗಿ ಸ್ವಯಂಚಾಲಿತ ಪ್ರಕ್ರಿಯೆ.
ನಿಯಂತ್ರಣ	ಹುಡುಕಾಟ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಹೆಚ್ಚುವರಿ ನಿಯಂತ್ರಣ ನೀಡುತ್ತದೆ.	ಹುಡುಕಾಟ ಮತ್ತು ರಚನೆಯನ್ನು ಸರಳಗೊಳಿಸಿ ಸ್ವಯಂಚಾಲನೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಲವಚಿಕೆತನ	ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು.	ದೊಡ್ಡ ಪ್ರಮಾಣದ ಅನುಷ್ಠಾನಗಳಿಗೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ.
ಸಂಕೀರ್ಣತೆ	ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ರೂಪಿಸು ಮತ್ತು ಬದಲಾಯಿಸಲು ಅಗತ್ಯವಿದೆ.	AI ಏಜೆಂಟ್ ಆರ್ಕಿಟೆಕ್ಷ್ಚರ್ ಗೆ ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದಾದದು.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಪ್ರಾಂಪ्टिング ತಂತ್ರಜ್ಞಾನ ಉದಾಹರಣೆ:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

ಸಾಧನ ಉದಾಹರಣೆ:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

ಪ್ರಸ್ತುತತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು

ಪ್ರಸ್ತುತತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು AI ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಇದು ಏಜೆಂಟ್ ಹುಡುಕಿದ ಮತ್ತು ರಚಿಸಿದ ಮಾಹಿತಿಯು ಸೂಕ್ತ, ನಿಖರ ಹಾಗೂ ಬಳಕೆದಾರರಿಗೆ ಉಪಯುಕ್ತವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. AI ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಪ್ರಸ್ತುತತೆ ಮೌಲ್ಯಮಾಪನ ಹೇಗೆ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಸಂಶೋಧಿಸೋಣ, ವ್ಯಾಪಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ತಂತ್ರಜ್ಞಾನದೊಂದಿಗೆ.

ಪ್ರಸ್ತುತತೆಯ ಮೌಲ್ಯಮಾಪನದ ಪ್ರಮುಖ ತತ್ವಗಳು

ಸಂದರ್ಭ ಅರಿವು:
- ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯ ಸಂದರ್ಭವನ್ನು ಏಜೆಂಟ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು, ಪ್ರಸ್ತುತ ಹಾಗೂ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲು ಮತ್ತು ರಚಿಸಲು.
- ಉದಾಹರಣೆ: “ಪ್ಯಾರಿಸಿನ ಅತ್ಯುತ್ತಮ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳು” ಎಂದು ಕೇಳಿದರೆ, ಏಜೆಂಟ್ ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳನ್ನು, ಆಹಾರದ ಪ್ರಕಾರ ಮತ್ತು ಬಜೆಟ್ ಹೀಗೆ ಪರಿಗಣಿಸಬೇಕು.
ನಿಖರತೆ:
- ಏಜೆಂಟ್ ನೀಡುವ ಮಾಹಿತಿ ಸತ್ಯ ಮತ್ತು ನವೀಕರಿಸಿರುವುದು ಇರಬೇಕು.
- ಉದಾಹರಣೆ: ಪ್ರಸ್ತುತ ತೆರೆದ ಮತ್ತು ಉತ್ತಮ ವಿಮರ್ಶೆಗಳಿರುವ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳನ್ನು ಶಿಫಾರಸು ಮಾಡುವುದು, ಪಲೇತನ ಅಥವಾ ಮುಚ್ಚಲಾದ ಸ್ಥಳಗಳ ಬದಲು.
ಬಳಕೆದಾರರ ಉದ್ದೇಶ:
- ಏಜೆಂಟ್ ಪ್ರಶ್ನೆಯ ಹಿಂದಿನ ಬಳಕೆದಾರನ ಉದ್ದೇಶವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಅತ್ಯಂತ ಪ್ರಸ್ತುತ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಬೇಕು.
- ಉದಾಹರಣೆ: “ಬಹಳ ಕಡಿಮೆ ವೆಚ್ಚದ ಹೋಟೆಲ್ಗಳು” ಎಂದು ಕೇಳಿದರೆ, ಅಗ್ಗದ ಆಯ್ಕೆಗಳನ್ನು ಆದ್ಯತೆ ನೀಡಿ.
ಪ್ರತಿಕ್ರಿಯೆ ಲೂಪ್:
- ನಿರಂತರವಾಗಿ ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆ ಸಂಗ್ರಹಿಸಿ ವಿಶ್ಲೇಷಿಸಿ, ಪ್ರಸ್ತುತತೆಯ ಮೌಲ್ಯಮಾಪನ ಕಾರ್ಯವಿಧಾನವನ್ನು ಸುಧಾರಿಸಲು.
- ಉದಾಹರಣೆ: ಹಿಂದಿನ ಶಿಫಾರಸುಗಳ ಮೇಲೆ ಬಳಕೆದಾರರ ರೇಟಿಂಗ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಸೇರಿಸಿ ಯಾದೃಚ್ಛಿಕ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸುಧಾರಿಸುವುದು.

ಪ್ರಸ್ತುತತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ ತಂತ್ರಗಳು

ಪ್ರಸ್ತುತತೆಯ ಅಂಕಗಳನ್ನು ನಿಗದಿ ಮಾಡುವುದು:
- ಪ್ರತಿ ಹುಡುಕಲಾದ ವಸ್ತುವಿಗೆ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆ ಮತ್ತು ಇಚ್ಛೆಗಳಿಗೆ ಹೊಂದಿದಷ್ಟು ಪ್ರಮಾಣದಲ್ಲಿ ಪ್ರಸ್ತುತತೆ ಅಂಕಗಳನ್ನು ನೀಡಿ.
- ಉದಾಹರಣೆ:
```
def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
```
ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ರ್ಯಾಂಕಿಂಗ್:
- ಅಪ್ರಸ್ತುತ ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಉಳಿದ ವಸ್ತುಗಳನ್ನು ಪ್ರಸ್ತುತತೆಯ ಅಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ರ್ಯಾಂಕ್ ಮಾಡಿ.
- ಉದಾಹರಣೆ:
```
def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # ಮೇಲಿನ 10 ಸಂಬಂಧಿತ ವಸ್ತುಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ
```
ಸ್ವಾಭಾವಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ (NLP):
- ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು NLP ತಂತ್ರಗಳನ್ನು ಬಳಸಿ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಿ.
- ಉದಾಹರಣೆ:
```
def process_query(query):
    # ಬಳಕೆದಾರನ ಪ್ರಶ್ನೆಯಿಂದ ಪ್ರಮುಖ ಮಾಹಿತಿಯನ್ನು ತೆಗೆಯಲು NLP ಅನ್ನು ಬಳಸಿ
    processed_query = nlp(query)
    return processed_query
```
ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆ ಸಂಯೋಜನೆ:
- ಒದಗಿಸಿದ ಶಿಫಾರಸುಗಳ ಮೇಲೆ ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸಂಗ್ರಹಿಸಿ, ಮುಂದಿನ ಪ್ರಸ್ತುತತೆ ಮೌಲ್ಯಮಾಪನಗಳನ್ನು ಸರಿಹೊಂದಿಸಿ.
- ಉದಾಹರಣೆ:
```
def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items
```

ಉದಾಹರಣೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತತೆ ಮೌಲ್ಯಮಾಪನ

ಇಲ್ಲಿದೆ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಪ್ರಯಾಣ ಶಿಫಾರಸುಗಳ ಪ್ರಸ್ತುತತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # ಮೇಲಿನ 10 ಸಂಬಂಧಿತ ವಸ್ತುಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# ಉದಾಹರಣೆಯ ಬಳಕೆ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

ಉದ್ದೇಶದೊಂದಿಗೆ ಹುಡುಕಾಟ

ಉದ್ದೇಶದೊಂದಿಗೆ ಹುಡುಕಾಟ ಎಂದರೆ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯ ಹಿಂದಿನ ಮೂಲ ಉದ್ದೇಶ ಅಥವಾ ಗುರಿಯನ್ನು ಅರ್ಥಮಾಡుకొని ಅತ್ವಂತ ಸಂಬಂಧಿತ ಹಾಗೂ ಬಳಕೆದಾರರಿಗೆ ಉಪಯುಕ್ತ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲು ಮತ್ತು ರಚಿಸಲು. ಈ ವಿಧಾನದದು ಕೀವರ್ಡ್ ಹೊಂದುವಿಕೆಯನ್ನು ಮೀರಿದಂತೆ, ಬಳಕೆದಾರರ ನಿಜವಾದ ಅಗತ್ಯಗಳು ಮತ್ತು ಸಂದರ್ಭಗಳನ್ನು ಹಿಡಿದುಕೊಳ್ಳುತ್ತದೆ.

ಉದ್ದೇಶದೊಂದಿಗೆ ಹುಡುಕಾಟದ ಪ್ರಮುಖ ತತ್ವಗಳು

ಬಳಕೆದಾರರ ಉದ್ದೇಶವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು:
- ಬಳಕೆದಾರರ ಉದ್ದೇಶ ಮೂರು ಪ್ರಮುಖ ಪ್ರಕಾರಗಳಾಗಿರಬಹುದು: ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸು, ನಾವಿಗೇಷನಲ್, ಮತ್ತು ವ್ಯವಹಾರಾತ್ಮಕ.
  - ಮಾಹಿತಿಪ್ರದ ಉದ್ದೇಶ: ಬಳಕೆದಾರನು ನಿಶ್ಚಿತ ವಿಷಯದ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕುತ್ತಾನೆ (ಉದಾ: “ಪ್ಯಾರಿಸಿನ ಅತ್ಯುತ್ತಮ ಮ್ಯೂಸಿಯಂಗಳೇನು?”)
  - ನಾವಿಗೇಷನಲ್ ಉದ್ದೇಶ: ಬಳಕೆದಾರನು ಒಂದು ನಿಶ್ಚಿತ ವೆಬ್‌ಸೈಟ್ ಅಥವಾ ಪುಟಕ್ಕೆ ಹೋಗಲಿಚ್ಛೆಪಡುತ್ತಾನೆ (ಉದಾ: “Louvre ಮ್ಯೂಸಿಯಂ ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್”)
  - ವ್ಯವಹಾರಾತ್ಮಕ ಉದ್ದೇಶ: ಬಳಕೆದಾರನು ವ್ಯವಹಾರ ಮಾಡುವ ಉದ್ದೇಶವಿದೆ, ಹಾರಾಟ ಬುಕ್ ಮಾಡುವ ಅಥವಾ ಖರೀದಿ ನಡೆಸುವಂತೆ (ಉದಾ: “ಪ್ಯಾರಿಸಿಗೆ ಹಾರಾಟ ಬುಕ್ ಮಾಡಿ”)
ಸಂದರ್ಭ ಅರಿವು:
- ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯ ಸಂದರ್ಭ ವಿಶ್ಲೇಷಣೆ ಮಾಡುವುದರಿಂದ ಅವರ ಉದ್ದೇಶವನ್ನು ನಿಖರವಾಗಿ ಗುರುತಿಸಲು ಸಹಾಯವಾಗುತ್ತದೆ. ಇದು ಹಿಂದಿನ ಸಂಭಾಷಣೆ, ಗ್ರಾಹಕ ಇಚ್ಛೆಗಳು ಮತ್ತು ಪ್ರಸ್ತುತ ಪ್ರಶ್ನೆಯ ನಿರ್ದಿಷ್ಟ ವಿವರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
ಸ್ವಾಭಾವಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ (NLP):
- NLP ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರ ಭಾಷಾ ಪ್ರಶ್ನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು. ಇದರಲ್ಲಿ ಎಂಟಿಟಿ ಗುರುತು, ಭಾವ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಪ್ರಶ್ನೆ ಪಾರ್ಸಿಂಗ್ ಸೇರಿದಂತೆ ಕಾರ್ಯಗಳು ಸೇರಿವೆ.
ವೈಯಕ್ತೀಕರಣ:
- ಬಳಕೆದಾರರ ಇತಿಹಾಸ, ಇಚ್ಛೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರಿತವಾಗಿ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ವೈಯಕ್ತೀಕರಿಸುವ ಮೂಲಕ ಪ್ರಸ್ತುತತೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಉದ್ದೇಶದೊಂದಿಗೆ ಹುಡುಕಾಟ

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಉದಾಹರಣೆ ಮೂಲಕ ಉದ್ದೇಶದೊಂದಿಗೆ ಹುಡುಕಾಟ ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ ನೋಡೋಣ.

ಬಳಕೆದಾರರ ಇಚ್ಛೆಗಳ ಸಂಗ್ರಹ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

ಬಳಕೆದಾರರ ಉದ್ದೇಶವನ್ನು ಅರ್ಥ ಮಾಡಿಕೊಂಡು

def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

ಸಂದರ್ಭ ಅರಿವು

def analyze_context(query, user_history):
    # ಪ್ರಸ್ತುತ ಪ್ರಶ್ನೆಯನ್ನು ಬಳಕೆದಾರರ ಇತಿಹಾಸದೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ ಹಿನ್ನೆಲೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

ಹುಡುಕು ಮತ್ತು ವೈಯಕ್ತಿಕೃತ ಫಲಿತಾಂಶಗಳು

def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # информациялық ಉದ್ದೇಶಕ್ಕಾಗಿ ಉದಾಹರಣೆ ಹುಡುಕಾಟ ತರ್ಕ
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # ದಿಕ್ಕು ಸೂಚಿಸುವ ಉದ್ದೇಶಕ್ಕಾಗಿ ಉದಾಹರಣೆ ಹುಡುಕಾಟ ತರ್ಕ
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # ವಹಿವಾಟು ಉದ್ದೇಶಕ್ಕಾಗಿ ಉದಾಹರಣೆ ಹುಡುಕಾಟ ತರ್ಕ
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # ಉದಾಹರಣಾ ವೈಯಕ್ತೀಕರಣ ತರ್ಕ
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # ಟಾಪ್ 10 ವೈಯಕ್ತಿಕೃತ ಫಲಿತಾಂಶಗಳನ್ನು ವಾಪಸ್ ನೀಡು

ಉದಾಹರಣೆ ಬಳಕೆ

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. ಉಪಕರಣವಾಗಿ ಕೋಡ್ ರಚನೆ

ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ಗಳು ಜटಿಲ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಕೋಡ್ ಬರೆಯಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು AI ಮಾದರಿಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.

ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ಗಳು

ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ಗಳು ಜನರೇಟಿವ್ AI ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕೋಡ್ ಬರೆಯಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಬಳಸುತ್ತಾರೆ. ಈ ಏಜೆಂಟ್ಗಳು ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್ ರಚಿಸಿ ಚಲಾಯಿಸುವ ಮೂಲಕ ಜಟಿಲ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು, ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು ಮತ್ತು ಬೆಲೆಯುಕ್ತ ಒಳನೋಟಗಳನ್ನು ನೀಡಬಹುದು.

ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಿಕೆಗಳು

ಸ್ವಯಂಚಾಲಿತ ಕೋಡ್ ರಚನೆ: ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ, ವೆಬ್ ಸ್ಕ್ರಾಪಿಂಗ್ ಅಥವಾ ಯಂತ್ರ ಅಧ್ಯಯನಾತ್ಮಕ ಕಾರ್ಯಗಳಿಗೆ ವಿಶೇಷ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಚಿಸಿ.
RAG ಆಗಿ SQL: ಡೇಟಾಬೇಸಿನಿಂದ ಡೇಟಾವನ್ನು ತರಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಬಳಸಿ.
ಸಮಸ್ಯೆ ಪರಿಹಾರ: ವಿಶೇಷ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು, ಉದಾಹರಣೆಗೆ ಆಲ್ಗಾರಿಥಮ್‌ಗಳನ್ನು ಅತಿಕ್ಷೇಪಿಸುವುದು ಅಥವಾ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದಕ್ಕೆ ಕೋಡ್ ರಚಿಸಿ ನಿರ್ವಹಿಸಿ.

ಉದಾಹರಣೆ: ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗೆ ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್

ನೀವು ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ ವಿನ್ಯಾಸ ಮಾಡುತ್ತಿದ್ದೀರೇಂದು ಕಲ್ಪಿಸಿ. ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡಬಹುದು ನೋಡೋಣ:

ಕಾರ್ಯ: ಪ್ರವೃತ್ತಿಗಳು ಮತ್ತು ಮಾದರಿಗಳನ್ನು ಗುರುತಿಸಲು ಒಂದು ಡೇಟಾಸೆಟ್ ವಿಶ್ಲೇಷಿಸಿ.
ಹೆಜ್ಜೆಗಳು:
- ಡೇಟಾ ವಿಶ್ಲೇಷಣಾ ಸಾಧನಕ್ಕೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿ.
- ಡೇಟಾವನ್ನು ತರದು ಮತ್ತು ಸಂಗ್ರಹಿಸಲು SQL ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ.
- ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಿ.
- ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸಿ ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ರಚಿಸಿ.
ಬೇಕಾಗುವ ಸಂಪನ್ಮೂಲಗಳು: ಡೇಟಾಸೆಟ್ ಪ್ರವೇಶ, ಡೇಟಾ ವಿಶ್ಲೇಷಣಾ ಸಾಧನಗಳು ಮತ್ತು SQL ಸಾಮರ್ಥ್ಯಗಳು.
ಅನುಭವ: ಹಿಂದಿನ ವಿಶ್ಲೇಷಣೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸಿ ಭವಿಷ್ಯದ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿನ ನಿಖರತೆ ಮತ್ತು ಸಂಬಂಧಿತತೆ ಮನಸ್ಸುಮಾಡಿ.

ಉದಾಹರಣೆ: ಪ್ರವಾಸಿ ಏಜೆಂಟ್‌ಗೆ ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು “ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್” ಎಂಬ ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ ವಿನ್ಯಾಸ ಮಾಡುತ್ತೇವೆ, ಅದು ಜನರೇಟಿವ್ AI ಬಳಸಿ ಕೋಡ್ ರಚಿಸಿ ನಿರ್ವಹಿಸುವ ಮೂಲಕ ಬಳಕೆದಾರರಿಗೆ ಅವರ ಪ್ರಯಾಣವನ್ನು ಯೋಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಏಜೆಂಟ್ ಪ್ರಯಾಣ ಆಯ್ಕೆಗಳನ್ನು ಪಡೆಯುವುದು, ಫಲಿತಾಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು ಮತ್ತು ಒಂದು ಯೋಜಿತ ಹೊರಟ ಪಟ್ಟಿ ರಚಿಸುವ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.

ಕೋಡ್ ರಚಿಸುವ ಏಜೆಂಟ್ ಅವಲೋಕನ

ಬಳಕೆದಾರ ಇಷ್ಟಗಳನ್ನು ಸೆರೆಹಿಡಿಯುವುದು: ಗಮ್ಯಸ್ಥಾನ, ಪ್ರಯಾಣ ದಿನಾಂಕಗಳು, ಬಜೆಟ್ ಮತ್ತು ಆಸಕ್ತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ಡೇಟಾ ಪಡೆಯಲು ಕೋಡ್ ರಚನೆ: ವಿಮಾನ, ಹೋಟೆಲ್, ಆಕರ್ಷಣೆಗಳ ಬಗ್ಗೆ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಚಿಸುತ್ತದೆ.
ರಚಿಸಿದ ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು: ನಿದರ್ಶನದಲ್ಲಿನ তথ্যವನ್ನು ಪಡೆಯಲು ರಚಿಸಿದ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುತ್ತದೆ.
ಯಾತ್ರಾ ಯೋಜನೆ ರಚನೆ: ಪಡೆದ ಮಾಹಿತಿಯನ್ನು ವೈಯಕ್ತಿಕೃತ ಪ್ರಯಾಣ ಯೋಜನೆಯಲ್ಲಿ ಸಂಯೋಜಿಸುತ್ತದೆ.
ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗಾತ್ರಮಾನ: ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸಿ ಅಗತ್ಯವಿದ್ದರೆ ಫಲಿತಾಂಶಗಳನ್ನು ಸುಧಾರಿಸಲು ಕೋಡ್ ಮರುರಚನೆ ಮಾಡುತ್ತದೆ.

ಹಂತ-ಹಂತ ಅನುಷ್ಠಾನ

ಬಳಕೆದಾರ ಇಷ್ಟಗಳನ್ನು ಸೆರೆಹಿಡಿಯುವುದು

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

ಡೇಟಾ ಪಡೆಯಲು ಕೋಡ್ ರಚನೆ

def generate_code_to_fetch_data(preferences):
    # ಉದಾಹರಣೆ: ಬಳಕೆದಾರರ ಇಷ್ಟ/preferences ಆಧರಿಸಿ ವಿಮಾನಗಳನ್ನು ಹುಡುಕಲು ಕೇಡ್ ರಚಿಸಿ
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # ಉದಾಹರಣೆ: ಹೇೋಟೆಲ್ಗಳನ್ನು ಹುಡುಕಲು ಕೇಡ್ ರಚಿಸಿ
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

ರಚಿಸಿದ ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು

def execute_code(code):
    # exec ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಿದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

ಯಾತ್ರಾ ಯೋಜನೆ ರಚನೆ

def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗಾತ್ರಮಾನ

def adjust_based_on_feedback(feedback, preferences):
    # ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರದ ಮೇಲೆ ಇಚ್ಛಾಶಕ್ತಿ ಸಿಧ್ಧಪಡಿಸಿ
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# ನವೀಕರಿಸಲಾದ ಇಚ್ಛಾಶಕ್ತಿ ಬಳಕಿ ಕೋಡ್ ಪುನರ್ನಿರ್ಮಿಸಿ ಮತ್ತು ನಿರ್ವಹಿಸಿ
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

ಪರಿಸರ ಜಾಗೃತಿ ಮತ್ತು ತರ್ಕವನ್ನು ಪ್ರಕ್ರಿಯೆಮಾಡುವುದು

ಟೇಬಲಿನ ವಿದಾನಾತ್ಮಕ ಸ್ವರೂಪ ಆಧಾರಿತವಾಗಿ ಪ್ರಶ್ನೆ ರಚನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರಿಸರ ಜಾಗೃತಿ ಮತ್ತು ತರ್ಕವನ್ನು ಉಪಯೋಗಿಸಿ ಹೆಚ್ಚಿಸಬಹುದು.

ಇದನ್ನು ಹೇಗೆ ಮಾಡಲು ಸಾಧ್ಯವೆಂದರೆ ಹೀಗೆ ಇದೆ:

ವಿದಾನಗಳ ಅರಿವು: ವ್ಯವಸ್ಥೆ ಟೇಬಲಿನ ವಿದಾನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಅದನ್ನು ಪ್ರಶ್ನೆ ರಚನೆಗೆ ಆಧಾರವಾಗಿಸುತ್ತದೆ.
ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗಾತ್ರಮಾನ: ಬಳಕೆದಾರ ಇಷ್ಟಗಳನ್ನು ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗಾತ್ರಮಾನ ಮಾಡಿ, ವಿದಾನದಲ್ಲಿ ಯಾವ ಕ್ಷೇತ್ರಗಳನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಬೇಕು ಎಂದು ತರ್ಕಮಾಡುತ್ತದೆ.
ಪ್ರಶ್ನೆ ರಚನೆ ಮತ್ತು ನಿರ್ವಹಣೆ: ಹೊಸ ಇಷ್ಟಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಮಾನ ಮತ್ತು ಹೋಟೆಲ್ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಈ ಕಲ್ಪನೆಗಳನ್ನು ಒಳಗೊಂಡ ಅಪ್ಡೇಟ್ ಮಾಡಲಾದ Python ಕೋಡ್ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

def adjust_based_on_feedback(feedback, preferences, schema):
    # ಬಳಕೆದಾರರಿಂದ ಬಂದ ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಮೆಚ್ಚುಮತಗಳನ್ನು ಸರಿಹೊಂದಿಸಿ
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # ಸಂಬಂಧಿತ ಮೆಚ್ಚುಮತಗಳನ್ನು ಸರಿಹೊಂದಿಸಲು ಅಂಕಿಯಲ್ಲಿ ಆಧಾರಿತ ವಿವರಣೆ
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # ಅಂಕಿ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಮೆಚ್ಚುಮತಗಳನ್ನು ಸರಿಹೊಂದಿಸಲು ಕಸ್ಟಮ್ ಲಾಜಿಕ್
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # ನವೀಕರಿಸಿದ ಮೆಚ್ಚುಮತಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಮಾನಗಳ ಡೇಟಾವನ್ನು ಕರೆದೊಯ್ಯಲು ಕೋಡ್ ರಚಿಸಿ
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # ನವೀಕರಿಸಿದ ಮೆಚ್ಚುಮತಗಳ ಆಧಾರದ ಮೇಲೆ ಹೋಟೆಲ್ ಡೇಟಾವನ್ನು ಕರೆದೊಯ್ಯಲು ಕೋಡ್ ರಚಿಸಿ
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # ಕೋಡ್ ನ ಅನುಷ್ಠಾನವನ್ನು ಅನುಕಲಿಸಿ ಮತ್ತು ಮಾದರಿ ಡೇಟಾವನ್ನು ಮರಳಿಸಿ
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # ವಿಮಾನಗಳು, ಹೋಟೆಲ್‌ಗಳು ಮತ್ತು ಆಕರ್ಷಣೆಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಣಾಳಿ ರಚಿಸಿ
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# ಉದಾಹರಣೆಯ ಅಂಕಿ
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# ಉದಾಹರಣೆಯ ಬಳಕೆ
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# ನವೀಕರಿಸಿದ ಮೆಚ್ಚುಮತಗಳೊಂದಿಗೆ ಕೋಡ್ ನವೀಕರಿಸಿ ಮತ್ತು ಅನುಷ್ಠಾನಗೊಳಿಸಿ
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

ವಿವರ - ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಬುಕ್ಕಿಂಗ್

ವಿದಾನ ಜಾಗೃತಿ: schema ಡಿಕ್ಷನರಿ ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರಿತ ಇಷ್ಟಗಳನ್ನು ಹೇಗೆ ಗಾತ್ರಮಾನ ಮಾಡುವುದು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಇದರಲ್ಲಿ favorites ಮತ್ತು avoid ಹೀರಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಗಾತ್ರಮಾನಗಳಿವೆ.
ಇಷ್ಟಗಳನ್ನು ಗಾತ್ರಮಾನ ಮಾಡುವುದು (adjust_based_on_feedback ವಿಧಾನ): ಈ ವಿಧಾನ ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಇಷ್ಟಗಳನ್ನು ಗಾತ್ರಮಾನ ಮಾಡುತ್ತದೆ.
ಪರಿಸರ ಆಧಾರಿತ ಗಾತ್ರಮಾನಗಳು (adjust_based_on_environment ವಿಧಾನ): ಈ ವಿಧಾನ ವಿದಾನ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗಾತ್ರಮಾನಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುತ್ತದೆ.
ಪ್ರಶ್ನೆ ರಚನೆ ಮತ್ತು ನಿರ್ವಹಣೆ: ಗಾತ್ರಮಾನ ಮಾಡಿದ ಇಷ್ಟಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಮಾನ ಮತ್ತು ಹೋಟೆಲ್ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ಕೋಡ್ ರಚಿಸಿ ಅವುಗಳನ್ನು ಸಿಮ್ಯುಲೇಟು ಮಾಡುತ್ತದೆ.
ಯಾತ್ರಾ ಯೋಜನೆ ರಚನೆ: ಹೊಸ ವಿಮಾನ, ಹೋಟೆಲ್ ಮತ್ತು ಆಕರ್ಷಣೆಗಳ ಡೇಟಾ ಆಧಾರಿತ ಆಧುನಿಕೕಕರಿಸಿದ ಯೋಜನೆಯನ್ನು ರಚಿಸುತ್ತದೆ.

ವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಸರ-ಜागरूकವಾಗಿ ಮಾಡುವುದು ಮತ್ತು ವಿದಾನದ ಆಧಾರದ ಮೇಲೆ ತರ್ಕಮಾಡುವ ಮೂಲಕ, ಅದನ್ನು ಹೆಚ್ಚು ನಿಖರ ಮತ್ತು ಸಂಬಂಧಿತ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಇದರಿಂದ ಉತ್ತಮ ಪ್ರಯಾಣ ಸಲಹೆಗಳು ಮತ್ತು ಹೆಚ್ಚು ವೈಯಕ್ತಿಕೃತ ಬಳಕೆದಾರ ಅನುಭವ ಉಂಟಾಗುತ್ತದೆ.

SQL ಅನ್ನು Retrieval-Augmented Generation (RAG) ತಂತ್ರವಾಗಿ ಉಪಯೋಗಿಸುವುದು

SQL (ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಕ್ವೇರಿ ಲ್ಯಾಂಗಿನ್) ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡಲು ಶಕ್ತಿಯುತ ಉಪಕರಣವಾಗಿದೆ. Retrieval-Augmented Generation (RAG) ವಿಧಾನ ಭಾಗವಾಗಿ ಬಳಸಿದಾಗ, SQL ಡೇಟಾಬೇಸ್‌ಗಳಿಂದ ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ಕಳೆದು, AI ಏಜೆಂಟ್ಗಳಲ್ಲಿ ಉತ್ತರಗಳನ್ನು ಅಥವಾ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಲು ನೆರವಾಗುತ್ತದೆ. ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಸನ್ನಿವೇಶದಲ್ಲಿ SQL ಅನ್ನು RAG ತಂತ್ರವಾಗಿ ಹೇಗೆ ಉಪಯೋಗಿಸಬಹುದು ಎಂಬುದನ್ನು ನೋಡಿ.

ಪ್ರಮುಖ ಕಲ್ಪನೆಗಳು

ಡೇಟಾಬೇಸ್ ಸಂವಹನ:
- SQL ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಮತ್ತು ಡೇಟಾವನ್ನು ಸಂಶೋಧಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
- ಉದಾಹರಣೆ: ಪ್ರಯಾಣ ಡೇಟಾಬೇಸಿನಿಂದ ವಿಮಾನ ವಿವರಗಳು, ಹೋಟೆಲ್ ಮಾಹಿತಿ ಮತ್ತು ಆಕರ್ಷಣೆಗಳನ್ನು ಪಡೆಯುವುದು.
RAG ಜೊತೆ ಏಕತೆಯೀಕರಣ:
- SQL ಪ್ರಶ್ನೆಗಳು ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್ ಮತ್ತು ಇಷ್ಟಗಳ ಆಧಾರದ ಮೇಲೆ ರಚಿಸಲಾಗುತ್ತವೆ.
- ಪಡೆಯಲಾದ ಡೇಟಾವನ್ನು ವೈಯಕ್ತಿಕೃತ ಶಿಫಾರಸುಗಳು ಅಥವಾ ಕ್ರಮಗಳನ್ನು ರಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಡೈನಾಮಿಕ್ ಪ್ರಶ್ನೆ ರಚನೆ:
- AI ಏಜೆಂಟ್ ಪರಿಸರ ಮತ್ತು ಬಳಕೆದಾರ ಅಗತ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಡೈನಾಮಿಕ್ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುತ್ತದೆ.
- ಉದಾಹರಣೆ: ಬಜೆಟ್, ದಿನಾಂಕಗಳು ಮತ್ತು ಆಸಕ್ತಿಗಳ ಆಧಾರದ ಮೇಲೆ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು.

ಅನ್ವಯನೆಗಳು

ಸ್ವಯಂಚಾಲಿತ ಕೋಡ್ ರಚನೆ: ವಿಶೇಷ ಕಾರ್ಯಗಳಿಗೆ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಚಿಸಿ.
RAG ಆಗಿ SQL: ಡೇಟಾವನ್ನು ಸಂಶോധಿಸಲು SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಬಳಸಿ.
ಸಮಸ್ಯೆ ಪರಿಹಾರ: ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಕೋಡ್ ರಚಿಸಿ ಮತ್ತು ನಿರ್ವಹಿಸು.

ಉದಾಹರಣೆ: ಡೇಟಾ ವಿಶ್ಲೇಷಣಾ ಏಜೆಂಟ್:

ಕಾರ್ಯ: ಒಂದು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಪ್ರವೃತ್ತಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು.
ಹೆಜ್ಜೆಗಳು:
- ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡು.
- ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು SQL ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸು.
- ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯು.
- ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ರಚಿಸು.
ಸಂಪನ್ಮೂಲಗಳು: ಡೇಟಾಸೆಟ್ ಪ್ರವೇಶ, SQL ಸಾಮರ್ಥ್ಯಗಳು.
ಅನುಭವ: ಭವಿಷ್ಯದ ವಿಶ್ಲೇಷಣೆಯ ಸುಧಾರಣೆಗೆ ಹಳೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸಿ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ: ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ SQL ಬಳಕೆ

ಬಳಕೆದಾರ ಇಷ್ಟಗಳನ್ನು ಸೆರೆಹಿಡಿಯುವುದು

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

SQL ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುವುದು

def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

SQL ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

ಶಿಫಾರಸುಗಳನ್ನು ರಚಿಸುವುದು

def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

ಉದಾಹರಣೆಯ SQL ಪ್ರಶ್ನೆಗಳು

ವಿಮಾನ ಪ್ರಶ್ನೆ

SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

ಹೋಟೆಲ್ ಪ್ರಶ್ನೆ

SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

ಆಕರ್ಷಣೆ ಪ್ರಶ್ನೆ

SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Retrieval-Augmented Generation (RAG) ತಂತ್ರದ ಭಾಗವಾಗಿ SQL ಅನ್ನು ಉಪಯೋಗಿಸುವ ಮೂಲಕ, ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಹೀಗೆ AI ಏಜೆಂಟ್ಗಳು ಪ್ರಮುಖ ಮತ್ತು ವೈಯಕ್ತಿಕೃತ ಶಿಫಾರಸುಗಳನ್ನು ನೇರವಾಗಿ ಡೇಟಾ ಪಡೆದು ಬಳಸಬಹುದು.

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಉದಾಹರಣೆ

ಆದ್ದರಿಂದ ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅನುಷ್ಠಾನವನ್ನು ತೋರಿಸಲು, ನಾವು ಒಂದು ಸರಳ ಏಜೆಂಟ್ ರಚಿಸೋಣ ಅದು ಸಮಸ್ಯೆ ಪರಿಹರಿಸುವಾಗ ತನ್ನ ತೀರ್ಮಾನ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಬಿಂಬಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಗೆ, ನಾವು ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ, ಇಲ್ಲಿ ಏಜೆಂಟ್ ಹೋಟೆಲ್ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಆದರೆ ನಂತರ ತನ್ನ ತರ್ಕವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ ತಪ್ಪು ಅಥವಾ ಕ್ಲಿಷ್ಟತೆಯುಳ್ಳ ಆಯ್ಕೆ ಮಾಡಿದಾಗ ತಂತ್ರಮಾರ್ಗವನ್ನು ಹೊಂದಿಸುವುದು.

ನಾವು ಬೆಲೆ ಮತ್ತು ಗುಣಮಟ್ಟದ ಸಂಯೋಜನೆಗೆ ಆಧರಿಸಿ ಹೋಟೆಲ್ ಆಯ್ಕೆಮಾಡುವ ಸರಳ ಉದಾಹರಣೆ ಸಿಮ್ಯುಲೇಟುಮಾಡುತ್ತೇವೆ, ಆದರೆ ಅದು ತನ್ನ ತೀರ್ಮಾನಗಳ ಬಗ್ಗೆ “ಬಿಂಬಿಸಿ” ನಂತರ ಸುಧಾರಣೆಯನ್ನು ಮಾಡುತ್ತದೆ.

ಇದು ಮೆಟಾಕಾಗ್ನಿಷನ್ ಅನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

ಆರಂಭಿಕ ತೀರ್ಮಾನ: ಏಜೆಂಟ್ ಅತ್ಯಂತ ಕಡಿಮೆ ಬೆಲೆಯ ಹೋಟೆಲ್ ಆಯ್ಕೆಮಾಡುತ್ತದೆ, ಗುಣಮಟ್ಟದ ಪರಿಣಾಮವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳದೆ.
ಬಿಂಬನ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ: ಮೊದಲ ಆಯ್ಕೆ ನಂತರ, ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಳಸಿ ಹೋಟೆಲ್ “ಕೆಟ್ಟ” ಆಯ್ಕೆಯಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಹೋಟೆಲ್ ಗುಣಮಟ್ಟ ಕಡಿಮೆ ಕಂಡುಬಂದರೆ, ತನ್ನ ತರ್ಕವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
ತಂತ್ರದಿಂದ ಗಾತ್ರಮಾನ ಮಾಡುವುದು: ತನ್ನ ಬಿಂಬನೆ ಆಧಾರಿತವಾಗಿ ತಂತ್ರವನ್ನು ಬದಲಾಯಿಸಿ “ಕಡಿಮೆ ಬೆಲೆ” ಯಿಂದ “ಅತಿ ಉನ್ನತ ಗುಣಮಟ್ಟ”ಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಭವಿಷ್ಯದ ತೀರ್ಮಾನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಧಾರಿಸುವುದು.

ಉದಾಹರಣೆ ಕೆಳಗಿನಂತಿದೆ:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # ಹಿಂದಿನದು ಆಯ್ದ ಹೋಟೆಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ
        self.corrected_choices = []  # ಸರಿಪಡಿಸಿದ ಆಯ್ಕೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # ಲಭ್ಯವಿರುವ ರಣನೀತಿಗಳು

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # ಕೊನೆಯ ಆಯ್ಕೆ ಉತ್ತಮವೋ ಇಲ್ಲವೋ ಎಂಬುದನ್ನು ನಮಗೆ ಹೇಳುವ ಕೆಲವೊಂದು ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನಾವು ಧಾರಣೆ ಮಾಡೋಣ
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # ಹಿಂದಿನ ಆಯ್ಕೆ ತೃಪ್ತಿದಾಯಕವಾಗದಿದ್ದರೆ ರಣನೀತಿಯನ್ನು ಸರಿಪಡಿಸಿ
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# ಹೋಟೆಲ್ಗಳ ಪಟ್ಟಿ (ಬೆಲೆ ಮತ್ತು ಗುಣಮಟ್ಟ) ಅವಲೋಕನ ಮಾಡಿ
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ
agent = HotelRecommendationAgent()

# ಹಂತ 1: ಏಜೆಂಟ್ "ಅತಿ ಸಸ್ತಾ" ರಣನೀತಿಯನ್ನು ಬಳಸಿ ಒಂದು ಹೋಟೆಲನ್ನು ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# ಹಂತ 2: ಏಜೆಂಟ್ ಆಯ್ಕೆಯೌಪಚಾರಿಕತೆ ಕುರಿತು ಚಿಂತನ ಮಾಡಿ ಅಗತ್ಯವಿದ್ದರೆ ರಣನೀತಿಯನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# ಹಂತ 3: ಏಜೆಂಟ್ ಮತ್ತೆ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ, ಈ ಸಲ ಸರಿಪಡಿಸಿದ ರಣನೀತಿಯೊಂದಿಗೆ
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

ಏಜೆಂಟುಗಳ ಮೆಟಾಕಾಗ್ನಿಷನ್ ಸಾಮರ್ಥ್ಯಗಳು

ಇಲ್ಲಿ ಮುಖ್ಯವಾಗಿದೆ ಏಜೆಂಟಿನ ಸಾಮರ್ಥ್ಯ:

ತನ್ನ ಹಿಂದಿನ ಆಯ್ಕೆ ಮತ್ತು ತೀರ್ಮಾನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು.
ಆ ಬಿಂಬನೆ ಆಧಾರಿತ ತಂತ್ರವನ್ನು ಗಾತ್ರಮಾನ ಮಾಡುವುದು, ಅಂದರೆ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಮೆಟಾಕಾಗ್ನಿಷನ್.

ಇದು ಸ್ವಲ್ಪ ಸರಳ ಸ್ವರೂಪದ ಮೆಟಾಕಾಗ್ನಿಷನ್ ಆಗಿದ್ದು, ವ್ಯವಸ್ಥೆಯು ಒಳಗಿನ ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರಿತವಾಗಿ ತನ್ನ ತರ್ಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೊಂದಿಕೊಳ್ಳಬಲ್ಲದು.

ಸಮಾರೋಪ

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಉಪಕರಣ, ಅದು AI ಏಜೆಂಟುಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಬಹುಮಟ್ಟಿಗೆ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಮೆಟಾಕಾಗ್ನಿಟಿವ್ ಪ್ರಕ್ರಿಯೆಗಳ ಐಕೋಸistemasೊಂದಿಗೆ, ನೀವು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ, ಹೊಂದಿಕೆಯಾಗುವ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಏಜೆಂಟುಗಳನ್ನು ವಿನ್ಯಾಸ ಮಾಡಬಹುದು. ಮೆಟಾಕಾಗ್ನಿಷನ್ ಸಂಶೋಧನೆಗಾಗಿ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ವಿಸ್ತರಿಸಿ ನೋಡಿ.

ಮೆಟಾಕಾಗ್ನಿಷನ್ ವಿನ್ಯಾಸ ಮಾದರಿಯ ಕುರಿತಾಗಿ ಹೆಚ್ಚಿನ ಪ್ರಶ್ನೆಗಳಿವೆಯೇ?

Microsoft Foundry ಡಿಸ್ಕಾರ್ಡ್ ಗೆ ಸೇರಿ, ಇತರ ಅಭ್ಯಾಸ کرنے والوں ಜೊತೆಗೆ ಭೇಟಿಯಾಗಲು, ಕಾರ್ಯಾಲಯ ಸಮಯಗಳಿಗೆ ಹಾಜರಾಗಲು ಮತ್ತು ನಿಮ್ಮ AI ಏಜೆಂಟುಗಳ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರ ಪಡೆದುಕೊಳ್ಳಿ.

ಹಿಂದಿನ ಪಾಠ

ಬಹು ಏಜೆಂಟ್ ವಿನ್ಯಾಸ ಮಾದರಿ

ಮುಂದಿನ ಪಾಠ

ಉತ್ಪಾದನೆಯಲ್ಲಿ AI ಏಜೆಂಟುಗಳು

ಅಸ್ವೀಕಾರ: ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸಡ್ಡೆಗಳು ಇರಬಹುದು. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜು ಪ್ರಾಮಾಣಿಕ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಮೂಲಕ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಗಳ ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.

This site is open source. Improve this page.