ai-agents-for-beginners

Multi-Agent Design

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

AI ఏజెంట్లలో మెటాకాగ్నిషన్

పరిచయం

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

నేర్చుకునే లక్ష్యాలు

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

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

మెటాకాగ్నిషన్‌కు పరిచయం

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

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

మెటాకాగ్నిషన్ అంటే ఏమిటి?

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

ఉదాహరణ: “నేను తక్కువ ఖర్చరి విమానాలను ప్రాధాన్యం ఇచ్చాను ఎందుకంటే… నేను నేరుగా విమానాలు కోల్పోను భావించి, కాబట్టి తిరిగి తనిఖీ చేద్దాం.” ఎట్లా లేదా ఎందుకు ఒక నిర్దిష్ట మార్గాన్ని ఎంచుకుంది అని గమనించడం.

AI ఏజెంట్లలో మెటాకాగ్నిషన్ ప్రాముఖ్యత

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

Importance of Metacognition

AI ఏజెంట్ భాగాలు

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

ఈ భాగాలు కలిసి ఒక “నైపుణ్య యూనిట్లు” సృష్టించి నిర్దిష్ట పనులను నిర్వహిస్తాయి.

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

ఉదాహరణ: ట్రావెల్ ఏజెంట్ సర్వీస్‌లో మెటాకాగ్నిషన్

మీరు AI ఆధారిత ట్రావెల్ ఏజెంట్ సర్వీస్ రూపకల్పన చేస్తున్నారని ఊహించండి. ఈ “ట్రావెల్ ఏజెంట్” వినియోగదారులకు వారి సెలవులకు సాధారణ సహకారానికి సహాయపడుతుంది. మెటాకాగ్నిషన్‌ను సమ్మిళితం చేయడానికి, ట్రావెల్ ఏజెంట్ తన స్వీయ-ज్ఞానం మరియు గత అనుభవాల ఆధారంగా తన చర్యలను మూల్యాంకనం చేసి సర్దుబాటు చేసుకోవాలి. మెటాకాగ్నిషన్ ఎలా పాత్ర వహిస్తుందో ఇదిగో:

ప్రస్తుత పని

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

పనిని పూర్తి చేయడానికి ఎడుగులు

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

అవసరమైన వనరులు

అనుభవం మరియు స్వీయ-పరిశీలన

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

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

అభ్యాసకుడికి ప్రాక్టికల్ ఉదాహరణ

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

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)
        # అభిప్రాయాలను విశ్లేషించి భవిష్యత్తు సిఫారಸ್ತಿgలను సర్దుబాటు చేయండి
        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 ఏజెంట్ ప్రవర్తనలో కీలక భాగం. ఇది ప్రస్తుత స్థితి, వనరులు, మరియు సాధ్యమైన అడ్డంకులను పరిగణనలోకి తీసుకొని లక్ష్యాన్ని సాధించేందుకు అవసరమైన దశలను కావాల్సేమన్నది.

ప్లానింగ్ అంశాలు

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

ట్రావెల్ ఏజెంట్ కి దశలు

  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)

3. సరిదిద్దు RAG సిస్టమ్

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

RAG vs Context Loading

రిట్రీవల్-ఆగ్మెంటెడ్ జనరేషన్ (RAG)

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

RAG సిస్టమ్ లో, ఏజెంట్ ఒక జ్ఞాన ఒరుకు నుండి సంబంధిత సమాచారాన్ని రిట్రీవ్ చేసి అర్హమైన సమాధానాలు లేదా చర్యల తయారీలో ఉపయోగిస్తుంది.

సరిదిద్దు RAG విధానం

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

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

ఉదాహరణ: శోధనా ఏజెంట్‌లో సరిదిద్దు RAG

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

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

ట్రావెల్ ఏజెంట్‌లో సరిదిద్దు RAG

సరిదిద్దు RAG (రిట్రీవల్-ఆగ్మెంటెడ్ జనరేషన్) ఏజెంట్ లో దోషాలను సరి చేసుకోగలగడం మరియు ఖచ్చితమైన సమాచారాన్ని అందించడం సామర్ధ్యాన్ని పెంచుతుంది. ట్రావెల్ ఏజెంట్ సరిదిద్దు RAG విధానాన్ని ఉపయోగించి మరింత ఖచ్చితమైన మరియు సంబంధిత ప్రయాణ సిఫారసులు ఎలా ఇవ్వగలదో చూడండి.

దీనిలో ఉన్నాయి:

ట్రావెల్ ఏజెంట్ లో సరిదిద్దు 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 విధానం సహా ట్రావెల్ ఏజెంట్‌లోని సరళమైన 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)

ప్రీ-ఎంప్టివ్ కాంటెక్స్ట్ లోడ్

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

ఇక్కడ 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__ method): TravelAgent క్లాస్ ప్యారిస్, టోక్యో, న్యూ యార్క్, సిడ్నీ లాంటి ప్రజాదరణ పొందిన గమ్యస్థానాల సమాచారం కలిగిన డిక్షనరీని ముందుగా లోడ్ చేస్తుంది. ఈ డిక్షనరీలో ప్రతి గమ్యస్థానానికి దేశం, కరెన్సీ, భాష, ప్రధాన ఆకర్షణలు వంటి వివరాలు ఉంటాయి.

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

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

లక్ష్యంతో ప్లాన్ బూట్‌స్ట్రాపింగ్ చేయడం మరియు ఆపై పునరావృతం

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

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

సందర్భం

ఒక ట్రావెల్ ఏజెంట్ క్లయింట్ కోసం అనుకూల నిఖిల విహారం ప్రణాళికను రూపొందించాలని కోరుకుంటున్నాడు. లక్ష్యం క్లయింట్ ఎంపికలు మరియు బడ్జెట్ ఆధారంగా వారి సంతృప్తిని గరిష్టం చేసే ప్రయాణ ఆలోచనను సృష్టించడం.

దశలు

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

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)

కోడ్ వివరణ

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

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

  3. ఎంపికలకు సరిపోలిక (match_preferences method): ఈ పద్ధతి ఒక గమ్యస్థానం క్లయింట్ ఎంపికలకు సరిపోతుందా అని తనిఖీ చేస్తుంది.

  4. ప్లాన్ పునరావృతం (iterate_plan method): ఈ పద్ధతి ప్రాథమిక ప్లాన్‌ను మెరుగుపరుస్తుంది, ప్రణాళికలో ప్రతి గమ్యస్థానాన్ని క్లయింట్ ఎంపికలు మరియు బడ్జెట్ పరిమితుల ఆధారంగా ఉత్తమమయిన గమ్యస్థానంతో మార్చేందుకు ప్రయత్నిస్తుంది.

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

ఉదాహరణ వాడుక

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

రీ-రాంకింగ్ మరియు స్కోరింగ్ కోసం LLM ఉపయోగించడం

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

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

రీ-రాంకింగ్: LLM ఈ అభ్యర్థితులను వెలకట్టడం మరియు వారి సంబంధితత్వం మరియు గుణాత్మకత ఆధారంగా తిరిగి గ్రేడ్ చేస్తుంది. ఈ దశ అత్యంత సంబంధిత మరియు నాణ్యమైన సమాచారాన్ని ముందుగా చూపిస్తుంది.

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

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

Python లో వినియోగదారు ఎంపికల ఆధారంగా ట్రావెల్ గమ్యస్థానాలను రీ-రాంకింగ్ మరియు స్కోరింగ్ చేయడానికి ట్రావెల్ ఏజెంట్ ఎలా LLMను ఉపయోగించగలదో దుస్తునిందొక ఉదాహరణ ఉంది:

సందర్భం - ఎంపికల ఆధారంగా ప్రయాణం

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

దశలు:

  1. వినియోగదారు ఎంపికలు సేకరించండి.
  2. సాధ్యమైన ట్రావెల్ గమ్యస్థానాల జాబితా పొందండి.
  3. వినియోగదారు ఎంపికల ఆధారంగా గమ్యస్థానాలను రీ-రాంక్ చేసి స్కోర్ చేయడానికి LLMను ఉపయోగించండి.

క్రింద మీరు ముందుగా ఉన్న ఉదాహరణను Azure OpenAI సర్వీసులు ఉపయోగించేటట్లు ఎలా మార్చాలో చూపించారు:

అవసరాలు

  1. మీకు Azure సబ్ స్క్రిప్షన్ ఉండాలి.
  2. 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):
        # 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 method): ఈ పద్ధతి వినియోగదారు ఎంపికల ఆధారంగా Azure OpenAI సర్వీస్‌కు ఒక ప్రాంప్ట్‌ని రూపొందించి HTTP POST అభ్యర్థన చేస్తుంది, రీ-రాంక్ మరియు స్కోర్ చేసిన గమ్యస్థానాలను పొందుతుంది.

  3. ప్రాంప్ట్ తయారీ (generate_prompt method): ఈ పద్ధతి 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ను రీ-ర్యాంకింగ్ మరియు స్కోరింగ్ కోసం వినియోగించడం ద్వారా, ట్రావెల్ ఏజెంట్ మరింత వ్యక్తిగతీకరించిన మరియు సంబంధిత ట్రావెల్ సిఫారసులను క్లయింట్లకు అందించి వారి సార్వత్రిక అనుభవాన్ని మెరుగుపరుచగలడు.

RAG: ప్రాంప్టింగ్ సాంకేతికత vs సాధనం

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

RAG ప్రాంప్టింగ్ సాంకేతికతగా

ఇది ఏమిటి?

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

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

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

RAG సాధనంగా

ఇది ఏమిటి?

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

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

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

పోలిక

అంశం ప్రాంప్టింగ్ సాంకేతికత సాధనం
మాన్యువల్ vs ఆటోమేటిక్ ప్రతీ ప్రశ్నకు ప్రాంప్టులను మనually రూపొందించడం. పునఃప్రాప్తి మరియు జనరేషన్ కోసం ఆటోమేటిక్ ప్రాసెస్.
నియంత్రణ పునఃప్రాప్తి ప్రక్రియపై ఎక్కువ నియంత్రణ ఇస్తుంది. పునఃప్రాప్తి మరియు జనరేషన్ ప్రక్రియను సరళీకృతం చేస్తుంది.
లచీలుతనం ప్రత్యేక అవసరాల కోసం అనుకూల ప్రాంప్టులు అనుమతిస్తుంది. పెద్ద ప్రామాణిక అమలులకు మరింత సమర్థవంతం.
సంక్లిష్టత ప్రాంప్టులు రూపొందించడం మరియు సవరించడం అవసరం. 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. సంబంధిత స్కోరింగ్:
    • ప్రతి తెచ్చుకున్న అంశం కి వినియోగదారు ప్రశ్న మరియు ఎంపికలకు ఎంత సరిస amlurate అవుతుందో ఆధారంగా సంబంధిత స్కోరు ఇవ్వడం.

    • ఉదాహరణ:

      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. వినియోగదారు ఉద్దేశ్యం అర్థం చేసుకోవడం:
    • వినియోగదారు ఉద్దేశ్యాన్ని మూడు ప్రధాన రకాలుగా వర్గీకరించవచ్చు: సమాచారాత్మక, నావిగేషనల్, మరియు లావాదేవీ సంబంధమైనది.
      • సమాచారాత్మక ఉద్దేశ్యం: వినియోగదారు అంశం గురించిన సమాచారం కోరుకునేరు (ఉదా: “ప్యారిస్‌లో ఉత్తమ మ్యూజియంలు ఏమిటి?”).
      • నావిగేషనల్ ఉద్దేశ్యం: వినియోగదారు ఒక నిర్దిష్ట వెబ్‌సైట్ లేదా పేజీకి వెళ్ళాలనుకుంటున్నారు (ఉదా: “లూ‌వ్రే మ్యూజియం అధికారిక వెబ్‌సైట్”).
      • లావాదేవీ ఉద్దేశ్యం: వినియోగదారు ఒక లావాదేవీ చేయాలనుకుంటున్నారు, లాటింగ్ బుకింగ్ లేదా కొనుగోలు చేయడం (ఉదా: “ప్యారిస్‌కి విమానం బుక్ చేయండి”).
  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):
    # personalization లాజిక్ యొక్క ఉదాహరణ
    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)

4. సాధనంగా కోడ్ సృష్టించడం

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

కోడ్ సృష్టించే ఏజెంట్లు

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

ప్రయోజనకరమైన అనువర్తనాలు

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

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

మీరు ఒక కోడ్ సృష్టించే ఏజెంట్ రూపొందిస్తున్నట్లు ఊహించుకోండి. ఇది ఎలా పని చేయొచ్చు:

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

ఉదాహరణ: ట్రావెల్ ఏజెంట్ కోసం కోడ్ సృష్టించే ఏజెంట్

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

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

Retrieval-Augmented Generation (RAG) సాంకేతికంగా SQL ఉపయోగించడం

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

ముఖ్య సంజ్ఞలు

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

అనువర్తనాలు

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

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

ప్రయోజనకరమైన ఉదాహరణ: ట్రావెల్ ఏజెంట్‌లో SQL ఉపయోగించడం

  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)

SQL క్వెరీ ఉదాహరణలు

  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ను ఉపయోగించడం ద్వారా, ట్రావెల్ ఏజెంట్ వంటి AI ఏజెంట్లు సంబంధిత డేటాను డైనమిక్‌గా పొందగలుగుతాయి మరియు ఖచ్చితమైన, వ్యక్తిగతీకరించిన సిఫార్సులు అందించగలుగుతాయి.

మెటాకాగ్నిషన్ యొక్క ఉదాహరణ

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

మేము ఒక సింపుల్ ఉదాహరణతో దీనిని సిమ్యులేట్ చేస్తాము, ఇందులో ఏజెంట్ ధర మరియు నాణ్యత ఆధారంగా హోటల్స్‌ను ఎంపిక చేస్తుంది, కానీ తన నిర్ణయాలను “ప్రతిబింబిస్తుంది” మరియు అవసరమైతే సర్దుబాటు చేస్తుంది.

ఇది మెటాకాగ్నిషన్ ఎలా చూపిస్తుంది:

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

ఉదాహరణ:

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

This site is open source. Improve this page.