(ఈ పాఠం వీడియోను వీక్షించేందుకు పై చిత్రం పై క్లిక్ చేయండి)

AI ఏజెంట్లలో మెటాకగ్నీషన్ పాఠానికి స్వాగతం! ఈ అధ్యాయం, AI ఏజెంట్లు తమ స్వంత ఆలోచన ప్రక్రియల గురించి ఏ విధంగా ఆలోచించగలవో తెలుసుకోవాలనుకునే ఆరంభస్థాయి వారికి రూపొందించబడింది. ఈ పాఠం ముగింపుకి, మీరు ముఖ్యమైన సూత్రాలను అర్థం చేసుకుని, AI ఏజెంట్ డిజైన్లో మెటాకగ్నీషన్ ఉపయోగించే ప్రాయోగిక ఉదాహరణలతో సమృద్ధి చెందుతారు.

ఈ పాఠాన్ని పూర్తి చేసిన తర్వాత, మీరు:

1. ఏజెంట్ నిర్వచనాలలో తర్క సంక్రాంతుల ప్రభావాలను అర్థం చేసుకోవచ్చు.
2. స్వయం-సరి చేసుకునే ఏజెంట్స్‌కు ప్లానింగ్ మరియు మూల్యాంకన సాంకేతికతలను ఉపయోగించగలరు.
3. విధులు సాదించేందుకు కోడ్‌ని సవరించగల మీ స్వంత ఏజెంట్లు సృష్టించగలరు.

మెటాకగ్నీషన్ అంటే మనం మన ఆలోచనల గురించి ఆలోచించడం వంటి ఉన్నత స్థాయి జ్ఞాన ప్రక్రియలను సూచిస్తుంది. AI ఏజెంట్ల కోసం, దీనర్థం స్వీయ అవగాహన మరియు గత అనుభవాల ప్రాతిపదికన తమ చర్యలను మూల్యాంకనం చేసి సవరించగలగటం. "ఆలోచన గురించి ఆలోచించడం" అనే మెటాకగ్నీషన్, ఏజెంటిక్ AI సిస్టమ్స్ అభివృద్ధిలో ముఖ్యమైన కాన్సెప్టు. ఇది AI సిస్టమ్స్ తమ స్వంత అంతర్గత ప్రక్రియలను తెలుసుకొని, వారి ప్రవర్తనను పర్యవేక్షించడము, నియంత్రించడము మరియు సరిపడేటట్టు మార్చుకోవడాన్ని కలిగి ఉంటుంది. మనం గది పరిస్థితిని అర్థం చేసుకుంటున్నప్పుడు లేదా సమస్య చూశప్పుడు అందే అవగాహనటి లాంటిది. ఈ స్వీయ అవగాహన AI సిస్టమ్స్ మెరుగైన నిర్ణయాలు తీసుకోవడంలో, తప్పులను గుర్తించడంలో మరియు కాల పరిమితిలో వారి పనితీరును మెరుగుపరచడంలో సహాయపడుతుంది- తిరిగి ట్యూరింగ్ పరీక్షకు మరియు AI takeover మీద ఉన్న చర్చకు కూడా ఇది సంబంధం కలిగి ఉంది.

ఏజెంటిక్ AI సిస్టమ్స్ సందర్భంలో, మెటాకగ్నీషన్ ఈ సమస్యల పరిష్కారానికి సహాయపడుతుంది:

• పారదర్శకత: AI సిస్టమ్స్ తమ తర్కం మరియు నిర్ణయాలను వివరిస్తగలగాలి.
• తర్కం: AI సిస్టమ్స్ సమాచారాన్ని సింథసైజ్ చేసి మంచి నిర్ణయాలు తీసుకోవడంలో సామర్ధ్యం పెరగాలి.
• అనుకూలత: కొత్త పరిసరాలు మరియు మారుతున్న పరిస్థితులకు అనుగుణంగా AI సిస్టమ్స్ సర్దుబాటు చేసుకోగలగాలి.
• గ్రహణశక్తి: AI సిస్టమ్స్ తమ పరిసరాల నుండి డేటాను గుర్తించడం మరియు అర్థం చేసుకోవడంలో ఖచ్చితత్వాన్ని మెరుగుపర్చాలి.

మెటాకగ్నీషన్, లేదా "ఆలోచన గురించి ఆలోచన," అనేది ఉన్నత స్థాయి జ్ఞాన ప్రక్రియ, ఇది స్వీయ అవగాహన మరియు జ్ఞాన ప్రక్రియలపై స్వీయ నియంత్రణ కలిగి ఉంటుంది. AI రంగంలో, మెటాకగ్నీషన్ ఏజెంట్లను తమ వ్యూహాలు మరియు చర్యలను మూల్యాంకనం చేసి అప్‌డేట్ చేసుకోవడంలో శక్తివంతం చేస్తుంది, తద్వారా సమస్య పరిష్కారం మరియు నిర్ణయ తీసుకోవడంలో మెరుగుదల వస్తుంది. మెటాకగ్నీషన్ అర్థం చేసుకుని, మీరు కేవలం తెలివైన కాకుండా ఎక్కువ అనుకూలించగలిగే, సమర్థవంతమైన AI ఏజెంట్లను డిజైన్ చేయవచ్చు. నిజమైన మెటాకగ్నీషన్‌లో, AI స్పష్టంగా తన తర్కాన్ని గురించి తానే తర్కిస్తుంటుంది.

ఉదాహరణ: “నేను చౌకగా విమానాలు ఆలోచించాను ఎందుకంటే… నాకు డైరెక్ట్ ఫ్లైట్లను మిస్ కావడం జరుగవచ్చు, కాబట్టి మళ్లీ తనిఖీ చేస్తాను.” ఎంతగానో లేదా ఎందుకు ఒక దారి ఎంచుకున్నదో ట్రాక్ చేసుకోవడం.

• గత సారి వినియోగదారు అభిరుచులను ఎక్కువగా ఆధారపడి తప్పులు చేసినప్పుడు, ఏజెంట్ నిర్ణయ తయారీ వ్యూహాన్ని మార్చుతుంది, కేవలం తుది సిఫారసును కాకుండా.
• “వినియోగదారు ‘చాలా సందడి’ అని చెప్పినప్పుడు, నేను కేవలం కొన్ని ఆకర్షణలను తొలగించడం కాకుండా ‘టాప్ ఆకర్షణలను’ ఎంచుకోవడంలో లోపాన్ని గుర్తించాలి” అనే నమూనాలను గుర్తించడం.

AI ఏజెంట్ డిజైన్‌లో మెటాకగ్నీషన్ అనేవి అనేక కారణాలతో కీలక పాత్ర పోషిస్తుంది:

• స్వీయ-పరిశీలన: ఏజెంట్లు తమ పనితీరును అంచనా వేసి మెరుగుదల అవసరాలను గుర్తించగలవు.
• అనుకూలత: ఏజెంట్లు గత అనుభవాలు మరియు మారుతున్న పరిసరాల ఆధారంగా వ్యూహాలను మార్చుకోవచ్చు.
• లోపాలు సరిదిద్దుట: ఏజెంట్లు స్వయంచాలకంగా లోపాలను గుర్తించి సరిదిద్దగలవు, తద్వార ఖచ్చితమైన ఫలితాలు వస్తాయి.
• వనరు నిర్వహణ: ఏజెంట్లు కాలం మరియు కంప్యూటేషనల్ శక్తి వంటి వనరులను మెరుగైన విధంగా వినియోగించుకోవచ్చు.

మెటాకగ్నిటివ్ ప్రక్రియల్లోకి వెళ్ళే ముందు, AI ఏజెంట్ యొక్క ప్రాథమిక భాగాలను అర్థం చేసుకోవడం అవసరం. సాధారణంగా ఒక AI ఏజెంట్ ఇతర ముఖ్య భాగాలు కలిగి ఉంటుంది:

• పర్సోనా: ఏజెంట్ యొక్క వ్యక్తిత్వం మరియు లక్షణాలు, వినియోగదారుల తో ఎలా ప్రవర్తిస్తుందో నిర్వచిస్తాయి.
• టూల్స్: ఏజెంట్ చేయగల సామర్థ్యాలు మరియు ఫంక్షన్లు.
• నైపుణ్యాలు: ఏజెంట్ కలిగిన జ్ఞానం మరియు ప్రావీణ్యం.

ఈ భాగాలు కలిసి ఒక "నైపుణ్య యూనిట్" గా పనిచేసి నిర్దిష్ట పనులను చేస్తాయి.

ఉదాహరణ: మీకు ఒక ట్రావెల్ ఏజెంట్ ఉంది అని భావించండి, ఇది మీ సెలవును మాత్రమే ప్లాన్ చేయదు, కానీ నిజ సమయ డేటా మరియు గత కస్టమర్ ప్రయాణ అనుభవాల ప్రాతిపదికన దారి సర్దుబాటు కూడా చేస్తుంది.

మీరు AI శక్తితో ట్రావెల్ ఏజెంట్ సర్వీస్ డిజైన్ చేస్తున్నారని ఊహించండి. ఈ ఏజెంట్ "ట్రావెల్ ఏజెంట్" వినియోగదారులకు వారి సెలవులను ప్లాన్ చేయటంలో సహాయం చేస్తుంది. మెటాకగ్నీషన్ చేర్పించడానికి, ట్రావెల్ ఏజెంట్ స్వీయ అవగాహన మరియు గత అనుభవాల ఆధారంగా తన చర్యలను మూల్యాంకనం చేసి సవరించాలి. దీన్ని ఇలా చూడవచ్చు:

ప్రస్తుతం వినియోగదారుకి పారిస్ ప్రయాణం ప్లాన్ చేయడంలో సహాయం చేయాలి.

1. వినియోగదారుడి అభిరుచులను సేకరించటం: ప్రయాణ తేదీలు, బడ్జెట్, ఇష్టాలు (ఉదా. మ్యూజియంలు, వంటకాలు, షాపింగ్) మరియు ప్రత్యేక అవసరాల గురించి అడగండి.
2. సమాచారం సేకరణ: వినియోగదారుడి అభిరుచులకు సరిపడే విమానాలు, ఆశ్రయాలు, ఆకర్షణలు, రెస్టారెంట్లు శోధించండి.
3. సిఫారసులు రూపొందించండి: వ్యక్తిగతీకరించిన ప్రణాళికను ఇచ్చి, విమాన వివరాలు, హోటల్ బుకింగ్‌లు, సూచించిన కార్యకలాపాలను అందించండి.
4. ప్రతిస్పందన ఆధారంగా సర్దుబాటు: సిఫారసులపై వినియోగదారుడి అభిప్రాయాన్ని తీసుకుని అవసరమైన మార్పులు చేయండి.

• విమానాలు మరియు హోటల్ బుకింగ్ డేటాబేస్‌లకు ప్రాప్తి.
• పారిస్ ఆకర్షణలు, రెస్టారెంట్ల సమాచారం.
• గత పరస్పర చర్యల నుండి వినియోగదారుల అభిప్రాయ డేటా.

ట్రావెల్ ఏజెంట్ తన పనితీరును మూల్యాంకనం చేసి గత అనుభవాల నుండి నేర్చుకుంటుంది. ఉదాహరణకి:

1. వినియోగదారుల అభిప్రాయ విశ్లేషణ: ఏవి స్మృతి ప్రాప్తం పొందిన సిఫారసులన్నీ బాగున్నాయో, అవి కాకపోయేదీ ఎలాంటి అని చూచి భవిష్యత్ సూచనలను సవరిస్తుంది.
2. అనుకూలత: వినియోగదారుడు గతంలో కూడా పెద్ద జనసందడే ఇష్టపడకుండా ఉన్నట్లయితే, ట్రావెల్ ఏజెంట్ ముందు కాలంలో పాపులర్ టూరిస్టు చోట్లను సూచించకుండా ఉంటుంది.
3. లోప సవరణ: గత బుకింగ్ లో ఏజెంట్ చేసిన తప్పులు (ఉదా. పూర్తిగా బుక్ అయిపోయిన హోటల్ సూచన) ఉంటే, తదుపరి సిఫారసుల ముందు ఆవailability బాగా చదువుకుంటుంది.

మెటాకగ్నీషన్ చేర్పించినప్పుడు ట్రావెల్ ఏజెంట్ కోడ్ ఎలా ఉండవొచ్చో సులభీకరించిన ఉదాహరణ ఇలా ఉంటుంది:

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)

• స్వీయ-పరిశీలన: ఏజెంట్లు తమ పనితీరును విశ్లేషించి మెరుగుదల అవసరాలను గుర్తించగలరు.
• అనుకూలత: అభిప్రాయం మరియు మారుతున్న పరిస్థితుల ఆధారంగా వ్యూహాలను మార్చుకోవచ్చు.
• లోప సవరణ: ఏజెంట్లు స్వతంత్రంగా తప్పులను గుర్తించి సరి చేసుకుంటారు.
• వనరు నిర్వహణ: కాలం మరియు కంప్యూటేషనల్ శక్తి వంటి వనరులను సద్వినియోగంచుకోవచ్చు.

మెటాకగ్నీషన్ చేర్పించడం వల్ల ట్రావెల్ ఏజెంట్ మరింత వ్యక్తిగతీకరించిన, ఖచ్చితమైన ట్రావెల్ సిఫారసులు ఇచ్చే సామర్థ్యం పెరుగుతుంది, ఇది వినియోగదారుని అనుభవాన్ని మెరుగుపరుస్తుంది.

---

ఏజెంట్ ప్రవర్తనలో ప్లానింగ్ ఒక కీలక భాగం. ఇది లక్ష్యాన్ని సాధించేందుకు అవసరమైన దశలను ప్రస్తుత స్థితి, వనరులు మరియు సమర్థవంతమైన వ్యత్యయాలను పరిగణనలో ఉంచుతూ రూపొందించడం.

• ప్రస్తుత పని: పనిని స్పష్టంగా నిర్వచించు.
• పని పూర్తి చేసే దశలు: పనిని పరిమిత దశలుగా విభజించు.
• కావలసిన వనరులు: అవసరమైన వనరులను గుర్తించు.
• అనుభవం: గత అనుభవాలను ప్రణాళికలో ఉపయోగించు.

ఉదాహరణ: వినియోగదారుని ట్రిప్ సక్రమంగా ప్లాన్ చేయటానికి ట్రావెల్ ఏజెంట్ తీసుకోవలసిన దశలు:

1. వినియోగదారుడి అభిరుచులను సేకరించు

   • ప్రయాణ తేదీలు, బడ్జెట్, ఇష్టాలు మరియు ప్రత్యేక అవసరాల గురించి అడగండి.
   • ఉదాహరణలు: "మీరు ఎప్పుడు ప్రయాణం చేయాలనుకుంటున్నారు?" "మీ బడ్జెట్ పరిధి ఎంత?" "మీకు సెలవులో ఏమైనా ప్రత్యేక కార్యకలాపాలు ఇష్టం?"

2. సమాచారం సేకరించు

   • వినియోగదారుడి కోరుకున్న అంచనా ఆధారంగా ప్రయాణ ఆప్షన్లు శోధించండి.
   • విమానాలు: అందుబాటులో ఉన్న విమానాలు, బడ్జెట్ మరియు తేదీలతో సరిపోయే విధంగా చూడండి.
   • ఆశ్రయాలు: ప్రదేశం, ధర, సౌకర్యాల పరిగణతో హోటల్స్ లేదా అద్దె ప్రాపర్టీలను పొందండి.
   • ఆకర్షణలు మరియు రెస్టారెంట్లు: వినియోగదారుల ఆసక్తులకు అనుగుణంగా ప్రముఖ ఆకర్షణలు, కార్యకలాపాలు మరియు భోజన అవకాశాలను గుర్తించండి.

3. సిఫారసులు రూపొందించు

   • సేకరించిన సమాచారంతో వ్యక్తిగతీకరించిన ప్రణాళికను తయారుచేయండి.
   • విమాన వివరాలు, హోటల్ రిజర్వేషన్లు, సూచించిన కార్యకలాపాలను అందించండి.

4. ప్రణాళికను వినియోగదారునికి అందించు

   • వినియోగదారుడు సమీక్షించుకునేందుకు ప్రతిపాదిత ప్రణాళికను పంచుకోండి.
   • ఉదాహరణ: "పారిస్ మీరు చేస్తారనే ప్రయాణానికి ఇది ప్రతిపాదిత ప్రణాళిక. ఇందులో విమాన వివరాలు, హోటల్ బుకింగ్లు మరియు సూచించిన కార్యకలాపాలు ఉన్నాయి. మీ అభిప్రాయాన్ని తెలియజేయండి!"

5. ప్రతిస్పందన సేకరణ

   • ప్రతిపాదిత ప్రణాళికపై వినియోగదారుడి నుంచి అభిప్రాయం సేకరించండి.
   • ఉదాహరణలు: "విమాన ఆప్షన్లు మీకు ఇష్టమాయెనా?" "హోటల్ మీ అవసరాలకు తగినదా?" "మీకసెలవులో ఏమైనా చేర్చాలనుకొంటున్న కార్యకలాపాలున్నాయా?"

6. ప్రతిస్పందన ఆధారంగా సర్దుబాటు చేయండి

   • వినియోగదారుడి అభిప్రాయానికి అనుగుణంగా ప్రణాళికను సవరించండి.
   • విమానాలు, ఆశ్రయాలు మరియు కార్యకలాపాల సిఫారసులను వినియోగదారుల అభిరుచులకు తగునట్లు మార్చండి.

7. అంతిమ నిర్ధారణ

   • సవరించిన ప్రణాళికను వినియోగదారుని సమీక్ష కోసం అందించండి.
   • ఉదాహరణ: "మీ అభిప్రాయం ప్రాతిపదిగా మార్పులు చేశాను. ఇది హాజరు ప్రణాళిక. ఎటువంటి సమస్యా ఉందా?"

8. రిజర్వేషన్లు బుక్ చేసి నిర్ధారించండి

   • వినియోగదారుడు ప్రణాళికను ఒప్పుకున్న తర్వాత, విమానాలు, ఆశ్రయాలు, ఇతర యోజనలు బుక్ చేయండి.
   • నిర్ధారణ వివరాలను వినియోగదారునికి పంపండి.

9. నిరంతర మద్దతు అందించండి

   • ప్రయాణ సమయంలో మరియు ముందుగా మార్పులు లేదా అదనపు అభ్యర్థనలకు సహాయం చేయడానికి సిద్ధంగా ఉండండి.
   • ఉదాహరణ: "మీ ప్రయాణంలో ఏదైనా సహాయం కావాలంటే ఎప్పుడైనా నన్ను సంప్రదించండి!"

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)

ముందుగా RAG టూల్ మరియు ప్రీ-ఎంప్టివ్ కాంటెక్స్ట్ లోడింగ్ మధ్య తేడా తెలుసుకుందాం

RAG లో రిట్రీవల్ సిస్టమ్ మరియు జనరేటివ్ మోడల్ కలుస్తాయి. ప్రశ్న వచ్చినప్పుడు, రిట్రీవల్ సిస్టమ్ సంబంధిత పత్రాలు లేదా డేటాను బాహ్య మూలం నుండి తెస్తుంది, ఆ సమాచారంతో జనరేటివ్ మోడల్ ఇన్‌పుట్‌ని బలోపేతం చేస్తుంది. ఇది మోడల్ ఉత్తమ ఖచ్చితమైన మరియు సందర్భానుకూలమైన ప్రతిస్పందనలు ఇవ్వడానికి సహాయపడుతుంది.

RAG సిస్టమ్‌లో ఏజెంట్ జ్ఞాన వనరుల నుండి సంబంధిత సమాచారాన్ని పొందించి, సరైన ప్రతిస్పందనలు లేదా చర్యలు రూపొందిస్తుంది.

సరి చేసుకునే RAG పద్ధతి RAG సాంకేతికతలను ఉపయోగించి AI ఏజెంట్లలో ఖచ్చితత్వం పెంచటం మరియు లోపాలను సరి చేసుకోవడంపై దృష్టి పెట్టుతుంది. ఇందులో:

1. ప్రాంప్టింగ్ పద్ధతి: ఏజెంట్ సరైన సమాచారాన్ని తెచ్చుకోవడానికి ప్రత్యేకమైన ప్రాంప్ట్స్ ఉపయోగించడం.
2. టూల్: ఏజెంట్ తెచ్చుకున్న సమాచార సార్థకతను అంచనా వేసి ఖచ్చితమైన ప్రతిస్పందనలు తయారుచేసే అల్గోరిథమ్స్ మరియు ప్రక్రియలు.
3. మూల్యాంకనం: ఏజెంట్ పనితీరును నిరంతరం పరిశీలించి ఖచ్చితత్వం మెరుగుదల కోసం సమాన్ని సవరించడం.

వినియోగదారుల ప్రశ్నలకు వెబ్ నుండి సమాచారాన్ని తెచ్చుకునే సెర్చ్ ఏజెంట్‌ను పరిగణించండి. సరి చేసుకునే RAG ఈ విధంగా ఉండవచ్చు:

1. ప్రాంప్టింగ్ పద్ధతి: వినియోగదారుడి ఇన్‌పుట్ ఆధారంగా సెర్చ్ ప్రశ్నలను రూపొందించడం.
2. టూల్: సహజ భాషా ప్రాసెసింగ్ మరియు మెషీన్ లెర్నింగ్ ఉపయోగించి సెర్చ్ ఫలితాలను ర్యాంక్ మరియు ఫిల్టర్ చేయటం.
3. మూల్యాంకనం: తెచ్చిన సమాచారంలో పొరపాట్లను గుర్తించి వాటిని సరిదిద్దేందుకు వినియోగదారుల అభిప్రాయాన్ని విశ్లేషించడం.

సరి చేసుకునే RAG (Retrieval-Augmented Generation) AI యొక్క సమాచార తెచ్చుకోగల సామర్థ్యం మరియు లోపాలు సరి చేసుకునే శక్తిని పెంచుతుంది. ట్రావెల్ ఏజెంట్ సరి చేసుకునే RAG ను ఎలా ఉపయోగించవచ్చు చూద్దాం:

ఇది:

• ప్రాంప్టింగ్ పద్ధతి: ఏజెంట్ సరైన సమాచారాన్ని తెచ్చుకోవడానికి ప్రత్యేక ప్రాంప్ట్స్ ఉపయోగిస్తుంది.
• టూల్: తెచ్చుకున్న సమాచార ప్రాసెసింగ్, ఖచ్చితమైన ప్రతిస్పందన తయారీకి అల్గోరిథమ్స్ అమలుచేస్తుంది.
• మూల్యాంకనం: ఏజెంట్ పనితీరును నిరంతరం పరిశీలించి మెరుగుదల కోసం మార్పులు చేయుతుంది.

1. మొదటి వినియోగదారుతో పరస్పర చర్య

   • ట్రావెల్ ఏజెంట్ గమ్యం, ప్రయాణ తేదీలు, బడ్జెట్, ఆసక్తులు వంటి ప్రాథమిక అభిరుచులను సేకరిస్తుంది.

   • ఉదాహరణ:

     preferences = {
         "destination": "Paris",
         "dates": "2025-04-01 to 2025-04-10",
         "budget": "moderate",
         "interests": ["museums", "cuisine"]
     }
     

2. సమాచారం తెచ్చుకోవడం

   • వినియోగదారుల అభిరుచులపై ఆధారపడి విమానాలు, ఆశ్రయాలు, ఆకర్షణలు మరియు రెస్టారెంట్ల గురించి సమాచారం సేకరిస్తుంది.

   • ఉదాహరణ:

     flights = search_flights(preferences)
     hotels = search_hotels(preferences)
     attractions = search_attractions(preferences)
     

3. ప్రాథమిక సిఫారసులు తయారు చేయడం

   • సేకరించిన సమాచారంతో వ్యక్తిగతీకరించిన ప్రణాళికను రూపొందిస్తుంది.

   • ఉదాహరణ:

     itinerary = create_itinerary(flights, hotels, attractions)
     print("Suggested Itinerary:", itinerary)
     

4. వినియోగదారుల అభిప్రాయం సేకరణ

   • ప్రాథమిక సిఫారసులపై వినియోగదారుని అభిప్రాయం అడుగుతుంది.

   • ఉదాహరణ:

     feedback = {
         "liked": ["Louvre Museum"],
         "disliked": ["Eiffel Tower (too crowded)"]
     }
     

5. సరి చేసుకునే 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)

ప్రి-ఎంప్టివ్ కాంటెక్స్ట్ లోడ్ అంటే క్వెరీని ప్రాసెస్ చేసేముందు సంబంధిత కాంటెక్స్ట్ లేదా నేపథ్య సమాచారాన్ని మోడల్‌లో లోడ్ చేయడం. దీని అర్థం, మోడల్ ఆ సమాచారాన్ని ఆరంభం నుండి యాక్సెస్ చేయగలదు, అందువలన అదనపు డేటా యాత్ర సమయంలో పొందాల్సిన అవసరం లేకుండా మరింత సుగమమైన, సమాచారంతో కూడిన ప్రతిస్పందనలు సృష్టించగలదు.

ఇక్కడ ట్రావెల్ ఏజెంట్ అప్లికేషన్ కోసం ప్రి-ఎంప్టివ్ కాంటెక్స్ట్ లోడ్ ఎలా ఉంటుందో ఒక సరళీకృత ఉదాహరణ ఉంది 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"))

1. ఇనిషియలైజేషన్ (__init__ మెథడ్): TravelAgent క్లాస్ ప్రముఖ గమ్యస్థానాలైన ప్యారీ, టోక్యో, న్యూ యార్క్, సిడ్నీ గురించి సమాచారం కలిగిన డిక్షనరీని ముందుగానే లోడ్ చేస్తుంది. ఈ డిక్షనరీలో ప్రతి గమ్యస్థానం గురించి దేశం, కరెన్సీ, భాష, ప్రధాన ఆకర్షణలు వంటి వివరాలు ఉంటాయి.

2. సమాచారం పొందటం (get_destination_info మెథడ్): యూజర్ ఒక నిర్దిష్ట గమ్యస్థానం గురించి క్వెరీ చేసినప్పుడు, get_destination_info మెథడ్ ముందుగా లోడ్ చేసిన కాంటెక్స్ట్ డిక్షనరీ నుండి సంబంధిత సమాచారాన్ని తీసుకుంటుంది.

ప్రి-లోడింగ్ చేయడం వలన, ట్రావెల్ ఏజంట్ అప్లికేషన్ రియల్-టైంలో ఇన్ఫర్మేషన్ పొందకుండా యూజర్ క్వెరీస్‌కు త్వరగా స్పందించగలదు. ఇది అప్లికేషన్‌ను మరింత సమర్థవంతంగా మరియు ప్రతిస్పందించేలా చేస్తుంది.

లక్ష్యంతో ప్రణాళికను బూట్‌స్ట్రాప్ చేయడం అంటే స్పష్టమైన లక్ష్యం లేదా గమ్యాన్ని ముందుగానే నిర్దేశించడం. ఈ లక్ష్యాన్ని ముందుగా నిర్వచించడం ద్వారా మోడల్ దీన్ని గైడింగ్ ప్రిన్సిపల్‌గా ఉపయోగించి పునరావృత ప్రక్రియలో ప్రయాణిస్తుంది. దీని వల్ల ప్రతి పునరావృతం కోరిన ఫలితానికి దగ్గరగా కదులుతుంది, తద్వారా ప్రాసెస్ మరింత సమర్థవంతంగా మరియు కేంద్రీకృతంగా ఉంటుంది.

ఇక్కడ Python లోని ట్రావెల్ ఏజెంట్ కోసం లక్ష్యంతో ప్రణాళికను బూట్‌స్ట్రాప్ చేసి పునరావృతం ఎలా చేయాలో ఒక ఉదాహరణ ఉంది:

ఒక ట్రావెల్ ఏజెంట్ కస్టమర్ కోసం వ్యక్తిగత కస్టమైజ్డ్ సెలవుల ప్రణాళిక చేయాలనుకుంటున్నాడు. లక్ష్యం కస్టమర్ అభిరుచులు, బడ్జెట్ ప్రామాణికంగా గరిష్ఠ తృప్తిని కలిగించే యాత్రా ప్రయాణ ప్రణాళిక రూపొందించడం.

1. కస్టమర్ అభిరుచులు మరియు బడ్జెట్ నిర్వచించండి.
2. ఆ అభిరుచుల ఆధారంగా ప్రాథమిక ప్రణాళికను బూట్‌స్ట్రాప్ చేయండి.
3. ప్రణాళికను పునరావృతం చేసి, కస్టమర్ తృప్తి కోసం ఆప్టిమైజ్ చేయండి.

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)

1. ఇనిషియలైజేషన్ (__init__ మెథడ్): TravelAgent క్లాస్ వెనుక ఉన్న గమ్యస్థానాల జాబితాతో ఇనిషియలైజ్ అవుతుంది, ప్రతీ గమ్యానికి పేరు, ఖర్చు, చಟువటికాల రకం వంటి లక్షణాలు ఉంటాయి.

2. ప్రణాళిక బూట్‌స్ట్రాప్ చేయడం (bootstrap_plan మెథడ్): ఈ మెథడ్ కస్టమర్ అభిరుచులు మరియు బడ్జెట్ ఆధారంగా ప్రారంభ యాత్రా ప్రణాళికను సృష్టిస్తుంది. ఇది గమ్యస్థానాలను పునరావృతం చేస్తూ, కస్టమర్ యొక్క అభిరుచులకు సరిపోయినవాటిని మరియు బడ్జెట్ లోపల వున్నవాటిని ప్రణాళికలో చేర్పిస్తుంది.

3. అభిరుచులు సరిపోయేమో పరీక్షించడం (match_preferences మెథడ్): గమ్యస్థానం కస్టమర్ అభిరుచులకు సరిపోయిందా అని తనిఖీ చేస్తుంది.

4. ప్రణాళిక పునరావృతం చేయడం (iterate_plan మెథడ్): ప్రారంభ ప్రణాళికను మెరుగుపరచడానికి ప్రయత్నిస్తుంది, ప్రతీ గమ్యాన్ని మరింత మంచి సరిపోవడంతో మార్చి, అభిరుచులు మరియు బడ్జెట్ పరిమితుల్ని పరిగణలోకి తీసుకుంటుంది.

5. ఖర్చును లెక్కించడం (calculate_cost మెథడ్): ప్రస్తుత ప్రణాళిక యొక్క మొత్తం ఖర్చు, కొత్త గమ్యంతో కలిపి, లెక్కిస్తుంది.

• ప్రాథమిక ప్రణాళిక: ట్రావెల్ ఏజెంట్ కస్టమర్ అభిరుచులకు అనుగుణంగా సైట్సీయింగ్ కోసం మరియు $2000 బడ్జెట్ కోసం ప్రారంభ ప్రణాళికను సృష్టిస్తాడు.
• పునరావృత ప్రణాళిక: ట్రావెల్ ఏజెంట్ ప్రణాళికను పునరావృతం చేసి, కస్టమర్ అభిరుచి, బడ్జెట్ ప్రకారం ఆప్టిమైజ్ చేస్తాడు.

లక్ష్యం స్పష్టంగా ఉన్న ప్రణాళికను బూట్‌స్ట్రాప్ చేసి, దాన్ని పునరావృతం చేయడం ద్వారా ట్రావెల్ ఏజెంట్ కస్టమర్ కోసం కస్టమైజ్డ్ మరియు ఆప్టిమైజ్డ్ ట్రావెల్ ఇట్టినరరీని తయారు చేయవచ్చు. ప్రారంభం నుండే కస్టమర్ అభిరుచులు, బడ్జెట్ తో ప్రణాళిక అనుగుణంగా ఉంటుంది మరియు ప్రతి పునరావృతంతో మెరుగవుతుంది.

పెద్ద భాషా మోడళ్లు (LLMs) రీ-రാങ്കింగ్ మరియు స్కోరింగ్ కోసం ఉపయోగించవచ్చు, ఎందుకంటే అవి స్వీకరించిన డాక్యుమెంట్లు లేదా రూపొందించిన ప్రతిస్పందనల సామర్థ్యం మరియు నాణ్యతను అంచనా వేస్తాయి. ఇది ఎలా పని చేస్తుందో చూడండి:

ಗ್ರಹಣ: ప్రాథమిక retrieval దశ ప్రశ్న ఆధారంగా అభ్యర్థి డాక్యుమెంట్లు లేదా ప్రతిస్పందనలను తెస్తుంది.

రీ-రాంకింగ్: LLM అభ్యర్థులని సముచితత మరియు నాణ్యత పునఃస్థానం ఆధారంగా మళ్లీ స్థానం ఇస్తుంది. ఇది అత్యుత్తమ, అత్యంత సంబంధిత సమాచారం ముందుగా చూపించబడేలా చేస్తుంది.

స్కోరింగ్: LLM ప్రతీ అభ్యర్థికి సంబంధితత మరియు నాణ్యత‌ను ప్రతిబింబించే స్కోర్లు కలిగి ఉంటుంది. ఇది ఉత్తమ ప్రతిస్పందన లేదా డాక్యుమెంట్‌ను ఎంచుకోవడంలో సహాయపడుతుంది.

LLMs ఉపయోగించి రీ-రాంకింగ్ మరియు స్కోరింగ్ ద్వారా, సిస్టమ్ మరింత సరిగ్గా మరియు సందర్భానుకూల సమాచారం అందించగలదు, దీని వలన యూజర్ అనుభవం మెరుగవుతుంది.

ఇక్కడ యూజర్ పనితీరుల ఆధారంగా ట్రావెల్ గమ్యస్థానాలను రీ-ర్యాంక్ చేసి, స్కోర్ చేయడానికి Large Language Model (LLM) ఎలా ఉపయోగించవచ్చో ఒక ఉదాహరణ ఉంది Python లో:

ట్రావెల్ ఏజెంట్ కస్టమర్ యొక్క అభిరుచుల పై మంచి ట్రావెల్ గమ్యస్థానాలు సిఫార్సు చేయాలనుకుంటున్నాడు. LLM గమ్యస్థానాలను సముచితం అనుసరించి రీ-ర్యాంక్ చేసి, స్కోర్ చేస్తుంది.

1. యూజర్ అభిరుచులను సేకరించండి.
2. వ్యాప్తంగా పరిగణలోకి తీసుకునే ట్రావెల్ గమ్యస్థానాల జాబితాను తెప్పించండి.
3. యూజర్ అభిరుచుల ఆధారంగా LLM ఉపయోగించి రీ-ర్యాంక్ చేసి, స్కోర్ చేయండి.

గత ఉదాహరణను Azure OpenAI సేవలు ఉపయోగించే విధంగా ఎలా నవీకరిస్తారో ఇక్కడ ఉంది:

1. మీకు Azure సబ్‌స్క్రిప్షన్ ఉండాలి.
2. Azure OpenAI వనరును సృష్టించి మీ API కీ పొందండి.

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Azure OpenAI కోసం ప్రాంప్ట్‌ని రూపొందించండి
        prompt = self.generate_prompt(preferences)
        
        # అభ్యర్ధన కోసం హెడర్లు మరియు పేయ్లోడ్‌ను నిర్వచించండి
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # తిరిగి ర్యాంక్ చేయబడిన మరియు స్కోరు చేసిన గమ్యస్థానాలను పొందడానికి Azure OpenAI 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)

1. ఇనిషియలైజేషన్: TravelAgent క్లాస్ గమ్యస్థానాల జాబితాతో ఇనిషియలైజ్ అవుతుంది, ప్రతీ జాబితాలో పేరు మరియు వివరణ వంటి లక్షణాలు ఉంటాయి.

2. సిఫార్సుల్లో పొందడం (get_recommendations మెథడ్): ఈ మెథడ్ Azure OpenAI సేవకు యూజర్ అభిరుచుల ఆధారంగా ప్రాంప్ట్ తయారు చేసి, HTTP POST అభ్యర్థన చేసి, రీ-ర్యాంకింగ్ మరియు స్కోరింగ్ చేసిన గమ్యస్థానాలను తీసుకొస్తుంది.

3. ప్రాంప్ట్ తయారీ (generate_prompt మెథడ్): ఈ మెథడ్ యూజర్ అభిరుచులు మరియు గమ్యస్థానాల జాబితాను கொண்டு Azure OpenAI కోసం ఒక ప్రాంప్ట్ తయారు చేస్తుంది. ప్రాంప్ట్ మోడల్‌ను ఇచ్చిన అభిరుచుల ఆధారంగా గమ్యస్థానాలను రీ-ర్యాంక్ చేసి స్కోర్ చేయమని మార్గనిర్దేశం చేస్తుంది.

4. API కాల్: requests లైబ్రరీకు ఉపయోగించి Azure OpenAI API ఎండ్‌పాయింట్‌కు HTTP POST అభ్యర్థన పంపుతుంది. ప్రతిస్పందన రీ-ర్యాంక్ చేసిన, స్కోర్డ్ గమ్యస్థానాలతో ఉంటుంది.

5. ఉదాహరణ వాడుక: ట్రావెల్ ఏజెంట్ యూజర్ అభిరుచులు (ఉదా: సైట్సీయింగ్, వివిధ సంప్రదాయాలపై ఆసక్తి) సేకరించి Azure OpenAI సేవను ఉపయోగించి గమ్యస్థానాల రీ-ర్యాంకింగ్ మరియు స్కోరింగ్ పొందుతాడు.

your_azure_openai_api_key స్థానంలో మీ అసలైన Azure OpenAI API కీ మరియు https://your-endpoint.com/... స్థానంలో మీ Azure OpenAI డిప్లాయ్‌మెంట్ యొక్క సరైన ఎండ్‌పాయింట్ URLని ఉపయోగించండి.

LLM ద్వారా రీ-ర్యాంకింగ్ మరియు స్కోరింగ్ ఉపయోగించడం వలన, ట్రావెల్ ఏజెంట్ మరింత వ్యక్తిగతం చేసిన, సంబంధిత ట్రావెల్ సిఫార్సులను కస్టమర్లకు అందించగలడు, వారి అనుభవం మరింత మెరుగుపడుతుంది.

Retrieval-Augmented Generation (RAG) ఏఐ ఏజెంట్‌ల అభివృద్దిలో ప్రాంప్టింగ్ సాంకేతికతగా మరియు ఒక టూల్‌గా ఉండవచ్చు. వీటి మధ్య తేడాను అర్థం చేసుకోవడం RAGని మీ ప్రాజెక్టులలో మరింత సమర్థవంతంగా ఉపయోగించడంలో సహాయపడుతుంది.

ఏమిటి?

• ప్రాంప్టింగ్ సాంకేతికతగా, RAG పెద్ద కార్పస్ లేదా డేటాబేస్ నుండి సంబంధిత సమాచారాన్ని తిరిగి తెచ్చే కోసం నిర్దిష్ట క్వెరీలు లేదా ప్రాంప్ట్‌లను రూపొందించడం. ఆ సమాచారాన్ని తర్వాత ప్రతిస్పందనలు లేదా చర్యలు ఉత్పత్తి చేయడం కోసం ఉపయోగిస్తారు.

ఇది ఎలా పనిచేస్తుంది:

1. ప్రాంప్ట్‌లు రూపొందించండి: పనికి లేదా యూజర్ ఇన్‌పుట్‌కు అనుగుణంగా బాగా నిర్మితమైన ప్రాంప్ట్‌లు లేదా క్వెరీలు సృష్టించండి.
2. సమాచారాన్ని తిరిగి తీసుకోండి: ప్రాంప్ట్‌లను ఉపయోగించి ముందే ఉన్న జ్ఞానసంపద లేదా డేటాసెట్ నుండి సంబంధిత డేటాను వెతకండి.
3. ప్రతిస్పందన సృష్టించండి: తిరిగి తీసుకున్న సమాచారాన్ని జనరేటివ్ AI మోడళ్లతో కలిపి సమగ్రమైన మరియు సముచితం ప్రతిస్పందన ఉత్పత్తి చేయండి.

ట్రావెల్ ఏజెంట్‌లో ఉదాహరణ:

• యూజర్ ఇన్‌పుట్: "నేను ప్యారీస్లో మ్యూజియమ్స్ చూడవలనున్నాను."
• ప్రాంప్ట్: "ప్యారీస్లో టాప్ మ్యూజియమ్స్ తెలుసుకో."
• తిరిగి వచ్చిన సమాచారం: Louvre Museum, Musée d'Orsay వివరాలు.
• రూపొందించిన ప్రతిస్పందన: "ప్యారీస్లో కొన్ని శ్రేష్ఠమైన మ్యూజియమ్స్ ఇవే: Louvre Museum, Musée d'Orsay, Centre Pompidou."

ఏమిటి?

• టూల్‌గా, RAG అనేది ఒక ఐక్యీకృత వ్యవస్థ, ఇది retrieval మరియు generation ప్రక్రియలను ఆటోమేటిగ్గా నిర్వహిస్తుంది, ప్రతి క్వెరీకి ప్రాంప్ట్‌లు తయారు చేయకుండా అభివృద్ధి దారులకు క్లిష్ట AI ఫంక్షనాలిటీలను సులభతరం చేస్తుంది.

ఇది ఎలా పనిచేస్తుంది:

1. ఇంటిగ్రేషన్: AI ఏజెంట్ నిర్మాణంలో RAGని చేరుస్తారు, తద్వారా ఇది retrieval మరియు generation పనులను ఆటోమేటిగ్గా నిర్వహిస్తుంది.
2. ఆటోమేషన్: ఉపయోక్త ఇన్‌పుట్‌ను స్వీకరించి, తుది ప్రతిస్పందన సృష్టించే మొత్తం ప్రక్రియను టూల్ నిర్వహిస్తుంది.
3. సమర్థవంతత: retrieval మరియు generation ప్రక్రియను సరళీకృతం చేసి ఏజెంట్ పనితీరును మెరుగుపరుస్తుంది, త్వరిత మరియు ఖచ్చితమైన ప్రతిస్పందనలను అందిస్తుంది.

ట్రావెల్ ఏజెంట్ లో ఉదాహరణ:

• యూజర్ ఇన్‌పుట్: "నేను ప్యారీస్లో మ్యూజియమ్స్ చూడాలనుకుంటున్నాను."
• RAG టూల్: ఆటోమేటిగ్గా మ్యూజియమ్స్ గురించి సమాచారాన్ని తెచ్చి ప్రతిస్పందన రూపొందిస్తుంది.
• రూపొందించిన ప్రతిస్పందన: "ప్యారీస్లో కొన్ని ప్రముఖ మ్యూజియమ్స్: Louvre Museum, Musée d'Orsay, Centre Pompidou."

అంశం	ప్రాంప్టింగ్ సాంకేతికత	టూల్
మాన్యువల్ vs ఆటోమేటిక్	ప్రతి క్వెరీ కోసం ప్రాంప్ట్‌లను మాన్యువల్‌గా రూపొందించాలి.	retrieval మరియు generation ప్రక్రియలు ఆటోమేటైజ్ చేయబడ్డాయి.
నియంత్రణ	retrieval ప్రక్రియపై ఎక్కువ నియంత్రణ ఇస్తుంది.	retrieval మరియు generation సులభతరం చేస్తుంది.
లచీలా ధర్మం	నిర్దిష్ట అవసరాల కోసం అనుకూలమైన ప్రాంప్ట్‌లను అనుమతిస్తుంది.	పెద్ద స్థాయి అమలు కోసం మరింత సమర్థవంతం.
సంకీర్నత	ప్రాంప్ట్‌లను రూపొందించడం మరియు సరిచేయడం అవసరం.	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 ఏజెంట్‌లలో సంబంధితత ఎలా అంచనా వేయాలో ప్రాక్టికల్ ఉదాహరణలు, సాంకేతికతలతో చూద్దాం.

1. కాంటెక్స్ట్ అవేర్‌నెస్:

   • ఏజెంట్ యూజర్ క్వెరీ యొక్క సందర్భాన్ని అర్థం చేసుకుని సంబంధిత సమాచారాన్ని తీసుకోవాలి.
   • ఉదాహరణ: "ప్యారీస్లో బెటర్ రెస్టారెంట్లు" అని అడిగినప్పుడు, యూజర్ అభిరుచులు (క్యుయిజిన్ రకం, బడ్జెట్) దృష్టిలో పెట్టుకోవాలి.

2. ఖచ్చితత్వం:

   • ఏజెంట్ ఇచ్చే సమాచారం వాస్తవానికి సరైనది, తాజా సమాచారం అయి ఉండాలి.
   • ఉదాహరణ: ప్రస్తుతం తెరవబడిన, మంచి రివ్యూలు ఉన్న రెస్టారెంట్లు సూచించడం, పాత లేదా మూసివేడిన ఆప్షన్లను కాకాదు.

3. యూజర్ ఉద్దేశ్యం:

   • క్వెరీ వెనుక ఉన్న యూజర్ ఉద్దేశ్యాన్ని అర్థం చేసుకుని సరైన సమాచారం అందించాలి.
   • ఉదాహరణ: "బడ్జెట్-ఫ్రెండ్లీ హోటల్స్" అడిగితే, సేద్యం మీద గౌరవం చూపించే ఆప్షన్లను అందించాలి.

4. ఫీడ్‌బ్యాక్ లూప్:

   • యూజర్ ఫీడ్‌బ్యాక్ సేకరించి విశ్లేషించి సంబంధితత అంచనాను మెరుగుపరచాలి.
   • ఉదాహరణ: గత సిఫార్సులపై యూజర్ రేటింగ్స్ తీసుకుని తదుపరి ప్రతిస్పందనలలో ఉపయోగించడం.

1. సంబంధితత స్కోరింగ్:

   • ప్రతి తిరిగి వచ్చిన అంశానికి యూజర్ క్వెరీ, అభిరుచులతో ఎంత సరిసాటి ఉందో పరిశీలించి స్కోరు ఇవ్వడం.

   • ఉదాహరణ:

     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
     

2. ఫిల్టరింగ్ మరియు ర్యాంకింగ్:

   • సంబంధంలేని అంశాలను తొలగించి, మిగిలిన వాటిని సంబంధితత స్కోర్ ఆధారంగా వరుసగా సర్దుబాటు చేయడం.

   • ఉదాహరణ:

     def filter_and_rank(items, query):
         ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
         return ranked_items[:10]  # టాప్ 10 సంబంధిత అంశాలను తిరిగి ఇవ్వండి
     

3. నేచురల్ లాంగ్వేజ్ ప్రాసెసింగ్ (NLP):

   • యూజర్ క్వెరీను అర్థం చేసుకుని సంబంధిత సమాచారం తిరిగి తెచ్చేందుకు NLP పద్ధతులు ఉపయోగించడం.

   • ఉదాహరణ:

     def process_query(query):
         # యూజర్ యొక్క ప్రశ్న నుండి ముఖ్యమైన సమాచారాన్ని తీసుకోవడానికి NLP ను ఉపయోగించండి
         processed_query = nlp(query)
         return processed_query
     

4. యూజర్ ఫీడ్‌బ్యాక్ సమన్వయం:

   • అందించిన సిఫార్సులపై యూజర్ ఫీడ్‌బ్యాక్ సేకరించి తదుపరి సంబంధితత అంచనాలను సవరించడం.

   • ఉదాహరణ:

     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)

ఉద్దేశ్యంతో శోధన అంటే యూజర్ క్వెరీ వెనుక అసలు లక్ష్యాన్ని, గమ్యాన్ని అర్థం చేసుకుని సంబంధిత మరియు ఉపయోగకరమైన సమాచారం తిరిగి తెచ్చేందుకు చర్యలు తీసుకోవడం. ఇది కీవర్డ్స్ సరిపింపుకు మించి యూజర్ యొక్క వాస్తవ అవసరాలని, సందర్భాన్నీ గ్రహిస్తుంది.

1. యూజర్ ఉద్దేశ్యం అర్థం చేసుకోవడం:

   • ఉద్దేశ్యాలు మూడు ప్రధాన రకాలుగా వర్గీకరించవచ్చు: సమాచారాత్మక, నావిగేషనల్, లావాదేవీ
     • సమాచారాత్మక ఉద్దేశ్యం: యూజర్ ఒక విషయం గురించి సమాచారాన్ని కోరుకుంటున్నాడు (ఉదా: "ప్యారీస్‌లో ఉత్తమ మ్యూజియమ్స్ ఏవి?").
     • నావిగేషనల్ ఉద్దేశ్యం: యూజర్ ఒక నిర్దిష్ట వెబ్‌సైట్ లేదా పేజీకి వెళ్లదలచినవాడు (ఉదా: "Louvre Museum అధికారిక వెబ్‌సైట్").
     • లావాదేవీ ఉద్దేశ్యం: యూజర్ విమానం బుక్ చేయడం లేదా కొనుగోలు చేయడం వంటి లావాదేవీచేయాలనుకుంటున్నాడు (ఉదా: "ప్యారీస్‌కు విమానం బుక్ చేయాలి").

2. కాంటెక్స్ట్ అవేర్‌నెస్:

   • యూజర్ క్వెరీ పరిధి, పూర్వ ఇన్‌టరాక్షన్స్, అభిరుచులు మరియు ప్రస్తుత క్వెరీ వివరాలతో ఉద్దేశ్యాన్ని ఖచ్చితంగా గుర్తించడానికి విశ్లేషించడం.

3. నేచురల్ లాంగ్వేజ్ ప్రాసెసింగ్ (NLP):

   • NLP పద్ధతులు ఉపయోగించి యూజర్ అందించిన సహజభాష క్వెరీల్ని అర్థం చేసుకోటం, ఎంటిటీ గుర్తింపు, భావ విశ్లేషణ, క్వెరీ పార్సింగ్ చేయడం.

4. వ్యక్తిగతీకరణ:

   • యూజర్ చరిత్రము, అభిరుచులు మరియు ఫీడ్‌బ్యాక్ ఆధారంగా శోధన ఫలితాలను వ్యక్తిగతీకరించడం, సంబంధితతను పెంచడం.

ట్రావెల్ ఏజెంట్‌ను ఉదాహరణగా తీసుకుని ఉద్దేశ్యంతో శోధన ఎలా అమలు చేయాలో చూద్దాం.

1. యూజర్ అభిరుచులను సేకరించడం

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

2. యూజర్ ఉద్దేశ్యాన్ని అర్థం చేసుకోవడం

   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"
   

3. కాంటెక్స్ట్ అవేర్‌నెస్

   def analyze_context(query, user_history):
       # ప్రస్తుత అభ్యర్థనను వినియోగదారు చరిత్రతో కలిపి సందర్భాన్ని అర్థం చేసుకోండి
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   

4. ఫలితాలను శోధించడం మరియు వ్యక్తిగత పరచడం

   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 వ్యక్తిగతీకరించబడిన ఫలితాలను తిరిగి ఇవ్వండి
   

5. ఉదాహరణ వినియోగం

   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)
   

---

కోడ్ జనరేట్ చేసే ఏజెంట్లు AI మోడెల్స్ ఉపయోగించి కోడ్ రాయడం మరియు అమలు చేయడం ద్వారా సంక్లిష్ట సమస్యలను పరిష్కరించి, టాస్కులను ఆటోమేటింగ్ చేస్తాయి.

కోడ్ జనరేట్ చేసే ఏజెంట్లు జనరేటివ్ AI మోడెల్స్‌ను ఉపయోగించి కోడ్ రాయడం మరియు అమలు చేస్తాయి. ఈ ఏజెంట్లు వివిధ ప్రోగ్రామింగ్ భాషల్లో కోడ్‌ను ఉత్పత్తి చేసి నడిపించడం ద్వారా సంక్లిష్ట సమస్యలను పరిష్కరించగలవు, టాస్కులను ఆటోమేట్ చేయగలవు మరియు విలువయైన అవగాహనలను అందించగలవు.

1. ఆటోమేటెడ్ కోడ్ జనరేషన్: డేటా విశ్లేషణ, వెబ్ స్క్రాపింగ్ లేదా మెషీన్ లెర్నింగ్ వంటి నిర్దిష్ట టాస్కుల కోసం కోడ్ స్నిపెట్స్ ఉత్పత్తి చేయడం.
2. RAG గా SQL: డేటాబేసుల నుండి డేటాను పొందడానికి మరియు మానిప్యులేట్ చేయడానికి SQL క్వెరీలను ఉపయోగించడం.
3. సమస్య పరిష్కారం: ఒక నిర్దిష్ట సమస్యను పరిష్కరించడానికి కోడ్ సృష్టించి అమలు చేయడం, ఉదాహరణకు అల్గోరిథమ్‌లను ఆప్టిమైజ్ చేయడం లేదా డేటాను విశ్లేషించడం.

మీరు ఒక కోడ్ జనరేట్ చేసే ఏజెంట్ రూపకల్పన చేస్తున్నారని అనుకుందాం. ఇది ఇలా పని చేయవచ్చు:

1. టాస్క్: ట్రెండ్స్ మరియు నమూనాలను గుర్తించడానికి డేటా సెట్‌ను విశ్లేషించండి.
2. దశలు:
   • డేటా సెట్‌ను డేటా విశ్లేషణ సాధనంలో లోడ్ చేయండి.
   • డేటాను ఫిల్టర్ చేయడానికి మరియు సారాంశం చేయడానికి SQL క్వెరీలను ఉత్పత్తి చేయండి.
   • క్వెరీల‌ను అమలు చేసి ఫలితాలను పొందండి.
   • ఫలితాలను ఉపయోగించి విజువలైజేషన్‌లు మరియు అవగాహనలను సృష్టించండి.
3. అవసర వనరులు: డేటా సెట్ ప్రవేశం, డేటా విశ్లేషణ సాధనాలు, మరియు SQL సామర్ధ్యాలు.
4. అనుభవం: భవిష్యత్ విశ్లేషణల ఖచ్చితత్వం మరియు సంబంధితతను మెరుగుపరచడానికి గత విశ్లేషణ ఫలితాలను ఉపయోగించండి.

ఈ ఉదాహరణలో, మనం యూజర్ల ప్రయాణాన్ని ప్లాన్ చేసుకోవడంలో సహాయపడే కోడ్ ఉత్పత్తి చేసి అమలు చేసే 'Travel Agent' అనే కోడ్ జనరేట్ చేసే ఏజెంట్‌ను రూపకల్పన చేస్తాము. ఈ ఏజెంట్ ప్రయాణ ఎంపికలను తీసుకోవడం, ఫలితాలను ఫిల్టర్ చేయడం మరియు జనరేటివ్ AI ఉపయోగించి ప్రయాణ ప్రణాళికను సమీకరించడం లాంటి పనులను నిర్వహించగలదు.

1. వాడుకరి ప్రాధాన్యాలు సేకరించడం: గమ్యం, ప్రయాణ తేదీలు, బడ్జెట్, మరియు ఆసక్తుల వంటి వాడుకరి ఇన్‌పుట్‌లు సేకరిస్తుంది.
2. డేటాను పొందడానికి కోడ్ ఉత్పత్తి: విమానాలు, హోటల్స్, ఆకర్షణల గురించి డేటాను తెప్పించడానికి కోడ్ స్నిపెట్స్ ఉత్పత్తి చేస్తుంది.
3. ఉత్పత్తి చేసిన కోడ్‌ను అమలు చేస్తుంది: రియల్ టైమ్ సమాచారాన్ని పొందడానికి కోడ్‌ను నడిపిస్తుంది.
4. ప్రయాణ ప్రణాళికను ఉత్పత్తి చేస్తుంది: తెప్పించిన డేటాను వ్యక్తిగత ప్రయాణ ప్రణాళికగా కంపైల్ చేస్తుంది.
5. ఫీడ్‌బ్యాక్ ఆధారంగా సర్దుబాటు చేస్తుంది: వాడుకరి ఫీడ్‌బ్యాక్‌ను పొందటం మరియు అవసరమైతే ఫలితాలను మెరుగుపర్చడానికి కోడ్‌ను మనుగడ చేస్తుంది.

1. వాడుకరి ప్రాధాన్యాలు సేకరించడం

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

2. డేటా పొందడానికి కోడ్ ఉత్పత్తి చేయడం

   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
   

3. ఉత్పత్తి చేసిన కోడ్‌ను అమలు చేయడం

   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)
   

4. ప్రయాణ ప్రణాళికను ఉత్పత్తి చేయడం

   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)
   

5. ఫీడ్‌బ్యాక్ ఆధారంగా సర్దుబాటు

   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)
   

పట్టిక యొక్క స్కీమాను ఆధారంగా తీసుకొని క్వెరీ ఉత్పత్తి ప్రక్రియను పర్యావరణ పరిజ్ఞానంతో మరియు తర్కంతో మెరుగుపరచవచ్చు.

ఇది ఎలా సాధ్యం అవుతుందని ఒక ఉదాహరణ ఇక్కడ ఉంది:

1. స్కీమాను అర్థం చేసుకునడం: సిస్టమ్ పట్టిక యొక్క స్కీమాను అర్థం చేసుకుని ఈ సమాచారంతో క్వెరీ ఉత్పత్తిని స్థిరపరుస్తుంది.
2. ఫీడ్‌బ్యాక్ ఆధారంగా సర్దుబాటు: సిస్టమ్ వాడుకరి ఇష్టాలను ఫీడ్‌బ్యాక్ ఆధారంగా సర్దుబాటు చేసి, స్కీమాలోని ఏ ఫీల్డులను నవీకరించవలసిందో తర్కిస్తుంది.
3. క్వెరీలు ఉత్పత్తి చేసి అమలు చేయడం: సిస్టమ్ తాజా ఇష్టాలను బట్టి నవీకరించిన విమానం మరియు హోటల్ డేటాను పొందడానికి క్వెరీలను ఉత్పత్తి చేసి అమలు చేస్తుంది.

ఈ ఆలోచనలను చేర్చిన నవీకరించిన 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)

1. స్కీమా అవగాహన: schema డిక్షనరీ ఫీడ్‌బ్యాక్ ఆధారంగా ఇష్టాలను ఎలా సర్దుబాటు చేయాలో నిర్వచిస్తుంది. దీని లో favorites మరియు avoid వంటి ఫీల్డులు ఉంటాయి, సంబంధిత సర్దుబాట్లు ఉంటాయి.
2. ఇష్టాల సర్దుబాటు (adjust_based_on_feedback పద్ధతి): ఈ పద్ధతి వాడుకరి ఫీడ్‌బ్యాక్ మరియు స్కీమాను బట్టి ఇష్టాలను సర్దుబాటు చేస్తుంది.
3. పర్యావరణ ఆధారిత సర్దుబాట్లు (adjust_based_on_environment పద్ధతి): ఈ పద్ధతి స్కీమా మరియు ఫీడ్‌బ్యాక్ ఆధారంగా సర్దుబాట్లను తగిన విధంగా వ్యక్తిగతం చేస్తుంది.
4. క్వెరీలు ఉత్పత్తి చేసి అమలు చేయడం: సిస్టమ్ సర్దుబాటు చేసిన ఇష్టాల ఆధారంగా తాజా విమానాలు, హోటల్స్ డేటాను తెప్పించడానికి కోడ్ ఉత్పత్తి చేసి, ఆ క్వెరీల అమలును సిమ్యులేట్ చేస్తుంది.
5. ప్రయాణ ప్రణాళికను ఉత్పత్తి చేయడం: సిస్టమ్ తాజా విమానాలు, హోటల్స్, ఆకర్షణల డేటా ఆధారంగా తాజా ప్రణాళికను సృష్టిస్తుంది.

సిస్టమ్‌ను పర్యావరణ అవగాహనతో మరియు స్కీమా ఆధారిత తర్కంతో రూపొందించడం ద్వారా, ఇది మరింత ఖచ్చితమైన మరియు సంబంధిత క్వెరీలను ఉత్పత్తి చేసుకోవచ్చు, తద్వారా మెరుగైన ప్రయాణ సిఫారసులు మరియు వ్యక్తిగత అనుభవం అందించగలదు.

SQL (స्ट्रక్చర్డ్ క్వెరీ లాంగ్వేజ్) డేటాబేసులతో మెలుకువకు చాలా శక్తివంతమైన సాధనం. Retrieval-Augmented Generation (RAG) విధానం భాగంగా ఉపయోగిస్తే, SQL డేటాబేసుల నుండి సంబంధిత డేటాను తెప్పించడానికి, AI ఏజెంట్లలో ప్రతిస్పందనలు లేదా చర్యలు ఉత్పత్తి చేసేందుకు ఉపయోగించవచ్చు. ట్రావెల్ ఏజెంట్ సందర్భంలో SQL ను RAG సాంకేతికంగా ఎలా ఉపయోగించాలో చూద్దాం.

1. డేటాబేస్ ఇంటరాక్షన్:

   • SQLను డేటాబేస్‌లను క్వెరీ చేసేందుకు, సంబంధిత సమాచారాన్ని తెప్పించుకోవచ్చు మరియు డేటాను మానిప్యులేట్ చేయవచ్చు.
   • ఉదాహరణ: విమాన వివరాలు, హోటల్ సమాచారం, ఆకర్షణలను ట్రావెల్ డేటాబేస్ నుండి తెప్పించుకోవడం.

2. RAGతో ఇంటిగ్రేషన్:

   • SQL క్వెరీలు యూజర్ ఇన్‌పుట్ మరియు ఇష్టాల ఆధారంగా ఉత్పత్తి చేయబడతాయి.
   • తెప్పించిన డేటా ఆధారంగా వ్యక్తిగత సిఫారసులు లేదా చర్యలు రూపొందించబడతాయి.

3. డైనమిక్ క్వెరీ ఉత్పత్తి:

   • కాంటెక్స్ట్ మరియు యూజర్ అవసరాల ఆధారంగా AI ఏజెంట్ హై డైనమిక్ SQL క్వెరీలను సృష్టిస్తాడు.
   • ఉదాహరణ: బడ్జెట్, తేదీలు, ఆసక్తులను బట్టి ఫలితాలను ఫిల్టర్ చేసే SQL క్వెరీలు.

• ఆటోమేటెడ్ కోడ్ జనరేషన్: నిర్దిష్ట పనుల కోసం కోడ్ స్నిపెట్స్ సృష్టించడం.
• RAG గా SQL: డేటా మానిప్యులేషన్ కోసం SQL క్వెరీలు ఉపయోగించడం.
• సమస్య పరిష్కారం: సమస్యలను పరిష్కరించడానికి కోడ్ ఉత్పత్తి చేసి అమలు చేయడం.

ఉదాహరణ: డేటా విశ్లేషణ ఏజెంట్:

1. టాస్క్: ఒక డేటాసెట్‌లో ట్రెండ్స్ కనుగొనడం.
2. దశలు:
   • డేటాసెట్ లోడ్ చేయడం.
   • డేటా ఫిల్టర్ చేయడానికి SQL క్వెరీలు ఉత్పత్తి చేయడం.
   • క్వెరీలు అమలు చేసి ఫలితాలను తెప్పించడం.
   • విజువలైజేషన్లు మరియు అవగాహన ఉత్పత్తి చేయడం.
3. వనరులు: డేటాసెట్ యాక్సెస్, SQL నైపుణ్యం.
4. అనుభవం: భవిష్యత్ విశ్లేషణల మెరుగుదల కోసం గత ఫలితాలను ఉపయోగించడం.

1. వాడుకరి ప్రాధాన్యాలు సేకరించడం

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

2. 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
   

3. 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
   

4. సిఫారసులు ఉత్పత్తి చేయడం

   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)
   

1. విమాన క్వెరీ

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

2. హోటల్ క్వెరీ

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

3. ఆకర్షణ క్వెరీ

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

Retrieval-Augmented Generation (RAG) సాంకేతికంగా SQL ను వినియోగించడం ద్వారా, 'Travel Agent' వంటి AI ఏజెంట్లు సంబంధిత డేటాను డైనమిక్‌గా తెప్పించి, ఖచ్చితమైన మరియు వ్యక్తిగత సూచనలు ఇవ్వగలవు.

మెటాకాగ్నిషన్ అమలును చూపించడానికి, సమస్య పరిష్కరిస్తూ ఒక ఏజెంట్ తన దిశానిర్దేశక ప్రాసెస్‌ను పరిశీలిస్తుంది ఒక సులభమైన ఏజెంట్‌ను సృష్టిద్దాం. ఈ ఉదాహరణలో, ఏజెంట్ హోటల్ని ఎంపిక చేసుకుంటుంది, ఆ ఎంపికపై తన స్వంత తర్కాన్ని ఆవలోకనం చేసుకుంటుంది, ఎటువంటి లోపాలు లేదా అనుకూలంగా లేని ఎంపికలు ఉంటే తన వ్యూహాన్ని సర్దుబాటు చేస్తుంది.

ఈ ఫంక్షనాలిటీని ఒక ప్రాథమిక ఉదాహరణగా సిమ్యులేట్ చేద్దాం, ఏజెంట్ ధర మరియు నాణ్యత ఆధారంగా హోటల్స్ ఎంచుకుంటుంది, అయితే తన నిర్ణయాలపై "ప్రతిబింబం" చూపించి, ఆవత్యాసాల ప్రకారం సర్దుబాటు చేస్తుంది.

1. ప్రాథమిక నిర్ణయం: ఏజెంట్ అత్యల్ప ధర గల హోటల్నే ఎంచుకుంటుంది, నాణ్యత ప్రభావాన్ని అర్థం చేసుకోకుండానే.
2. ఆవలోకనం మరియు మూల్యాంకనం: మొదటి ఎంపిక తరువాత, ఏజెంట్ వాడుకరి ఫీడ్‌బ్యాక్ ద్వారా హోటల్ "చెడు" అనిపించినట్లయితే తన తర్కాన్ని పరిశీలిస్తుంది.
3. వ్యూహ సర్దుబాటు: తర్కాన్వయ ప్రారంభానికి అనుగుణంగా వ్యూహాన్ని పునఃస్మరింపజేశారు: "అత్యల్ప ధర" నుండి "అధిక నాణ్యత" లోకి మారుతుంది, తద్వారా భవిష్యత్తులో మెరుగైన నిర్ణయాలను తీసుకోగలదు.

ఇది ఒక ఉదాహరణ:

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: ఏజెంట్ ఎంపికపై reflexão చేస్తుంది మరియు అవసరమైతే వ్యూహాన్ని సిద్దం చేస్తుంది
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 అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నిస్తున్నప్పటికీ, ఆటోమేటెడ్ అనువాదాలలో పొరపాట్లు లేదా తప్పులుండవచ్చు. మూల నిబంధనల భాషలో ఉన్న ఒరిజినల్ డాక్యుమెంట్‌ను అధికారిక మూలంగా పరిగణించాలి. కీలక సమాచారం కోసం, ప్రొఫెషనల్ మానవ అనువాదం పొందడం మంచిది. ఈ అనువాదాన్ని ఉపయోగించడంతో కలిగే ఏవైనా అపార్థాలు లేదా తప్పు అర్థమే కావడం వల్ల మేము బాధ్యత వహించము.