(यो पाठको भिडियो हेर्न माथि रहेको तस्बिरमा क्लिक गर्नुहोस्)

AI एजेन्टहरूमा मेटाकग्निसन सम्बन्धी पाठमा स्वागत छ! यो अध्याय आरम्भकर्ताहरूका लागि डिजाइन गरिएको छ जसलाई AI एजेन्टहरूले आफ्नो सोच्ने प्रक्रियाबारे कसरी सोच्न सक्छन् भन्ने कुरामा जिज्ञासा छ। यस पाठको अन्त्यमा, तपाईंले प्रमुख अवधारणाहरू बुझ्नुहुनेछ र AI एजेन्ट डिजाइनमा मेटाकग्निसन प्रयोग गर्न व्यावहारिक उदाहरणहरूसँग सुसज्जित हुनुहुनेछ।

यस पाठ पूरा गरेपछि, तपाईं सक्षम हुनुहुनेछ:

1. एजेन्ट परिभाषाहरूमा तर्क गर्ने लूपहरूको प्रभावहरू बुझ्न।
2. आत्म-सुुधार गर्ने एजेन्टहरूको सहायता गर्न योजना बनाउने र मूल्यांकन गर्ने प्राविधिहरू प्रयोग गर्न।
3. कोड सम्हाल्न सक्षम आफ्नै एजेन्टहरू सिर्जना गर्न जसले कार्यहरू पूरा गर्न सक्छन्।

मेटाकग्निसन भन्नाले आफैंको सोच्ने प्रक्रियाबारे सोच्ने उच्च-स्तरको संज्ञानात्मक प्रक्रिया जनाउँछ। AI एजेन्टहरूको लागि, यसको अर्थ आफैंको स्वजात्यता र विगतका अनुभवहरूलाई आधार बनाएर आफ्ना कार्यहरू मूल्यांकन र समायोजन गर्न सक्नु हो। मेटाकग्निसन, वा "सोच्ने बारे सोच्ने," एजेन्टिक AI प्रणाली विकासमा महत्त्वपूर्ण अवधारणा हो। यसले AI प्रणालीहरूलाई आफ्नै आन्तरिक प्रक्रियाहरूको बारेमा सचेत हुन र आफ्नो व्यवहार अनुगमन, नियन्त्रण, तथा अनुकूलन गर्न सक्षम बनाउँछ। जसरी हामी कोठाको अवस्था बुझ्ने वा समस्यालाई हेर्ने गर्थ्यौं, त्यस्तै यो आत्म-जागरुकता AI प्रणालीलाई राम्रो निर्णय लिन, त्रुटिहरू पहिचान गर्न, र समयसँगै आफ्नो प्रदर्शन सुधार गर्न मद्दत गर्दछ — फेरि ट्यूरिङ परीक्षण र AI ले संसार कब्जा गर्ने कि नगर्ने बहससम्म पुर्‍याउँछ।

एजेन्टिक AI प्रणालीहरूको सन्दर्भमा, मेटाकग्निसनले निम्न जस्ता चुनौतीहरू समाधान गर्न मद्दत पुर्याउन सक्छ:

• पारदर्शिता: AI प्रणालीहरूले आफ्नो तर्क र निर्णयहरू स्पष्ट पार्न सकून्।
• तर्क गर्ने क्षमता: AI प्रणालीहरूलाई सूचना संश्लेषण गरेर सोझो निर्णय लिन सक्षम पार्नु।
• अनुकूलन: AI प्रणालीहरूले नयाँ वातावरण र परिवर्तनशील अवस्थाहरूमा आफूलाई अनुकूल बनाउन सकून्।
• अनुभूति: आफ्नो वातावरणबाट प्राप्त डाटा चिन्ने र व्याख्या गर्ने क्षमतामा सुधार ल्याउनु।

मेटाकग्निसन, वा "सोच्ने बारे सोच्ने," आफैंको संज्ञानात्मक प्रक्रियाहरूको स्व-जागरूकता र आत्म-नियन्त्रण समावेश गर्ने उच्च-स्तरको संज्ञानात्मक प्रक्रिया हो। AI क्षेत्रको सन्दर्भमा, मेटाकग्निसन एजेन्टहरूलाई आफ्नो रणनीतिहरू र कार्यहरू मूल्यांकन र अनुकूलन गर्न सशक्त बनाउँछ, जसले समस्या समाधान र निर्णय क्षमतालाई सुधार गर्दछ। मेटाकग्निसन बुझेर, तपाईंले ती AI एजेन्टहरू डिजाइन गर्न सक्नुहुन्छ जुन मात्र बढी बौद्धिक नभएर थप अनुकूलनशील र प्रभावकारी पनि हुन्छन्। साँचो मेटाकग्निसनमा, AI स्पष्ट रूपमा आफ्नै तर्कबारे तर्क गर्दैछ।

उदाहरण: "मैले सस्तो उडानलाई प्राथमिकता दिएँ किनभने... सिधा उडान छुटेको हुन सक्छ, त्यसैले फेरि जाँच गरौं।" कुन मार्ग छान्यो र किन छान्यो त्यसको ट्र्याक राख्नु।

• प्रयोगकर्ताका अघिल्लो लगानी प्राथमिकताहरूमा अत्यधिक निर्भर भएर गल्ती गरेको देखेपछि निर्णय-निर्माण रणनीतिमा परिवर्तन गर्ने, केवल अन्तिम सिफारिस मात्र होइन।
• नियम जाँच गर्दै: "जब प्रयोगकर्ताले ‘धेरै भीड’ भन्छ, म केवल केही आकर्षण हटाउने मात्र होईन, मेरो ‘शीर्ष आकर्षण’ चयन गर्ने तरिका पनि सुधार्नुपर्छ यदि म लोकप्रियताका आधारमा मात्र क्रम बनाउँछु भने।"

मेटाकग्निसनले 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)
        # प्रतिक्रिया विश्लेषण गर्नुहोस् र भविष्यको सिफारिसहरू समायोजन गर्नुहोस्
        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)

• आत्म-प्रतिबिम्ब: एजेन्टहरूले आफ्ना प्रदर्शनहरू विश्लेषण गरेर सुधारका क्षेत्रहरू पत्ता लगाउँछन्।
• अनुकूलनशीलता: एजेन्टहरूले प्रतिक्रिया र परिवर्तित अवस्थाहरू आधारमा रणनीतिहरू समायोजन गर्छन्।
• त्रुटि सुधार: एजेन्टहरूले स्वतन्त्र रूपमा गल्तिहरू पत्ता लगाएर सुधार गर्छन्।
• स्रोत व्यवस्थापन: एजेन्टहरूले समय र कम्प्युटेशनल शक्तिको उपयोग अनुकूलन गर्छन्।

मेटाकग्निसन समावेश गर्दा, यात्रा एजेन्टले अधिक व्यक्तिगत र सटीक यात्रा सिफारिसहरू प्रदान गर्न सक्छ, जसले समग्र प्रयोगकर्ता अनुभव सुधार गर्छ।

---

योजना बनाउनु 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)

पहिले RAG उपकरण र प्रि-एम्प्टिभ कण्टेक्स्ट लोड बीचको भिन्नता बुझौं।

RAGले एक रिट्रीवल प्रणालीलाई जनरेटिव मोडलसँग संयोजन गर्छ। जब प्रश्न सोधिन्छ, रिट्रीवल प्रणालीले बाह्य स्रोतबाट सान्दर्भिक कागजात वा डाटा निकाल्छ, र यो प्राप्त जानकारी जनरेटिव मोडलको इनपुट बढाउन प्रयोग गरिन्छ। यसले मोडललाई बढी सटीक र सान्दर्भिक प्रतिक्रिया उत्पादन गर्न मद्दत गर्दछ।

RAG प्रणालीमा, एजेन्टले ज्ञान भण्डारबाट सान्दर्भिक जानकारी निकाल्छ र उपयुक्त प्रतिक्रिया वा कार्यहरू उत्पादन गर्न प्रयोग गर्छ।

सुधारात्मक RAG दृष्टिकोणले RAG प्राविधिहरू प्रयोग गरेर त्रुटिहरू सुधार्न र AI एजेन्टहरूको शुद्धता बढाउन केन्द्रित हुन्छ। यसमा समावेश हुन्छ:

1. प्रम्प्टिङ प्रविधि: सान्दर्भिक जानकारी पुन: प्राप्त गर्न एजेन्टलाई मार्गदर्शन गर्न विशिष्ट प्रम्प्टहरू प्रयोग गर्नु।
2. उपकरण: एजेन्टलाई प्राप्त जानकारीको सान्दर्भिताको मूल्यांकन र सटीक प्रतिक्रिया उत्पादन सम्भव गराउने एल्गोरिदम र संयन्त्रहरू कार्यान्वयन गर्नु।
3. मूल्यांकन: एजेन्टको प्रदर्शन निरन्तर मूल्यांकन गरेर सुधारका लागि समायोजन गर्नु।

वेबबाट प्रयोगकर्ताका प्रश्नहरूको उत्तर खोज्ने खोज एजेन्ट विचार गर्नुहोस्। सुधारात्मक RAG दृष्टिकोण समावेश गर्न सक्छ:

1. प्रम्प्टिङ प्रविधि: प्रयोगकर्ताको इनपुट अनुसार खोज प्रश्न तयार पार्नु।
2. उपकरण: प्राकृतिक भाषा प्रशोधन र मेसिन लर्निङ एल्गोरिदम प्रयोग गरेर खोज परिणामहरू क्रमबद्ध र फिल्टर गर्नु।
3. मूल्यांकन: प्रयोगकर्ता प्रतिक्रियालाई विश्लेषण गरी प्राप्त जानकारीमा शुद्धता र त्रुटिहरू सुधार गर्नु।

सुधारात्मक RAG (रिट्रीवल-अग्मेन्टेड जेनेरेशन) 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 दृष्टिकोण समावेश गर्दै यात्रा एजेन्टको साधारण 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__ मेथड): 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) लाई पुनः र्याङ्किङ र स्कोरिङका लागि प्रयोग गर्न सकिन्छ जसले पुनःप्राप्त दस्तावेज वा उत्पन्न प्रतिक्रियाहरूको प्रासंगिकता र गुणस्तर मूल्याङ्कन गर्छ। यसरी यो काम गर्छ:

रेकभरी: आरम्भिक चरणमा क्वेरीको आधारमा उम्मेदवार दस्तावेज वा प्रतिक्रियाहरू प्राप्त हुन्छन्।

पुनः र्याङ्किङ: LLM ले ती उम्मेदवारहरूको मूल्याङ्कन गरेर पुनः र्याङ्क गर्छ, जसले सबैभन्दा प्रासंगिक र उच्च गुणस्तरको जानकारी पहिलो प्रस्तुत सुनिश्चित गर्छ।

स्कोरिङ: LLM ले प्रत्येक उम्मेदवारलाई स्कोर प्रदान गर्छ, जसले तिनीहरूको प्रासंगिकता र गुणस्तर प्रतिबिम्बित गर्छ। यसले उपयोगकर्ताका लागि उत्कृष्ट प्रतिक्रिया वा दस्तावेज चयन गर्न मद्दत गर्दछ।

LLM मार्फत पुनः र्याङ्किङ र स्कोरिङ गर्नेले प्रणालीलाई अझ सही र सन्दर्भअनुकूल जानकारी दिन मद्दत गर्दछ, जसले समग्र प्रयोगकर्ता अनुभव सुधार गर्छ।

यहाँ Python मा प्रयोगकर्ताका रुचि अनुसार ट्राभल गन्तव्यलाई पुनः र्याङ्क र स्कोर गर्न कसरी ट्राभल एजेन्टले LLM प्रयोग गर्न सक्छ भन्ने उदाहरण छ:

एक ट्राभल एजेन्ट ग्राहकका रुचि अनुसार उत्कृष्ट ट्राभल गन्तव्यहरू सिफारिस गर्न चाहन्छ। 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 endpoint मा HTTP POST अनुरोध पठाउँछ। प्रतिक्रिया पुनः र्याङ्क र स्कोर गरिएका गन्तव्यहरू समावेश गर्दछ।

5. प्रयोगको उदाहरण: ट्राभल एजेन्टले प्रयोगकर्ताका रुचिहरू (जस्तै, दृश्यावलोकन र विविध संस्कृति) संकलन गरेर Azure OpenAI सेवा प्रयोग गरी पुनः र्याङ्क र स्कोर गरिएका सिफारिसहरू प्राप्त गर्दछ।

your_azure_openai_api_key लाई आफ्नो वास्तविक Azure OpenAI API कुञ्जीसँग र https://your-endpoint.com/... लाई Azure OpenAI डिप्लोयमेन्टको वास्तविक endpoint URL सँग प्रतिस्थापन गर्न निश्चित गर्नुहोस्।

LLM को पुनः र्याङ्क र स्कोरिङ क्षमताको सदुपयोग गरेर ट्राभल एजेन्टले ग्राहकलाई अझ व्यक्तिगत र सान्दर्भिक यात्रा सिफारिसहरू प्रदान गरी उनीहरूको समग्र अनुभव सुधार गर्न सक्छ।

Retrieval-Augmented Generation (RAG) दुबै प्रॉम्प्टिङ प्रविधि र उपकरण हुन सक्छ AI एजेन्ट विकासमा। यी दुई बीचको भिन्नता बुझेर तपाईंले आफ्नो परियोजनाहरूमा RAG लाई अझ प्रभावकारी तरिकाले प्रयोग गर्न सक्नुहुन्छ।

त्यो के हो?

• प्रॉम्प्टिङ प्रविधिको रूपमा, RAG ले ठूलो कर्पस वा डेटाबेसबाट सम्बन्धित जानकारी ल्याउन विशिष्ट क्वेरी वा प्रॉम्प्ट तयार पार्न समावेश गर्छ। त्यसपछि यस जानकारीलाई प्रतिक्रियाहरू वा कार्यहरू उत्पादन गर्न प्रयोग गरिन्छ।

यो कसरी काम गर्छ:

1. प्रॉम्प्ट तयार पार्नु: कार्य वा प्रयोगकर्ताको इनपुटको आधारमा राम्रो संरचित प्रॉम्प्ट वा क्वेरीहरू बनाउनु।
2. जानकारी प्राप्त गर्नु: तयार प्रॉम्प्टको मद्दतले पूर्व-अस्तित्वमा रहेको ज्ञान आधार वा डाटासेटबाट सम्बन्धित डाटा खोज्नु।
3. प्रतिक्रिया उत्पादन गर्नु: प्राप्त जानकारीलाई जेनेरेटिभ AI मोडेलसँग जोडेर सम्पूर्ण र सुसंगत प्रतिक्रिया उत्पादन गर्नु।

ट्राभल एजेन्टमा उदाहरण:

• प्रयोगकर्ताको इनपुट: "म पेरिसका संग्रहालयहरू भ्रमण गर्न चाहन्छु।"
• प्रॉम्प्ट: "पेरिसका शीर्ष संग्रहालयहरू खोज्नुहोस्।"
• प्राप्त जानकारी: लुभ्रे संग्रहालय, म्युसे डोर्से आदि विवरणहरू।
• उत्पन्न प्रतिक्रिया: "यहाँ पेरिसका केही प्रमुख संग्रहालयहरू छन्: लुभ्रे संग्रहालय, म्युसे डोर्से, र सेन्टर पम्पिदु।"

त्यो के हो?

• उपकरणको रूपमा, RAG एक समेकित प्रणाली हो जुन पुनःप्राप्ति र उत्पादन प्रक्रियालाई स्वचालित गर्दछ, जसले विकासकर्ताहरूलाई प्रत्येक क्वेरीका लागि म्यानुअल प्रॉम्प्ट तयार नगरी जटिल AI कार्यक्षमताहरू सजिलै कार्यान्वयन गर्न सक्षम बनाउँछ।

यो कसरी काम गर्छ:

1. एकीकरण: AI एजेन्टको संरचनामा RAG समावेश गरेर स्वतः पुनः प्राप्ति र उत्पादन कार्यहरू हातेमालो गर्ने गरी।
2. स्वचालन: प्रयोगकर्ताको इनपुट प्राप्त देखि अन्तिम प्रतिक्रिया उत्पादनसम्मको सम्पूर्ण प्रक्रिया बिना प्रस्ट प्रॉम्प्ट आवश्यक छ अपरेट गर्ने।
3. कुशलता: एजेन्टको प्रदर्शन सुधार गरी पुनः प्राप्ति र उत्पादन थप शीघ्र र सही बनाउने।

ट्राभल एजेन्टमा उदाहरण:

• प्रयोगकर्ताको इनपुट: "म पेरिसका संग्रहालयहरू भ्रमण गर्न चाहन्छु।"
• RAG उपकरण: स्वतः संग्रहालयहरूको बारेमा जानकारी प्राप्त गरेर प्रतिक्रिया उत्पादन गर्छ।
• उत्पन्न प्रतिक्रिया: "यहाँ पेरिसका केही प्रमुख संग्रहालयहरू छन्: लुभ्रे संग्रहालय, म्युसे डोर्से, र सेन्टर पम्पिदु।"

पक्ष	प्रॉम्प्टिङ प्रविधि	उपकरण
म्यानुअल vs स्वचालित	प्रत्येक क्वेरीका लागि म्यानुअल प्रॉम्प्ट निर्माण।	पुनः प्राप्ति र उत्पादन प्रक्रियाको स्वचालन।
नियन्त्रण	पुनः प्राप्ति प्रक्रियामा बढी नियन्त्रण दिन्छ।	पुनः प्राप्ति र उत्पादन प्रक्रिया सरल र स्वचालित।
लचिलोपन	आवश्यकताअनुसार प्रॉम्प्ट अनुकूलन मिल्छ।	ठूलो परिमाणमा कार्यान्वयनका लागि अधिक कुशल।
जटिलता	प्रॉम्प्ट निर्माण र ट्यूनिङ चाहिन्छ।	AI एजेन्टको संरचनामा सजिलै एकीकृत हुन्छ।

प्रॉम्प्टिङ प्रविधि उदाहरण:

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

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

उपकरण उदाहरण:

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

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

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

प्रासंगिकताको मूल्याङ्कन AI एजेन्ट कार्यसम्पादनको एक महत्वपूर्ण पक्ष हो। यसले सुनिश्चित गर्छ कि एजेन्टले प्राप्त र उत्पन्न गरेको जानकारी उपयुक्त, सही, र प्रयोगकर्ताका लागि उपयोगी छ। आउनुहोस् कसरी 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]  # शीर्ष १० सान्दर्भिक वस्तुहरू फिर्ता गर्नुहोस्
     

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]  # शीर्ष १० सान्दर्भिक वस्तुहरू फिर्ता गर्नुहोस्

    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):
       # उदाहरण निजीकृतकरण तर्क
       personalized = [result for result in results if result not in user_history]
       return personalized[: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. SQL लाई RAG को रूपमा प्रयोग: डेटाबेसबाट डेटा प्राप्त गर्न र परिमार्जन गर्न 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. यात्रा विवरण उत्पादन: प्रणालीले नयाँ उडान, होटेल, र आकर्षण डेटाको आधारमा अद्यावधिक यात्रा योजना बनाउँछ।

परिसर-सजग र स्किमा-आधारित तर्कशक्ति प्रयोग गरेर प्रणालीले बढी ठीक र सान्दर्भिक क्वेरीहरू उत्पादन गर्न सक्छ, जसले राम्रो यात्रा सिफारिसहरू र व्यक्तिगत प्रयोगकर्ता अनुभवलाई प्रवर्धन गर्दछ।

SQL (Structured Query Language) डेटाबेससँग अन्तर्क्रिया गर्ने शक्तिशाली उपकरण हो। Retrieval-Augmented Generation (RAG) दृष्टिकोणको भागको रूपमा प्रयोग गर्दा, SQL ले डेटाबेसबाट सान्दर्भिक डेटा ल्याएर AI एजेन्टहरूमा प्रतिक्रियाहरू वा क्रियाहरू उत्पादन गर्न प्रयोग गर्न सकिन्छ। यात्रा एजेन्टको सन्दर्भमा SQL कसरी RAG प्रविधिको रूपमा प्रयोग गर्न सकिन्छ हेरौं।

1. डेटाबेस अन्तर्क्रिया:

   • SQL डेटाबेसमा क्वेरी गरी सान्दर्भिक जानकारी निकाल्न र डाटालाई परिमार्जन गर्न प्रयोग गरिन्छ।
   • उदाहरण: यात्रा डेटाबेसबाट उडान विवरण, होटल जानकारी, र आकर्षणहरू फेच गर्नु।

2. RAG सँग एकीकरण:

   • SQL क्वेरीहरू प्रयोगकर्ताको इनपुट र प्राथमिकताहरूको आधारमा उत्पादन हुन्छन्।
   • प्राप्त डेटा व्यक्तिगत सिफारिसहरू वा कार्यहरू उत्पादन गर्न प्रयोग गरिन्छ।

3. डायनामिक क्वेरी उत्पादन:

   • AI एजेन्टले सन्दर्भ र प्रयोगकर्ता आवश्यकताका आधारमा डाइनामिक SQL क्वेरीहरू उत्पादन गर्छ।
   • उदाहरण: बजेट, मिति, र रुचिको आधारमा परिणामहरू फिल्टर गर्न SQL क्वेरीहरू अनुकूलित गर्नु।

• स्वचालित कोड उत्पादन: विशिष्ट कार्यका लागि कोड स्निपेटहरू उत्पादन गर्नुहोस्।
• SQL लाई RAG रूपमा प्रयोग: डेटा परिमार्जन गर्न 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 प्रयोग गरेर, यात्रा एजेन्ट जस्ता AI एजेन्टहरूले सान्दर्भिक डेटा गतिशील रूपमा प्राप्त गरी सही र व्यक्तिगत सिफारिसहरू प्रदान गर्न सक्छन्।

त्यसैले Metacognition को कार्यान्वयन देखाउन, एउटा साधारण एजेन्ट बनाऔं जुन समस्या समाधान गर्दा आफ्नो निर्णय प्रक्रियामा प्रतिबिम्बन गर्दछ। यस उदाहरणमा, हामी एक प्रणाली बनाउनेछौं जहाँ एजेन्टले होटल छनोटमा मूल्य र गुणस्तरको संयोजनको आधारमा छनोट गर्छ, तर पछि आफ्नो तर्क मूल्याङ्कन गरी त्रुटि वा उपयुक्त नभएका छनोटहरूमा रणनीति समायोजन गर्छ।

हामीले यसलाई एउटा आधारभूत उदाहरण प्रयोग गरेर सिमुलेट गर्नेछौं जहाँ एजेन्टले "सबैभन्दा सस्तो" होटल चयन गर्छ, तर आफ्ना निर्णयहरूको प्रतिबिम्ब गर्दै आधारमा सुधार गर्दछ।

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: एजेन्टले छनौटमा विचार गर्दछ र आवश्यक परे रणनीति समायोजन गर्दछ
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']}")

यहाँ मुख्य कुरा एजेन्टको क्षमता हो:

• आफ्नो अघिल्ला छनोटहरू र निर्णय प्रक्रियाको मूल्याङ्कन गर्ने।
• प्रतिबिम्बको आधारमा रणनीति समायोजन गर्ने अर्थात् Metacognition कार्यान्वयन।

यो Metacognition को साधारण रूप हो जहाँ प्रणाली आन्तरिक प्रतिक्रिया आधारमा आफ्नो तर्क प्रक्रियामा सुधार गर्न सक्षम हुन्छ।

Metacognition एक शक्तिशाली उपकरण हो जसले AI एजेन्टहरूको क्षमता निकै सुधार गर्न सक्छ। Metacognitive प्रक्रियाहरू समावेश गरेर, तपाईं अझ बुद्धिमान, अनुकूलनीय, र कुशल एजेन्टहरू डिजाइन गर्न सक्नुहुन्छ। थप अन्वेषणका लागि थप स्रोतहरू प्रयोग गर्नुहोस् र AI एजेन्टहरूमा Metacognition को रमाइलो संसारमा डुबुल्की मार्नुहोस्।

Microsoft Foundry Discord मा सामेल हुनुहोस् जहाँ तपाईं अन्य सिक्नेहरूसँग भेट्न, अफिस आवरहरूमा सहभागी हुन, र AI एजेन्टहरू सम्बन्धी प्रश्नहरूको जवाफ पाउन सक्नुहुन्छ।

बहु-एजेन्ट डिजाइन ढाँचा

उत्पादनमा AI एजेन्टहरू

---

अस्वीकरण: यो दस्तावेज् AI अनुवाद सेवा Co-op Translator को प्रयोग गरी अनुवाद गरिएको हो। हामी शुद्धताको लागि प्रयासरत भए पनि, कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धिहरू हुन सक्छन्। मूल दस्तावेज् यसको स्वदेशी भाषामा अधिकृत स्रोत मानिनु पर्छ। महत्त्वपूर्ण जानकारीको लागि व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न कुनै पनि गलतफहमी वा गलत व्याख्याका लागि हामी जिम्मेवार छैनौं।