ai-agents-for-beginners

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

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

ಪರಿಚಯ

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

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

ಈ ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನೀವು ಸಂಪಾದಿಸಬಹುದಾದವು:

ಏಜೆಂಟ್ ವ್ಯಾಖ್ಯಾನಗಳಲ್ಲಿ ತರ್ಕ ಚಕ್ರಗಳ ಪರಿಣಾಮಗಳನ್ನು ಅರಿತುಕೊಳ್ಳುವುದು.
ಸ್ವಯಂ-ಸರಿ ಮಾಡಲು ಸಹಾಯ ಮಾಡುವ ಯೋಜನೆ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ತಂತ್ರಗಳನ್ನು ಬಳಸುವುದು.
ಕಾರ್ಯಗಳನ್ನು ಪೂರೈಸಲು ಕೋಡ್ ಅನ್ನು ತಿದ್ದುಪಡಿ ಮಾಡಲು ಸಾಮರ್ಥ್ಯವಿರುವ ನಿಮ್ಮದೇ ಏಜೆಂಟುಗಳನ್ನು ರಚಿಸುವುದು.

ಮೆಟಾಕಾಗ್ನಿಷನ್‌ಗೆ ಪರಿಚಯ

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

ಏಜೆಂಟ್‌ಿಕ AI ವ್ಯವಸ್ಥೆಗಳ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಮೆಟಾಕಾಗ್ನಿಷನ್ ಕೆಳಗಿನ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು, ಉದಾ:

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

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

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

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

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

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

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

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

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

AI ಏಜೆಂಟ್ ಘಟಕಗಳು

ಮೆಟಾಕಾಗ್ನಿಟಿವ್ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಮುನ್ನಡೆಸಲು, AI ಏಜೆಂಟ್‌ನ ಮೂಲಭೂತ ಘಟಕಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ. AI ಏಜೆಂಟ್ ಸಾಮಾನ್ಯವಾಗಿ ಈ ಭಾಗಗಳಿಂದ ನಿರ್ಮಾಣವಾಗಿದೆ:

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

ಈ ಘಟಕಗಳು ಜೋಡಣೆಯಾಗಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ಪೂರೈಸುವ “ನಿಪುಣತೆ ಘಟಕ”ವನ್ನು ರಚಿಸುತ್ತವೆ.

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

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

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

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

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

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

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

ಬೇಕಾಗಿರುವ ಸಂಪನ್ಮೂಲಗಳು

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

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

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

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

ಪ್ರಾಯೋಗಿಕ ಡೆವಿ ಪ್ರತಿದರ್ಶನ

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಒಳಗೊಂಡಂತೆ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಕೋಡ್ ಒಂದು ಸರಳಲೇ ವೇದಿಕೆಯ ಉದಾಹರಣೆ:

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)

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

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

ಮೆಟಾಕಾಗ್ನಿಷನ್ ಸಹಿತ, ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಹೆಚ್ಚು ವೈಯಕ್ತಿಕ ಮತ್ತು ನಿಖರ ಯಾತ್ರಾ ಶಿಫಾರಸುಗಳನ್ನು ನೀಡಬಹುದು, ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ವೃದ್ಧಿಸುತ್ತದೆ.

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

ಯೋಜನೆ AI ಏಜೆಂಟ್ ವರ್ತನೆಯ ಪ್ರಮುಖ ಘಟಕವಾಗಿದೆ. ಇದು ಗುರಿ ಸಾಧಿಸಲು ಬೇಕಾದ ಹಂತಗಳನ್ನು ಸರಾಗವಾಗಿ ರೂಪಿಸುವುದು, ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ, ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಸಾಧ್ಯವಿರುವ ಅಡ್ಡಿಪಡಿಸುವ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ.

ಯೋಜನೆಯ ഘಟಕಗಳು

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

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

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್ ಹಂತಗಳು

ಬಳಕೆದಾರ ಪ್ರಾಥಮಿಕತೆಗಳನ್ನು ಸಂಗ್ರಹಿಸು
- ಪ್ರಯಾಣ ದಿನಾಂಕ, ಬಜೆಟ್, ಆಸಕ್ತಿಗಳು ಮತ್ತು ವಿಶೇಷ ಅಗತ್ಯಗಳ ಬಗ್ಗೆ ಕೇಳಿ.
- ಉದಾಹರಣೆ: “ನೀವು ಯಾವಾಗ ಪ್ರಯಾಣ ಮಾಡಬೇಕೆಂದು ಯೋಜಿಸುತ್ತಿದ್ದೀರಾ?” “ನಿಮ್ಮ ಬಜೆಟ್ ಎಷ್ಟು?” “ರಜೆ ವೇಳೆ ಯಾವ ರೀತಿಯ ಕ್ರಿಯೆಗಳನ್ನು ನೀವು ಇಷ್ಟಪಡುವಿರಿ?”
ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಿರಿ
- ಬಳಕೆದಾರ ಪ್ರಾಥಮಿಕತೆಗಳ ಆಧಾರದ ಮೇಲೆ ಸಂಬಂಧಿತ ಪ್ರಯಾಣ ಆಯ್ಕೆಗಳು ಹುಡುಕಿ.
- ವಿಮಾನಗಳು: ಬಜೆಟ್ ಮತ್ತು ಪ್ರವಾಸ ದಿನಾಂಕಗಳ ನಡುವಿನ ಲಭ್ಯವಿರುವ ವಿಮಾನಗಳನ್ನು ಹುಡುಕಿ.
- ವಸತಿಗಳು: ಸ್ಥಳ, ಬೆಲೆ ಮತ್ತು ಸೌಲಭ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಹೋಟೆಲ್ ಅಥವಾ ಬಾಡಿಗೆ ಮನೆಗಳನ್ನು ಹುಡುಕಿ.
- ಆಕರ್ಷಣೆಗಳು ಹಾಗೂ ಭೋಜನಾಲಯಗಳು: ಬಳಕೆದಾರ ಆಸಕ್ತಿಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಜನಪ್ರಿಯ ಆಕರ್ಷಣೆಗಳು ಮತ್ತು ಆಹಾರಮಂಡಾಪಗಳನ್ನು ಗುರುತಿಸಿ.
ಶಿಫಾರಸುಗಳನ್ನು ತಯಾರು ಮಾಡಿ
- ಸಂಗ್ರಹಿಸಿದ ಮಾಹಿತಿಯನ್ನು ವೈಯಕ್ತಿಕ ರೂಪರೇಖೆಯಾಗಿ ಸಂಯೋಜಿಸಿ.
- ವಿಮಾನ ಆಯ್ಕೆಗಳು, ಹೋಟೆಲ್ ಕಾಯ್ದುಕೊಡುವಿಕೆ ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಿದ ಕ್ರಿಯೆಗಳ ವಿವರಗಳನ್ನು ನೀಡಿ, ಹೀಗೆ ಬಳಕೆದಾರರಲ್ಲಿ ಆಸಕ್ತಿ ಹೆಚ್ಚಿಸುವಂತೆ.
ಯೋಜನೆಯನ್ನು ಬಳಕೆದಾರನಿಗೆ ಮಂಡಿಸಿ
- ಯೋಚನೆಗಾಗಿ ಪ್ರಸ್ತಾವಿತ ಯೋಜನೆಯನ್ನು ಬಳಕೆದಾರನಿಗೆ ಹಂಚಿಕೊಳ್ಳಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ಯಾರಿಸ್ ಪ್ರವಾಸಕ್ಕೆ ಇದು ಶಿಫಾರಸು ಮಾಡಿದ ಯೋಜನೆ. ಇದರಲ್ಲಿ ವಿಮಾನ ವಿವರಗಳು, ಹೋಟೆಲ್ ಬುಕ್ಕಿಂಗ್ ಗಳು ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಿದ ಚಟುವಟಿಕೆಗಳು ಹಾಗೂ ಆಹಾರಮಂಡಪಗಳ ಪಟ್ಟಿಯಿದೆ. ನಿಮ್ಮ ಅಭಿಪ್ರಾಯ ಹೇಳಿ!”
ಪರಿಹಾರ ಸಂಗ್ರಹಿಸಿ
- ಬಳಕೆದಾರರಿಂದ ಪ್ರಸ್ತಾವಿತ ಯೋಜನೆಯ ಮೆರೆಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆದುಕೊಳ್ಳಿ.
- ಉದಾಹರಣೆ: “ನೀವು ವಿಮಾನ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ ತೃಪ್ತರಾಗಿದ್ದೀರಾ?” “ಹೋಟೆಲ್ ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿ ಇದೆಯಾ?” “ನೀವು ಸೇರಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು ಬಯಸುವ ಚಟುವಟಿಕೆಗಳಿವೆಯಾ?”
ಪ್ರತಿಕ್ರಿಯೆ ಆಧಾರದ ಮೇಲೆ ಸರಿಪಡಿಸು
- ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಗಳ ಆಧಾರದ ಮೇಲೆ ಯೋಜನೆಯನ್ನು ಬದಲಾಯಿಸಿ.
- ವಿಮಾನ, ವಸತಿ ಮತ್ತು ಚಟುವಟಿಕೆ ಶಿಫಾರಸುಗಳನ್ನು ಬಳಕೆದಾರದ ಆಸಕ್ತಿಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಹೊಂದಿಸಿ.
ಕೊನೆಯ ದೃಢೀಕರಣ
- ನವೀಕರಿಸಿದ ಯೋಜನೆಯನ್ನು ಬಳಕೆದಾರನಿಗೆ ಕೊನೆಯ ದೃಢೀಕರಣಕ್ಕಾಗಿ ತೋರಿಸಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ರತಿಕ್ರಿಯೆ ಆಧರಿಸಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದ್ದೇನೆ. ನವೀಕರಿಸಿದ ಯೋಜನೆ ಇಲ್ಲಿದೆ. ಎಲ್ಲವೂ ಹೊಂದಿದೆಯೇ ಎಂದು ತಿಳಿಸಿ.”
ರಿಜರ್ವೇಶನ್ ಬುಕ್ ಮಾಡಿ ಮತ್ತು ದೃಢೀಕರಿಸಿ
- ಬಳಕೆದಾರನು ಯೋಜನೆಯನ್ನು ಒಪ್ಪಿದ ನಂತರ, ವಿಮಾನ, ವಸತಿ ಮತ್ತು ಪೂರ್ವಯೋಜಿಸುತ್ತಾ ಚಟುವಟಿಕೆಗಳನ್ನು ಬುಕ್ ಮಾಡಿ.
- ದೃಢೀಕರಣ ವಿವರಗಳನ್ನು ಬಳಕೆದಾರನಿಗೆ ಕಳುಹಿಸಿ.
ನಿರಂತರ ಬೆಂಬಲ ನೀಡಿ
- ಪ್ರವಾಸ సమయంలో ಬದಲಾವಣೆಗಳು ಅಥವಾ ಹೆಚ್ಚುವರಿ ವಿನಂತಿಗಳಿಗಾಗಿ ಬಳಕೆದಾರನಿಗೆ ಸಹಾಯ ಮಾಡಲು ಲಭ್ಯವಾಗಿರಿ.
- ಉದಾಹರಣೆ: “ನಿಮ್ಮ ಪ್ರವಾಸದಲ್ಲಿರುವ ಯಾವುದೇ ಸಹಾಯಕ್ಕೆ ನಿಮಗೆ ಬೇಕಾದರೆ ಯಾವಾಗಲಾದರೂ ನನ್ನನ್ನು ಸಂಪರ್ಕಿಸಬಹುದು!”

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

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 ಉಪಕರಣ ಮತ್ತು ಪೂರಕ ಸನ್ನಿವೇಶ ಭಾರವನ್ನು (Pre-emptive Context Load) ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.

RAG ಹಾಗೂ ಸನ್ನಿವೇಶ ಭಾರ

ಪುನಃಪ್ರಾಪ್ತ ಸೂಚನೆಯೊಂದಿಗೆ ತಯಾರಿಕೆ (Retrieval-Augmented Generation - RAG)

RAGವು ಪುನಃಪ್ರಾಪ್ತ ವ್ಯವಸ್ಥೆಯನ್ನು ಒಂದು ಉತ್ಪಾದನಾ ಮಾದರಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಪ್ರಶ್ನೆ ಬಂದಾಗ, ಪುನಃಪ್ರಾಪ್ತ ವ್ಯವಸ್ಥೆ ಹೊರಗಿನ ಮೂಲದಿಂದ ಸಂಬಂಧಿತ ದಾಖಲೆಗಳು ಅಥವಾ ದತ್ತಾಂಶಗಳನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಈ ಪಡೆಯಲಾದ ಮಾಹಿತಿಯನ್ನು ಉತ್ಪಾದನಾ ಮಾದರಿಯ ಒಳಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಇದರಿಂದ ಮಾದರಿ ಹೆಚ್ಚು ನಿಖರವಾದ ಮತ್ತು ಸನ್ನಿವೇಶ ಸಂಬಂಧಿತ ಉತ್ತರಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

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

ಸರಿಪಡಿಸುವ RAG ವಿಧಾನ

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

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರಜ್ಞಾನ: ಏಜೆಂಟ್ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಬಳಸುವುದು.
ಆಯ್ತು-ಇಡಿ ಉಪಕರಣ: ರಿಟ್ರೀವ್ ಮಾಡಲಾದ ಮಾಹಿತಿಯ ಪ್ರಸ್ತುತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನಗೆಳೆಯಲು ಮತ್ತು ನಿಖರ ಉತ್ತರ ನಿರ್ಮಿಸಲು ತಮ್ಮ ಚಟುವಟಿಕೆಗಳನ್ನು ನಿಭಾಯಿಸುವ ಯಂತ್ರಾಂಶಗಳನ್ನು ಬಳಸುವುದು.
ಮೌಲ್ಯಮಾಪನ: ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು સતત ಪರಿಗಣಿಸಿ ನಿಖರತೆಯನ್ನು ಮತ್ತು ಪರಿಣಾಮಕಾರಿತ್ವವನ್ನು ವೃದ್ಧಿಸಲು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು.

ಉದಾಹರಣೆ: ಹುಡುಕಾಟ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಸರಿಪಡಿಸುವ RAG

ಒಂದು ಹುಡುಕಾಟ ಏಜೆಂಟ್ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗಳಿಗೆ ವೆಬಿನಿಂದ ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸುತ್ತದೆಂದು ಭಾವಿಸಿ. ಸರಿಪಡಿಸುವ RAG ವಿಧಾನದಲ್ಲಿ:

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರಜ್ಞಾನ: ಬಳಕೆದಾರರ ಮಾಹಿತಿಯ ಆಧಾರದಲ್ಲಿ ಹುಡುಕಾಟ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುವುದು.
ಉಪಕರಣ: ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಯಂತ್ರಾಭ್ಯಾಸ ಮೂಲಕ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ಶ್ರೇಣೀಕರಿಸಿ ಫಿಲ್ಟರ್ ಮಾಡುವುದು.
ಮೌಲ್ಯಮಾಪನ: ಬಳಕೆದಾರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಪಡೆಯಲಾದ ಮಾಹಿತಿಯಲ್ಲಿನ ತಪ್ಪುಗಳನ್ನು ಗುರುತಿಸಿ ಸರಿಪಡಿಸುವುದು.

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಸರಿಪಡಿಸುವ RAG

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

ಇದರಲ್ಲಿ:

ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರಜ್ಞಾನ: ಏಜೆಂಟ್ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಬಳಸುವುದು.
ಉಪಕರಣ: ಪಡೆಯಲಾದ ಮಾಹಿತಿಯ ಪ್ರಸ್ತುತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನಗೆಳೆಯಲು ಮತ್ತು ನಿಖರ ಉತ್ತರಗಳಿಗಾಗಿ ಯಂತ್ರಾಂಶವನ್ನು ಕಾರ್ಯಗತಗೊಳ್ಳಿಸುವುದು.
ಮೌಲ್ಯಮಾಪನ: ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರಂತರವಾಗಿ ಪರಿಶೀಲಿಸಿ ನಿಖರತೆ ಹಾಗೂ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುವため to ಶೋಧಿಸಲು.

ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಸರಿಪಡಿಸುವ 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 ವಿಧಾನವನ್ನು ಒಳಗೊಂಡಂತೆ ಟ್ರಾವೆಲ್ ಏಜೆಂಟ್‌ನ ಸರಳ Python ಕೋಡ್ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

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)

ಪೂರ್ವಭಾವಿ ಸನ್ನಿವೇಶ ಭಾರ (Pre-emptive Context Load)

ಪ್ರೀ-ಎಂಪ್ಟಿವ್ ಕಾನ್ಟೆಕ್ಸ್ಟ್ ಲೋಡ್ ಎಂದರೆ ಪ್ರಶ್ನೆಯನ್ನು 프로ಸ್ಯಸ್ ಮಾಡುವ ಮೊದಲು ಸಂಬಂಧಿತ ಕಾನ್ಟೆಕ್ಸ್ಟ್ ಅಥವಾ ಹಿನ್ನೆಲೆ ಮಾಹಿತಿಯನ್ನು ಮಾದರಿಯಲ್ಲಿ ಲೋಡ್ ಮಾಡುವುದಾಗಿದೆ. ಇದರರ್ಥ ಮಾದರಿಗೆ ಆರಂಭದಿಂದಲೇ ಈ ಮಾಹಿತಿಯ 접근ವಿದ್ದು, ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಡೇಟಾವನ್ನು ಪಡೆಯದೆ ಹೆಚ್ಚು ಮಾಹಿತಿ ಯುಕ್ತ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ತಯಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಹೆಚ್ಚಾಗಿ ಪ್ರಿಯೋಗದ ಉದಾಹರಣೆಯಾಗಿ, Python ನಲ್ಲಿ ಪ್ರಯಾಣ ಏಜೆಂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಗೆ ಪ್ರೀ-ಎಂಪ್ಟಿವ್ ಕಾನ್ಟೆಕ್ಸ್ಟ್ ಲೋಡ್ ಹೇಗೆ ಕಾಣಬಹುದು ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆ:

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 ವಿಧಾನವು ಪೂರ್ವ ಲೋಡ್ ಮಾಡಲಾದ ಕಾನ್ಟೆಕ್ಸ್ಟ್ ನಿಥೋಜಿಕ್ಯದಿಂದ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.

ಪೂರ್ವ ಲೋಡ್ ಮಾಡಿದ ಕಾನ್ಟೆಕ್ಸ್ಟ್ ಮೂಲಕ, ಪ್ರಯಾಣ ಏಜೆಂಟ್ ಅಪ್ಲಿಕೇಶನ್ ತಕ್ಷಣವೇ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದು, ಬಹಿರ್ಮುಖ ಮೂಲದಿಂದ ಈ ಮಾಹಿತಿಯನ್ನು ರಿಯಲ್-ಟೈಮ್‌ನಲ್ಲಿ ಪಡೆಯಬೇಕಾಗಿರುವ ಅವಶ್ಯಕತೆಯಿಲ್ಲದೇ. ఇది ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೆಚ್ಚು ಪ್ರಭಾವಿ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾಶೀಲವಾಗಿ ಮಾಡುತ್ತದೆ.

ಗುರಿ ಇರುವ ಯೋಜನೆಯನ್ನು ಆರಂಭಿಸಿ ಪುನರಾವರ್ತನೆಗೊಳಿಸುವುದು

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

Python ನಲ್ಲಿ ಒಂದು ಪ್ರಯಾಣ ಏಜೆಂಟ್ ಗೆ ಗುರಿ ಹೊಂದಿದ ಯೋಜನೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವ ಮುಂಚೆ ಹೇಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು ಎಂಬುದಕ್ಕೆ ಉದಾಹರಣೆ ಇದಾಗಿದೆ:

ಸನ್ನಿವೇಶ

ಒಂದು ಪ್ರಯಾಣ ಏಜೆಂಟ್ ತನ್ನ ಗ್ರಾಹಕರಿಗೆ ಅವರ ಅಗ್ರಹ ಮತ್ತು ಬಜೆಟ್ ಆಧರಿಸಿ ವೈಯಕ್ತಿಕೀಕೃತ ರಜೆ ಯೋಜನೆಯನ್ನು ರೂಪಿಸಲು ಬಯಸುತ್ತಾನೆ. ಗುರಿ ಎಂದರೆ ಗ್ರಾಹಕನ ತೃಪ್ತಿಯನ್ನು ಗರಿಷ್ಟಗೊಳಿಸುವ ಪ್ರಯಾಣ ಯೋಜನೆಯನ್ನು ತಯಾರಿಸುವುದು.

ಹಂತಗಳು

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

Python ಕೋಡ್

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 ನ ಪುನರ್ರ್ಯಾಂಕಿಂಗ್ ಮತ್ತು ಸ್ಕೋರಿಂಗ್ ಉಪಯೋಗಿಸಿಕೊಳ್ಳುವುದು

ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳನ್ನು (LLM) ಪುನರ್ರ್ಯಾಂಕಿಂಗ್ ಮತ್ತು ಸ್ಕೋರಿಂಗ್ ಗಾಗಿ ಬಳಸಬಹುದು, ಇದು ಪ್ರತಿಕ್ರಿಯೆ ಅಥವಾ ದಾಖಲೆಗಳ ಸಂಬಂಧಿತತೆ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ. ಇದರ ಕಾರ್ಯವಿಧಾನ:

ಪುನರುತ್ಪಾದನೆ: ಪ್ರಾಥಮಿಕ ಹಂತದಲ್ಲಿ, ಪ್ರಶ್ನೆ ಆಧಾರದ ಮೇಲೆ ಅಭ್ಯರ್ಥಿ ದಾಖಲೆಗಳು ಅಥವಾ ಪ್ರತಿಕ್ರಿಯೆಗಳ ಸಂಕಲನ ಪಡೆಯಲಾಗುತ್ತದೆ.

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

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

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

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

ಸನ್ನಿವೇಶ - ಆಸಕ್ತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಯಾಣ

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

ಹಂತಗಳು:

ಬಳಕೆದಾರರ ಆಸಕ್ತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು.
ಸಂಭವನೀಯ ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರಾಪ್ತಿಗೊಳಿಸುವುದು.
LLM ಬಳಸಿ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಪುನರ್ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡುವುದಕ್ಕೆ.

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

ಅಗತ್ಯತೆಗಳು

ನಿಮಗೆ Azure ಸಬ್ಸ್ಕ್ರಿಪ್ಷನ್ ಇರಬೇಕು.
Azure OpenAI ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಿ ಮತ್ತು API ಕೀ ಪಡೆಯಿರಿ.

ಉದಾಹರಣೆಯ Python ಕೋಡ್

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
        }
        
        # ಮರುಶ್ರೇಣಿಗೊಳಿಸಲಾದ ಮತ್ತು ಅಂಕನ ಪಡೆದ ಗಮ್ಯಸ್ಥಳಗಳನ್ನು ಪಡೆಯಲು ಅಜೂರ್ ಓಪನ್‌ಎಐ API ಅನ್ನು ಕರೆಮಾಡಿ
        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 ಕೋಲನ್ನು Azure OpenAI API ಗೆ ಕಳುಹಿಸಿ, ಪುನರ್ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲಾದ ಗಮ್ಯಸ್ಥಳಗಳನ್ನ ಪಡೆಯುತ್ತದೆ.
ಪ್ರಾಂಪ್ಟ್ ರಚನೆ (generate_prompt ವಿಧಾನ): ಈ ವಿಧಾನ ಬಳಕೆದಾರರ ಆಸಕ್ತಿಗಳು ಮತ್ತು ಗಮ್ಯಸ್ಥಳಗಳ ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು Azure OpenAI ಗೆ ರಚಿಸುತ್ತದೆ. ಪ್ರಾಂಪ್ಟ್ ಮಾದರಿಯನ್ನು ಈ ಮಾಹಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಪುನರ್ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡಲು ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ.
API ಕರೆ: requests ಗ್ರಂಥಾಲಯ HTTP POST ವಿನಂತಿಯನ್ನು Azure OpenAI API ನಲ್ಲಿ ಮಾಡುತ್ತದೆ. ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಪುನರ್ರ್ಯಾಂಕ್ ಹಾಗೂ ಸ್ಕೋರ್ ಗಮ್ಯಸ್ಥಳಗಳ ಮಾಹಿತಿಯಿರುತ್ತದೆ.
ಉದಾಹರಣೆಯ ಬಳಕೆ: ಪ್ರಯಾಣ ಏಜೆಂಟ್ ಬಳಕೆದಾರರ ಆಸಕ್ತಿಗಳನ್ನು (ಸೈಟ್ಸೀಯಿಂಗ್ ಮತ್ತು ವಿವಿಧ ಸಂಸ್ಕೃತಿಗಳ ಆಸಕ್ತಿ) ಸಂಗ್ರಹಿಸಿ, Azure OpenAI ಸೇವೆಯ ಸಹಾಯದಿಂದ ಗಮ್ಯಸ್ಥಳ ಶಿಫಾರಸುಗಳನ್ನು ಪುನರ್ರ್ಯಾಂಕ್ ಮತ್ತು ಸ್ಕೋರ್ ಮಾಡುತ್ತದೆ.

your_azure_openai_api_key ಅನ್ನು ನಿಮ್ಮ ನಿಜವಾದ Azure OpenAI API ಕೀ ಮತ್ತು https://your-endpoint.com/... ಅನ್ನು ನಿಮ್ಮ Azure OpenAI ನಿಯೋಜನೆಯ ನಿಜವಾದ ಎಂಡ್‌ಪಾಯಿಂಟ್ URL ನಲ್ಲಿ ಬದಲಾಯಿಸುವುದಾಗಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

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

RAG: ಪ್ರಾಂಪ್ಟಿಂಗ್ ತಂತ್ರ ಮತ್ತು ಸಾಧನ

RAG (Retrieval-Augmented Generation) ಎಐ ಏಜೆಂಟ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಪ್ರಾಂಪ್ಟಿಂಗ್ ತಂತ್ರ ಮತ್ತು ಸಾಧನ ಎರಡೂ ಆಗಿರಬಹುದು. ಈ ಎರಡು ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ತಿಳಿದುಕೊಂಡರೆ ನಿಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ RAG ಅನ್ನು ಹೆಚ್ಚುವರಿ ಶಕ್ತಿಯೊಂದಿಗೆ ಬಳಸಬಹುದು.

ಪ್ರಾಂಪ್ಟಿಂಗ್ ತಂತ್ರವಾಗಿ RAG

ಇದು ಏನು?

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

ಕಾರ್ಯವಿಧಾನ:

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

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

ಬಳಕೆದಾರ ಇನ್ಪುಟ್: “ಪ್ಯಾರಿಸ್ ನಲ್ಲಿ ಮ್ಯೂಸಿಯಂಗಳ ನೋಡ್ಬೇಕಾಗಿದೆ.”
ಪ್ರಾಂಪ್ಟ್: “ಪ್ಯಾರಿಸ್ ನಲ್ಲಿ ಶ್ರೇಷ್ಠ ಮ್ಯೂಸಿಯಂಗಳ ತಿಳಿಸಿ.”
ಪಡೆದ ಮಾಹಿತಿ: ಲೂವ್ ಮ್ಯೂಸಿಯಂ, ಮ್ಯೂಸಿಯಂ ದಿ’ಆರ್ಸೇ ಮೊದಲಾದ ವಿವರಗಳು.
ರಚಿಸಿದ ಪ್ರತಿಕ್ರಿಯೆ: “ಪ್ಯಾರಿಸ್ ನ ಪ್ರಮುಖ ಮ್ಯೂಸಿಯಂಗಳಲ್ಲಿ ಲೂವ್ ಮ್ಯೂಸಿಯಂ, ಮ್ಯೂಸಿಯಂ ದಿ’ಆರ್ಸೇ, ಮತ್ತು ಸೆಂಟರ್ ಪೊಂಜಿಡ್ಯೂ ಸೇರಿವೆ.”

ಸಾಧನವಾಗಿ RAG

ಇದು ಏನು?

ಸಾಧನವಾಗಿ RAG ಒಂದು ಸಂಯೋಜಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದು, ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಹಿತಿ ಪಡೆಯುವ ಮತ್ತು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ತಂತ್ರಜ್ಞರು ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಕೈಯಿಂದ ರೂಪಿಸಬೇಕಾಗದೆ ಜಟಿಲ AI ಕಾರ್ಯಗಳನ್ನ ನೆರವೇರಿಸಬಹುದು.

ಕಾರ್ಯವಿಧಾನ:

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

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

ಬಳಕೆದಾರ ಇನ್ಪುಟ್: “ಪ್ಯಾರಿಸ್ ನಲ್ಲಿ ಮ್ಯೂಸಿಯಂಗಳ ನೋಡ್ಬೇಕಾಗಿದೆ.”
RAG ಸಾಧನ: ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮ್ಯೂಸಿಯಂಗಳ ಮಾಹಿತಿ ಪಡೆದು ಪ್ರತಿಕ್ರಿಯೆ ತಯಾರಿಸುತ್ತದೆ.
ರಚಿಸಿದ ಪ್ರತಿಕ್ರಿಯೆ: “ಪ್ಯಾರಿಸ್ ನ ಪ್ರಮುಖ ಮ್ಯೂಸಿಯಂಗಳಲ್ಲಿ ಲೂವ್ ಮ್ಯೂಸಿಯಂ, ಮ್ಯೂಸಿಯಂ ದಿ’ಆರ್ಸೇ, ಮತ್ತು ಸೆಂಟರ್ ಪೊಂಜಿಡ್ಯೂ ಸೇರಿವೆ.”

ಹೋಲಿಕೆಯು

ಅಂಶ	ಪ್ರಾಂಪ್ಟಿಂಗ್ ತಂತ್ರ	ಸಾಧನ
ಮ್ಯಾನುಯಲ್ vs ಸ್ವಯಂಚಾಲಿತ	ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಮ್ಯಾನುಯಲ್ ಪ್ರಾಂಪ್ಟ್ ರೂಪಿಸುವುದು	ಪಡೆಯುವಿಕೆ ಮತ್ತು ರಚನೆ ಪ್ರಕ್ರಿಯೆಯ ಸ್ವಯಂಚಾಲನೆ
ನಿಯಂತ್ರಣ	ಪಡೆಯುವಿಕೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣ ನೀಡುತ್ತದೆ	ಪಡೆಯುವಿಕೆ ಮತ್ತು ರಚನೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ
ಲವಚಿಕತೆ	ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಅನುಗುಣವಾದ ಪ್ರಾಂಪ್ಟ್ ರೂಪಿಸಲು ಅನುಕೂಲ	ದೊಡ್ಡ ಪ್ರಮಾಣದ ಅನುಷ್ಠಾನಗಳಿಗೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ
ಕಠಿಣತೆ	ಪ್ರಾಂಪ್ಟ್ ತಯಾರಿಕೆ ಮತ್ತು ತಿದ್ದುಪಡಿ ಅಗತ್ಯವಿರುತ್ತದೆ	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 ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಬಹುಮುಖ್ಯ ಅಂಶವಾಗಿದೆ. ಇದು ಏಜೆಂಟ್ ಪಡೆದ ಮತ್ತು ತಯಾರಿಸಿದ ಮಾಹಿತಿಯು ಬಳಕೆದಾರರಿಗೆ ಸೂಕ್ತ, ನಿಖರ ಮತ್ತು ಉಪಯುಕ್ತವಾಗಿರಬೇಕೆಂದು ದೃಢಪಡಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಸಂಬಂಧಿತತೆಯ ಮೌಲ್ಯಮಾಪನ ಹೇಗೆ ನಡೆಸಬಹುದು ಎಂಬುದನ್ನು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ತಂತ್ರಗಳೊಂದಿಗೆ ನೋಡೋಣ.

ಸಂಬಂಧಿತತೆ ಮೌಲ್ಯಮಾಪನದ ಮುಖ್ಯ ಆಲೋಚನೆಗಳು

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

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

ಸಂಬಂಧಿತತೆ ಸ್ಕೋರಿಂಗ್:
- ಪ್ರತಿಯೊಂದು ಪಡೆದ ಐಟಂ ಗೆ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆ ಮತ್ತು ಆಸಕ್ತಿಗೆ ಹೋಲಿಕೆ ಮಾಡಿ ಸಂಬಂಧಿತತೆ ಸ್ಕೋರ್ ನಿಗದಿ ಮಾಡುವುದು.
- ಉದಾ:
```
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)

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

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

ಉದ್ದೇಶದಿಂದ ಹುಡುಕಾಟದ ಮುಖ್ಯ ಆಲೋಚನೆಗಳು

ಬಳಕೆದಾರರ ಉದ್ದೇಶ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು:
- ಬಳಕೆದಾರ ಉದ್ದೇಶವನ್ನು ಮೂರು ಪ್ರಮುಖ ವಿಧಗಳಲ್ಲಿ ವರ್ಗೀಕರಿಸಬಹುದು: ಮಾಹಿತಿ ಹುಡುಕಾಟ, ಮಂಡಳಿ ಹುಡುಕಾಟ ಮತ್ತು ವ್ಯವಹಾರಾತ್ಮಕ ಉದ್ದೇಶ.
  - ಮಾಹಿತಿ ಉದ್ದೇಶ: ಬಳಕೆದಾರ ವಿಷಯದ ಕುರಿತು ತಿಳಿಯಬೇಕಾಗಿದೆ (ಉದಾ., “ಪ್ಯಾರಿಸ್ ನಲ್ಲಿ ಉತ್ತಮ ಮ್ಯೂಸಿಯಂಗಳೇನು?”).
  - ಮಂಡಳಿ ಉದ್ದೇಶ: ಬಳಕೆದಾರ ನಿರ್ದಿಷ್ಟ ವೆಬ್‌ಸೈಟ್ ಅಥವಾ ಪುಟಕ್ಕೆ ಹೋಗಲು ಬಯಸುತ್ತಾನೆ (ಉದಾ., “ಲೂವ್ ಮ್ಯೂಸಿಯಂ ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್”).
  - ವ್ಯವಹಾರಾತ್ಮಕ ಉದ್ದೇಶ: ಬಳಕೆದಾರ ವಿಮಾನ ಟಿಕೆಟ್ ಬುಕ್ ಮಾಡುವುದಿಲ್ಲದ ಹಾಗೆ ವ್ಯವಹಾರ ಮಾಡಲು ಬಯಸುತ್ತಾನೆ (ಉದಾ., “ಪ್ಯಾರಿಸ್ ಗೆ ವಿಮಾನ ಬುಕ್ ಮಾಡಿ”).
ಸಂದರ್ಭ ಜಾಗರೂಕತೆ:
- ಬಳಕೆದಾರನ ಪ್ರಶ್ನೆಯ ಸಂದರ್ಭವನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಅವರ ಉದ್ದೇಶವನ್ನು ನಿಖರವಾಗಿ ಗುರುತಿಸುವುದು. ಇದರಲ್ಲಿ ಹಿಂದಿನ ಸಂವಹನಗಳು, ಆಸಕ್ತಿಗಳು ಮತ್ತು ಪ್ರಸ್ತುತ ಪ್ರಶ್ನೆಯ ವಿಶೇಷ ವಿವರಗಳ ಪರಿಗಣನೆ ಇರುತ್ತದೆ.
ಪ್ರಾಕೃತ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ (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):
    # ಉದಾಹರಣೆ: ಬಳಕೆದಾರರ ಪ್ರಾಧಾನ್ಯತೆಗಳ ಆಧಾರವಾಗಿ ವಿಮಾನಗಳಿಗಾಗಿ ಶೋಧಿಸು ಕೋಡ್ ರಚಿಸಿ
    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)

ಪರಿಸರ ಅರಿವಿನಿಂದ ಮತ್ತು ತರ್ಕದಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯುವಿಕೆ

ಕಟ್ಟುಪಟ್ಟಿಯ_SCHEMA_ ಆಧಾರದ ಮೇಲೆ ಪ್ರಶ್ನೆ ರಚನಾ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರಿಸರ ಅರಿವಿನಿಂದ ಮತ್ತು ತರ್ಕದಿಂದ ಸುಧಾರಿಸಬಹುದು.

ಇದು ಹೇಗೆ ಸಾಧ್ಯ ಅಂತ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

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

ಈ ತತ್ವಗಳನ್ನು ಒಳಗೊಂಡಂತೆ 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 ಅನ್ನು ರಿಟ್ರೀವಲ್-ಆಗ್ಮೆಂಟೆಡ್ ಜನರೇಶನ್ (RAG) ತಂತ್ರವಾಗಿ ಬಳಕೆ

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

ಪ್ರಮುಖ ತತ್ವಗಳು

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

ಅನ್ವಯಗಳು

ಸ್ವಯಂಚಾಲಿತ ಕೋಡ್ ರಚನೆ: ವಿಶೇಷ ಕಾರ್ಯಗಳಿಗೆ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಚಿಸುವುದು.
SQL ಆಗಿ RAG: ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಗಾಗಿ 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';

ರಿಟ್ರೀವಲ್-ಆಗ್ಮೆಂಟೆಡ್ ಜನರೇಶನ್ (RAG) ತಂತ್ರದಲ್ಲಿನ ಭಾಗವಾಗಿ SQL ಬಳಸಿಕೊಡುತ್ತಾ, ಪ್ರಯಾಣ ಏಜೆಂಟ್‌ಗಳಂತಹ AI ಏಜೆಂಟ್‌ಗಳು ಡೈನಾಮಿಕ್ ರೀತಿಯಲ್ಲಿ ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ಪಡೆದು ನಿಖರ ಮತ್ತು ವೈಯಕ್ತಿಕ ಶಿಫಾರಸುಗಳನ್ನು ನೀಡಬಹುದು.

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

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

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

ಹೇಗೆ ಇದರಿಂದ ಮೆಟಾಕಾಗ್ನಿಶನ್ ತೋರಿಸುತ್ತದೆ:

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

ಇದಿದೆ ಉದಾಹರಣೆ:

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 ಏಜೆಂಟ್‌ಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನೂ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಮೆಟಾಕಾಗ್ನಿಶನ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಒಳಗೊಂಡ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ, ಹೊಂದಿಕೆಯಾಗುವ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಏಜೆಂಟ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು. ಹೆಚ್ಚಿನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಉಪಯೋಗಿಸಿ AI ಏಜೆಂಟ್‌ಗಳ ಮೆಟಾಕಾಗ್ನಿಶನ್ ಜಗತ್ತನ್ನು ಇನ್ನಷ್ಟು ಅನ್ವೇಷಿಸಿ.

ಮೆಟಾಕಾಗ್ನಿಶನ್ ವಿನ್ಯಾಸ ಮಾದರಿಯ ಬಗ್ಗೆ ಇನ್ನೂ ಪ್ರಶ್ನೆಗಳಿದೆಯೇ?

Microsoft Foundry Discord ಸೇರಿ, ಇತರ ಕಲಿಯುವವರೊಡನೆ ಭೇಟಿಯಾಗಿರಿ, ಆಫೀಸ್ ಅವರ್‌ಗಳಲ್ಲಿ ಭಾಗವಹಿಸಿ ಮತ್ತು ನಿಮ್ಮ AI ಏಜೆಂಟ್ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರ ಪಡೆಯಿರಿ.

ಹಿಂದಿನ ಅಧ್ಯಾಯ

ಮಲ್ಟಿ-ಏಜೆಂಟ್ ವಿನ್ಯಾಸ ಮಾದರಿ

ಮುಂದಿನ ಅಧ್ಯಾಯ

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

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

This site is open source. Improve this page.