ai-agents-for-beginners

(I-click ang larawan sa itaas upang panoorin ang video ng araling ito)

Metacognition sa mga AI Agent

Panimula

Maligayang pagdating sa aralin tungkol sa metacognition sa mga AI agent! Ang kabanatang ito ay dinisenyo para sa mga baguhan na interesado kung paano maaaring pag-isipan ng mga AI agent ang kanilang sariling proseso ng pag-iisip. Sa pagtatapos ng araling ito, mauunawaan mo ang mga pangunahing konsepto at magkakaroon ka ng mga praktikal na halimbawa upang mailapat ang metacognition sa disenyo ng AI agent.

Mga Layunin sa Pag-aaral

Pagkatapos makumpleto ang araling ito, magagawa mong:

1. Maunawaan ang mga implikasyon ng mga reasoning loop sa mga depinisyon ng agent.
2. Gamitin ang mga pamamaraan ng pagpaplano at pagsusuri upang matulungan ang mga agent na kusang magwasto.
3. Lumikha ng sarili mong mga agent na kayang manipulahin ang code upang makamit ang mga gawain.

Panimula sa Metacognition

Ang metacognition ay tumutukoy sa mga proseso ng mataas na antas ng pag-iisip na kinasasangkutan ang pag-iisip tungkol sa sariling pag-iisip. Para sa mga AI agent, nangangahulugan ito ng kakayahang suriin at ayusin ang kanilang mga aksyon base sa kamalayan sa sarili at mga nakaraang karanasan. Ang metacognition, o “pag-iisip tungkol sa pag-iisip,” ay isang mahalagang konsepto sa pagbuo ng mga agentic AI system. Kasama rito ang pagiging kamalayan ng mga AI system sa kanilang sariling mga internal na proseso at ang kakayahang subaybayan, i-regulate, at iakma ang kanilang pag-uugali nang naaayon. Katulad ng ginagawa natin kapag binabasa natin ang paligid o tinitingnan ang isang problema. Ang kamalayan sa sarili ay maaaring makatulong sa mga AI system na gumawa ng mas magagandang desisyon, matukoy ang mga pagkakamali, at pagbutihin ang kanilang pagganap sa paglipas ng panahon – na muling nag-uugnay sa Turing test at ang debate kung sakop ba ng AI ang mundo.

Sa konteksto ng mga agentic AI system, makakatulong ang metacognition na tugunan ang ilang mga hamon, tulad ng:

• Transparency: Pagtiyak na ang mga AI system ay maaaring ipaliwanag ang kanilang pag-iisip at mga desisyon.
• Reasoning: Pinaigting ang kakayahan ng mga AI system na pagsamahin ang impormasyon at gumawa ng mga matibay na desisyon.
• Adaptation: Pagbibigay-daan sa mga AI system na makaangkop sa mga bagong kapaligiran at nagbabagong mga kondisyon.
• Perception: Pagpapahusay ng katumpakan ng mga AI system sa pagkilala at pag-interpret ng data mula sa kanilang kapaligiran.

Ano ang Metacognition?

Ang metacognition, o “pag-iisip tungkol sa pag-iisip,” ay isang mataas na antas ng proseso ng pag-iisip na kinasasangkutan ang kamalayan sa sarili at pag-regulate ng sariling mga proseso ng pag-iisip. Sa larangan ng AI, pinapagana ng metacognition ang mga agent na suriin at iakma ang kanilang mga estratehiya at aksyon, na nagreresulta sa pinahusay na kakayahan sa paglutas ng problema at paggawa ng desisyon. Sa pag-unawa sa metacognition, makakalikha ka ng mga AI agent na hindi lamang mas matalino kundi mas nakakaya ring mag-adapt at mas epektibo. Sa tunay na metacognition, makikita mong tahasan na pinag-iisipan ng AI ang sarili nitong pag-iisip.

Halimbawa: “Pinili ko ang mga mas murang flight dahil… maaaring may mga direct flight na naiiwan, kaya susuriin ko muli.”. Sinusubaybayan kung paano o bakit ito pumili ng isang partikular na ruta.

• Napapansin na nagkamali ito dahil masyadong nakaasa sa mga preference ng user noong nakaraang beses, kaya binabago nito ang estratehiya ng paggawa ng desisyon, hindi lamang ang huling rekomendasyon.
• Natutukoy ang mga pattern tulad ng, “Kapag nababanggit ng user ang ‘masikip masyado,’ hindi lang dapat tanggalin ang ilang atraksyon kundi dapat rin pag-isipan na mali ang paraan ko sa pagpili ng ‘mga nangungunang atraksyon’ kung palagi akong niraranggo base sa kasikatan.”

Kahalagahan ng Metacognition sa mga AI Agent

Mahalaga ang metacognition sa disenyo ng AI agent dahil sa ilang mga dahilan:

• Pagsusuri sa Sarili: Maaaring tasahin ng mga agent ang kanilang sariling pagganap at tukuyin ang mga lugar na dapat pagbutihin.
• Kakayahang Makibagay: Maaaring baguhin ng mga agent ang kanilang mga estratehiya batay sa mga nakaraang karanasan at nagbabagong kapaligiran.
• Pagsasaayos ng Pagkakamali: Maaaring tuklasin at itama ng mga agent ang mga error nang mag-isa, na nagreresulta sa mas tumpak na mga resulta.
• Pamamahala sa Mga Yaman: Maaaring i-optimize ng mga agent ang paggamit ng mga yaman, tulad ng oras at computational power, sa pamamagitan ng pagpaplano at pagsusuri ng kanilang mga gawain.

Mga Bahagi ng AI Agent

Bago sumabak sa mga metacognitive na proseso, mahalagang maunawaan ang mga pangunahing bahagi ng isang AI agent. Karaniwang binubuo ang isang AI agent ng:

• Persona: Ang personalidad at mga katangian ng agent, na nagtutukoy kung paano ito nakikipag-ugnayan sa mga user.
• Mga Kagamitan: Ang mga kakayahan at mga function na maaaring isagawa ng agent.
• Kasanayan: Ang kaalaman at kadalubhasaan na taglay ng agent.

Ang mga bahaging ito ay nagtutulungan upang makalikha ng isang “expertise unit” na kayang magsagawa ng mga tiyak na gawain.

Halimbawa: Isipin ang isang travel agent, serbisyong agent na hindi lamang nagpaplano ng iyong bakasyon kundi nag-aakma rin ng landas batay sa real-time data at mga nakaraang karanasang paglalakbay ng customer.

Halimbawa: Metacognition sa Serbisyo ng Travel Agent

Isipin na nagdidisenyo ka ng isang serbisyong travel agent na pinatatakbo ng AI. Ang agent na ito, “Travel Agent,” ay tumutulong sa mga user sa pagpaplano ng kanilang mga bakasyon. Upang maisama ang metacognition, kailangang suriin at baguhin ng Travel Agent ang mga aksyon nito batay sa kamalayan sa sarili at mga nakaraang karanasan. Ganito ang maaaring papel ng metacognition:

Kasalukuyang Gawain

Ang kasalukuyang gawain ay tumulong sa isang user na magplano ng isang paglalakbay sa Paris.

Mga Hakbang upang Makumpleto ang Gawain

1. Kolektahin ang Mga Preference ng User: Tanungin ang user tungkol sa mga petsa ng biyahe, badyet, interes (hal. mga museo, pagkain, pamimili), at anumang partikular na pangangailangan.
2. Kunin ang Impormasyon: Maghanap ng mga opsyon sa flight, tirahan, atraksyon, at mga restoran na tumutugma sa mga preference ng user.
3. Gumawa ng mga Rekomendasyon: Magbigay ng isang personalized na itineraryo na may mga detalye ng flight, reserbasyon sa hotel, at mga iminungkahing aktibidad.
4. Baguhin Batay sa Feedback: Tanungin ang user para sa feedback sa mga rekomendasyon at gumawa ng kinakailangang mga pag-aayos.

Kinakailangang Yaman

• Access sa mga flight at hotel booking databases.
• Impormasyon tungkol sa mga atraksyon at restaurante ng Paris.
• Data ng feedback ng user mula sa mga nakaraang interaksyon.

Karanasan at Pagsusuri sa Sarili

Ginagamit ng Travel Agent ang metacognition upang suriin ang pagganap nito at matuto mula sa mga nakaraang karanasan. Halimbawa:

1. Pagsusuri sa Feedback ng User: Sine-suri ng Travel Agent ang feedback ng user upang matukoy kung alin sa mga rekomendasyon ang tinanggap nang mabuti at alin ang hindi. Inaayos nito ang mga susunod na mungkahi base rito.
2. Kakayahang Makibagay: Kung nasabi na ng user na ayaw niya sa mga masikip na lugar, iiwasan ng Travel Agent ang pagrerekomenda ng mga sikat na tourist spot sa mga oras na matao sa susunod.
3. Pagsasaayos ng Pagkakamali: Kung nagkamali ang Travel Agent sa isang booking, tulad ng pagrekomenda ng isang hotel na puno na, natututo itong suriin nang mabuti ang availability bago magbigay ng rekomendasyon.

Praktikal na Halimbawa para sa Developer

Narito ang isang pinaikling halimbawa kung paano maaaring magmukhang ang code ng Travel Agent habang isinisingit ang metacognition:

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):
        # Maghanap ng mga flight, hotel, at atraksyon batay sa mga kagustuhan
        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)
        # Suriin ang mga puna at ayusin ang mga susunod na rekomendasyon
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Halimbawa ng paggamit
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)

Bakit Mahalaga ang Metacognition

• Pagsusuri sa Sarili: Maaaring suriin ng mga agent ang kanilang pagganap at tukuyin ang mga dapat pagbutihin.
• Kakayahang Makibagay: Maaaring baguhin ng mga agent ang mga estratehiya base sa feedback at nagbabagong kondisyon.
• Pagsasaayos ng Pagkakamali: Maaaring awtomatikong matuklasan at maitama ng mga agent ang mga maling ginagawa.
• Pamamahala sa Yaman: Maaaring i-optimize ng mga agent ang paggamit ng yaman, tulad ng oras at computational power.

Sa pamamagitan ng pagsasama ng metacognition, makakapagbigay ang Travel Agent ng mas personalisado at tumpak na mga rekomendasyon para sa paglalakbay, na nagpapabuti sa pangkalahatang karanasan ng user.

---

2. Pagpaplano sa mga Agent

Mahalaga ang pagpaplano bilang bahagi ng pag-uugali ng AI agent. Kabilang dito ang paggawa ng balangkas ng mga hakbang na kinakailangan upang makamit ang isang layunin, isinasaalang-alang ang kasalukuyang kalagayan, mga yaman, at mga posibleng hadlang.

Mga Elemento ng Pagpaplano

• Kasalukuyang Gawain: Linawin ang gawain.
• Mga Hakbang upang Makumpleto ang Gawain: Hatiin ang gawain sa mga madaling pamahalaang hakbang.
• Kinakailangang Yaman: Tukuyin ang mga kailangang yaman.
• Karanasan: Gamitin ang mga nakaraang karanasan upang gabayan ang pagpaplano.

Halimbawa: Narito ang mga hakbang na kailangang gawin ng Travel Agent upang epektibong matulungan ang isang user sa pagpaplano ng kanilang paglalakbay:

Mga Hakbang para sa Travel Agent

1. Kolektahin ang Mga Preference ng User
   • Tanungin ang user tungkol sa mga detalye ng petsa ng biyahe, badyet, interes, at anumang partikular na pangangailangan.
   • Halimbawa: “Kailan ka magbabalak maglakbay?” “Ano ang saklaw ng iyong badyet?” “Anong mga aktibidad ang gusto mo sa bakasyon?”
2. Kunin ang Impormasyon
   • Maghanap ng mga angkop na opsyon sa paglalakbay base sa mga preference ng user.
   • Flights: Maghanap ng mga available na flight sa loob ng badyet at mga gustong petsa ng user.
   • Tirahan: Humanap ng mga hotel o paupahang paglulugar na tumutugma sa lokasyon, presyo, at mga amenities na gustong-gusto ng user.
   • Mga Atraksyon at Restoran: Tukuyin ang mga sikat na atraksyon, aktibidad, at mga kainan na tumutugma sa interes ng user.
3. Gumawa ng mga Rekomendasyon
   • Isama ang nakuhang impormasyon sa isang personalisadong itineraryo.
   • Ibigay ang mga detalye tulad ng mga opsyon sa flight, reserbasyon sa hotel, at mga iminungkahing aktibidad, siguraduhing angkop ang mga rekomendasyon sa mga preference ng user.
4. Ipakita ang Itineraryo sa User
   • Ibahagi ang iminungkahing itineraryo para sa pagsusuri ng user.
   • Halimbawa: “Narito ang isang iminungkahing itineraryo para sa iyong biyahe sa Paris. Kasama dito ang mga detalye ng flight, booking ng hotel, at listahan ng mga inirerekomendang aktibidad at pagkain. Sabihin mo lang kung ano ang iniisip mo!”
5. Kolektahin ang Feedback
   • Tanungin ang user para sa feedback tungkol sa iminungkahing itineraryo.
   • Halimbawa: “Nagustuhan mo ba ang mga opsyon sa flight?” “Angkop ba ang hotel para sa iyong pangangailangan?” “May mga aktibidad ka bang gustong idagdag o tanggalin?”
6. Baguhin Batay sa Feedback
   • Isagawa ang mga pagbabago sa itineraryo base sa feedback ng user.
   • Gawin ang mga kinakailangang pagbabago sa flight, tirahan, at rekomendasyon ng aktibidad upang mas umangkop sa preference ng user.
7. Panghuling Kumpirmasyon
   • Ipakita ang na-update na itineraryo sa user para sa panghuling kumpirmasyon.
   • Halimbawa: “Ginawa ko na ang mga pagbabago batay sa iyong feedback. Narito ang updated itineraryo. Ayos ba ito sa iyo?”
8. Mag-book at Kumpirmahin ang mga Reserbasyon
   • Kapag inaprubahan ng user ang itineraryo, ituloy ang pag-book ng flight, tirahan, at anumang pre-planned activity.
   • Ipadala ang mga detalye ng kumpirmasyon sa user.
9. Magbigay ng Patuloy na Suporta
   • Maging available upang tulungan ang user sa anumang pagbabago o dagdag na hiling bago at habang naglalakbay.
   • Halimbawa: “Kung kailangan mo pa ng tulong habang naglalakbay, huwag mag-atubiling kontakin ako anumang oras!”

Halimbawa ng Interaksyon

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)

# Halimbawang gamit sa loob ng isang humihiyaw na kahilingan
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. Corrective RAG System

Magsimula tayo sa pag-unawa ng pagkakaiba ng RAG Tool at Pre-emptive Context Load

Retrieval-Augmented Generation (RAG)

Pinagsasama ng RAG ang isang retrieval system at generative model. Kapag may query, kinukuha ng retrieval system ang mga kaugnay na dokumento o data mula sa panlabas na pinagmulan, at ginagamit ang impormasyong ito upang dagdagan ang input ng generative model. Nakakatulong ito sa modelong makabuo ng mas tumpak at kontekstwal na mga sagot.

Sa isang RAG system, kinukuha ng agent ang kaugnay na impormasyon mula sa isang knowledge base at ginagamit ito upang makabuo ng angkop na tugon o aksyon.

Tamang-tama (Corrective) na Pamamaraan ng RAG

Nakatuon ang Tamang-tama na pamamaraan ng RAG sa paggamit ng mga teknik ng RAG upang itama ang mga pagkakamali at mapabuti ang katumpakan ng mga AI agent. Kabilang dito ang:

1. Prompting Technique: Paggamit ng mga tiyak na prompt upang gabayan ang agent sa pagkuha ng kaugnay na impormasyon.
2. Tool: Pagpapatupad ng mga algorithm at mekanismo na nagpapahintulot sa agent na tasahin ang kaugnayan ng nakuha na impormasyon at makabuo ng tumpak na sagot.
3. Pagsusuri: Patuloy na pagtaya sa pagganap ng agent at paggawa ng mga pagsasaayos upang mapabuti ang katumpakan at kahusayan nito.

Halimbawa: Tamang-tama (Corrective) na RAG sa isang Search Agent

Isang search agent na naghahanap ng impormasyon mula sa web upang sagutin ang mga query ng user. Maaring kabilang sa Tamang-tama na pamamaraan ng RAG ang:

1. Prompting Technique: Pagsasaayos ng mga query sa paghahanap base sa input ng user.
2. Tool: Paggamit ng natural language processing at machine learning algorithm upang i-ranggo at i-filter ang mga resulta ng paghahanap.
3. Pagsusuri: Pagsusuri ng feedback ng user upang tuklasin at itama ang mga kamalian sa nakuhang impormasyon.

Tamang-tama na RAG sa Travel Agent

Pinapalakas ng Tamang-tama na RAG (Retrieval-Augmented Generation) ang kakayahan ng AI na kumuha at makabuo ng impormasyon habang itinatama ang mga posibleng kamalian. Tingnan natin kung paano magagamit ng Travel Agent ang pamamaraan ng Tamang-tama na RAG upang makapagbigay ng mas tumpak at kaugnay na mga rekomendasyon sa paglalakbay.

Kasama dito ang:

• Prompting Technique: Paggamit ng mga tiyak na prompt upang gabayan ang agent sa pagkuha ng kaugnay na impormasyon.
• Tool: Pagpapatupad ng mga algorithm at mekanismo na nagpapahintulot sa agent na tasahin ang kaugnayan ng nakuha na impormasyon at makabuo ng tumpak na sagot.
• Pagsusuri: Patuloy na pagtaya sa pagganap ng agent at paggawa ng mga pagsasaayos upang mapabuti ang katumpakan at kahusayan nito.

Mga Hakbang sa Pagsasagawa ng Tamang-tama na RAG sa Travel Agent

1. Paunang Pakikipag-ugnayan sa User
   • Kinokolekta ng Travel Agent ang mga paunang preference mula sa user, tulad ng destinasyon, petsa ng paglalakbay, badyet, at interes.

   • Halimbawa:

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

2. Pagkuha ng Impormasyon
   • Kinukuha ng Travel Agent ang impormasyon tungkol sa flight, tirahan, atraksyon, at mga restaurant batay sa mga preference ng user.

   • Halimbawa:

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

3. Pagbuo ng Paunang Mga Rekomendasyon
   • Ginagamit ng Travel Agent ang nakuhang impormasyon upang bumuo ng isang personalisadong itineraryo.

   • Halimbawa:

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

4. Pagkolekta ng Feedback ng User
   • Tinanong ng Travel Agent ang user tungkol sa mga paunang rekomendasyon.

   • Halimbawa:

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

5. Proseso ng Tamang-tama na RAG
   • Prompting Technique: Gumagawa ng mga bagong query sa paghahanap ang Travel Agent batay sa feedback ng user.

     • Halimbawa:

       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       

   • Tool: Gumagamit ang Travel Agent ng mga algorithm upang i-ranggo at i-filter ang mga bagong resulta ng paghahanap, na binibigyang-diin ang kaugnayan batay sa feedback ng user.

     • Halimbawa:

       new_attractions = search_attractions(preferences)
       new_itinerary = create_itinerary(flights, hotels, new_attractions)
       print("Updated Itinerary:", new_itinerary)
       

   • Pagsusuri: Patuloy na tinatasa ng Travel Agent ang kaugnayan at katumpakan ng mga rekomendasyon nito sa pamamagitan ng pagsusuri sa feedback ng user at paggawa ng mga kinakailangang pagsasaayos.

     • Halimbawa:

       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)
       

Praktikal na Halimbawa

Narito ang isang pinaikling halimbawa ng Python code na nagsasama ng pamamaraan ng Tamang-tama na RAG sa Travel Agent:

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

# Halimbawa ng paggamit
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

Pre-emptive Context Load

Ang Pre-emptive Context Load ay kinabibilangan ng pag-load ng kaugnay na konteksto o impormasyong panloob sa modelo bago iproseso ang isang query. Ibig sabihin nito ay may access ang modelo sa impormasyong ito mula pa sa simula, na makakatulong upang makabuo ito ng mas may kaalamang mga sagot nang hindi na kailangang kumuha ng karagdagang datos habang nagpapatuloy ang proseso.

Narito ang isang pinasimpleng halimbawa kung paano maaaring magmukhang ganito ang pre-emptive context load para sa isang travel agent application sa Python:

class TravelAgent:
    def __init__(self):
        # I-load nang maaga ang mga sikat na destinasyon at ang kanilang impormasyon
        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):
        # Kunin ang impormasyon ng destinasyon mula sa naunang na-load na konteksto
        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}."

# Halimbawa ng paggamit
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Paliwanag

1. Inisyal na Paglikha (__init__ method): Ang klase na TravelAgent ay unang naglo-load ng isang diksyunaryo na naglalaman ng impormasyon tungkol sa mga sikat na destinasyon tulad ng Paris, Tokyo, New York, at Sydney. Kasama sa diksyunaryong ito ang mga detalye gaya ng bansa, pera, wika, at mga pangunahing atraksyon sa bawat destinasyon.

2. Pagkuha ng Impormasyon (get_destination_info method): Kapag nagtatanong ang user tungkol sa isang tiyak na destinasyon, kinukuha ng get_destination_info method ang kaugnay na impormasyon mula sa pre-loaded na diksyunaryo ng konteksto.

Sa pamamagitan ng pag-pre-load ng konteksto, mabilis na nakakasagot ang travel agent application sa mga tanong ng user nang hindi na kailangang kumuha ng impormasyon mula sa ibang pinagmulan ng real-time. Ginagawa nitong mas epektibo at responsive ang aplikasyon.

Pag-bootstrapping ng Plano gamit ang Layunin Bago Mag-Iterate

Ang pag-bootstrapping ng plano gamit ang layunin ay kinabibilangan ng pagsisimula sa isang malinaw na layunin o target na resulta. Sa pamamagitan ng pagtukoy ng layuning ito agad, maaaring gamitin ito ng modelo bilang gabay sa buong proseso ng pag-uulit. Nakakatulong ito upang matiyak na ang bawat iteration ay umuusad nang mas malapit upang makamit ang ninanais na resulta, kaya mas epektibo at tutok ang proseso.

Narito ang halimbawa kung paano mo maaaring i-bootstrap ang isang plano sa paglalakbay gamit ang layunin bago mag-iterate para sa isang travel agent gamit ang Python:

Senaryo

Nais ng isang travel agent na magplano ng customized na bakasyon para sa kliyente. Ang layunin ay lumikha ng isang itinerary ng paglalakbay na nagpapataas ng kasiyahan ng kliyente base sa kanilang mga gusto at budget.

Mga Hakbang

1. Tukuyin ang mga gusto at budget ng kliyente.
2. I-bootstrap ang paunang plano base sa mga gustong ito.
3. Mag-iterate upang pinuhin ang plano, na para-optimize ang kasiyahan ng kliyente.

Python Code

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']

# Halimbawa ng paggamit
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)

Paliwanag ng Code

1. Inisyal na Paglikha (__init__ method): Ang klase na TravelAgent ay ini-inisyalisa gamit ang listahan ng mga potensyal na destinasyon, bawat isa ay may mga katangian tulad ng pangalan, gastos, at uri ng aktibidad.

2. Pag-bootstrapping ng Plano (bootstrap_plan method): Gumagawa ang method na ito ng paunang plano ng paglalakbay base sa mga gusto at budget ng kliyente. Nag-iiterate ito sa listahan ng mga destinasyon at idinadagdag ang mga ito sa plano kung tugma sila sa mga gusto ng kliyente at pasok sa budget.

3. Pagtutugma ng Mga Gusto (match_preferences method): Sinusuri ng method na ito kung ang isang destinasyon ay tugma sa mga gusto ng kliyente.

4. Pag-uulit ng Plano (iterate_plan method): Pinapahusay nito ang paunang plano sa pamamagitan ng pagsubok na palitan ang bawat destinasyon sa plano ng mas angkop na tugma, isinasaalang-alang ang mga gusto at limitasyon sa budget ng kliyente.

5. Pagkalkula ng Gastos (calculate_cost method): Kinakalkula ng method na ito ang kabuuang gastos ng kasalukuyang plano, kasama ang posibleng bagong destinasyon.

Halimbawa ng Paggamit

• Paunang Plano: Gumagawa ang travel agent ng paunang plano base sa mga gusto ng kliyente para sa sightseeing at budget na $2000.
• Pinahusay na Plano: Ini-iterate ng travel agent ang plano upang i-optimize ayon sa mga gusto at budget ng kliyente.

Sa pamamagitan ng pag-bootstrapping ng plano gamit ang malinaw na layunin (hal., pagpapataas ng kasiyahan ng kliyente) at pag-uulit para pinuhin ito, makakalikha ang travel agent ng isang customized at optimized na itinerary ng paglalakbay para sa kliyente. Tinitiyak ng diskarteng ito na ang plano sa paglalakbay ay naka-align sa mga gusto at budget ng kliyente mula pa sa simula at pinapabuti sa bawat iteration.

Paggamit ng LLM para sa Re-ranking at Scoring

Maaaring gamitin ang Large Language Models (LLMs) para sa re-ranking at scoring sa pamamagitan ng pagtatasa ng kaugnayan at kalidad ng mga nakuhang dokumento o nilikhang sagot. Ganito ang proseso:

Retrieval: Sa unang hakbang, kumukuha ng set ng mga kandidato ng dokumento o sagot base sa query.

Re-ranking: Sinusuri ng LLM ang mga kandidato at inaayos muli ang kanilang ranggo base sa kaugnayan at kalidad. Pinapahusay nito na ang pinaka-kaugnay at mataas na kalidad na impormasyon ang unang ipapakita.

Scoring: Nagbibigay ang LLM ng mga iskor sa bawat kandidato bilang tanda ng kaugnayan at kalidad. Nakakatulong ito sa pagpili ng pinakamahusay na sagot o dokumento para sa user.

Sa pamamagitan ng paggamit ng LLM para sa re-ranking at scoring, maaaring magbigay ang sistema ng mas tumpak at kontekstwal na kaugnay na impormasyon, na nagpapabuti sa kabuuang karanasan ng user.

Narito ang halimbawa kung paano maaaring gamitin ng isang travel agent ang isang Large Language Model (LLM) para sa re-ranking at scoring ng mga destinasyon ng paglalakbay base sa mga gusto ng user gamit ang Python:

Senaryo - Paglalakbay Batay sa Mga Gusto

Nais ng travel agent na irekomenda ang pinakamahusay na mga destinasyon sa paglalakbay sa isang kliyente base sa kanilang mga gusto. Tutulungan ng LLM na i-re-rank at i-score ang mga destinasyon upang matiyak na ang pinaka-kaugnay na mga opsyon ang ipapakita.

Mga Hakbang:

1. Kolektahin ang mga gusto ng user.
2. Kumuha ng listahan ng mga potensyal na destinasyon ng paglalakbay.
3. Gamitin ang LLM para i-re-rank at i-score ang mga destinasyon base sa mga gusto ng user.

Narito kung paano mo mae-update ang naunang halimbawa gamit ang Azure OpenAI Services:

Mga Kinakailangan

1. Kailangan mong magkaroon ng Azure subscription.
2. Gumawa ng Azure OpenAI resource at kunin ang iyong API key.

Halimbawa ng Python Code

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Gumawa ng prompt para sa Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Tukuyin ang mga header at payload para sa kahilingan
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Tawagin ang Azure OpenAI API upang makuha ang muling nasusuri at may iskor na mga destinasyon
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Kunin at ibalik ang mga rekomendasyon
        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

# Halimbawa ng paggamit
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)

Paliwanag ng Code - Preference Booker

1. Inisyal na Paglikha: Inisyalisa ang klase na TravelAgent gamit ang listahan ng mga potensyal na destinasyon ng paglalakbay, bawat isa ay may mga katangiang tulad ng pangalan at paglalarawan.

2. Pagkuha ng Mga Rekomendasyon (get_recommendations method): Gumagawa ang method na ito ng prompt para sa Azure OpenAI service base sa mga gusto ng user at nagsasagawa ng HTTP POST request sa Azure OpenAI API upang makuha ang mga na-re-rank at na-score na destinasyon.

3. Pagbuo ng Prompt (generate_prompt method): Gumagawa ang method na ito ng prompt para sa Azure OpenAI, kabilang ang mga gusto ng user at listahan ng mga destinasyon. Ginatitiyak ng prompt na i-re-rank at i-score ng modelo ang mga destinasyon base sa ibinigay na mga gusto.

4. API Call: Ginagamit ang requests library para magsagawa ng HTTP POST request sa Azure OpenAI API endpoint. Nasa tugon ang mga na-re-rank at na-score na destinasyon.

5. Halimbawa ng Paggamit: Kinokolekta ng travel agent ang mga gusto ng user (hal., interes sa sightseeing at sari-saring kultura) at ginagamit ang Azure OpenAI service para makuha ang mga na-re-rank at na-score na rekomendasyon para sa mga destinasyon ng paglalakbay.

Siguraduhing palitan ang your_azure_openai_api_key ng iyong totoong Azure OpenAI API key at ang https://your-endpoint.com/... ng totoong URL ng endpoint ng iyong Azure OpenAI deployment.

Sa pamamagitan ng paggamit ng LLM para sa re-ranking at scoring, makapagbibigay ang travel agent ng mas personalisado at kaugnay na mga rekomendasyon sa paglalakbay sa mga kliyente, na nagpapahusay sa kanilang pangkalahatang karanasan.

RAG: Pamamaraan ng Prompting kumpara sa Tool

Ang Retrieval-Augmented Generation (RAG) ay maaaring maging parehong isang pamamaraan ng prompting at isang tool sa pagbuo ng mga AI agent. Ang pag-unawa sa pagkakaiba ng dalawa ay makatutulong upang mas mahusay mong magamit ang RAG sa iyong mga proyekto.

RAG bilang Pamamaraan ng Prompting

Ano ito?

• Bilang pamamaraan ng prompting, kinabibilangan ang RAG ng pagbuo ng mga tiyak na query o prompt upang gabayan ang pagkuha ng kaugnay na impormasyon mula sa malaking corpus o database. Ginagamit ang impormasyong ito upang bumuo ng mga sagot o aksyon.

Paano ito gumagana:

1. Pagbuo ng Mga Prompt: Gumawa ng maayos na estrukturadong mga prompt o query base sa gawain o input ng user.
2. Pagkuha ng Impormasyon: Gamitin ang mga prompt upang maghanap ng kaugnay na datos mula sa pre-existing na knowledge base o dataset.
3. Pagbuo ng Sagot: Pagsamahin ang nakuha na impormasyon sa mga generative AI model upang makabuo ng komprehensibo at magkakaugnay na sagot.

Halimbawa sa Travel Agent:

• Input ng User: “Gusto kong bumisita sa mga museo sa Paris.”
• Prompt: “Hanapin ang mga nangungunang museo sa Paris.”
• Nakuha na Impormasyon: Mga detalye tungkol sa Louvre Museum, Musée d’Orsay, atbp.
• Nalikhang Sagot: “Narito ang ilang nangungunang museo sa Paris: Louvre Museum, Musée d’Orsay, at Centre Pompidou.”

RAG bilang Tool

Ano ito?

• Bilang tool, ang RAG ay isang integrated na sistema na awtomatikong pinangangasiwaan ang proseso ng retrieval at generation, na nagpapadali para sa mga developer na ipatupad ang mga kumplikadong AI functionality nang hindi kailangang mano-manong lumikha ng mga prompt para sa bawat query.

Paano ito gumagana:

1. Integrasyon: I-embed ang RAG sa arkitektura ng AI agent, na nagpapahintulot dito na awtomatikong pamahalaan ang mga gawain ng retrieval at generation.
2. Awtomasyon: Pinangangasiwaan ng tool ang buong proseso, mula pagtanggap ng input ng user hanggang sa pagbuo ng panghuling sagot, nang hindi nangangailangan ng tahasang mga prompt para sa bawat hakbang.
3. Kahusayan: Pinapalakas ang performance ng agent sa pamamagitan ng pagpapadali sa proseso ng retrieval at generation, na nagbibigay-daan sa mas mabilis at mas tumpak na mga sagot.

Halimbawa sa Travel Agent:

• Input ng User: “Gusto kong bumisita sa mga museo sa Paris.”
• Tool ng RAG: Awtomatikong kinukuha ang impormasyon tungkol sa mga museo at bumubuo ng sagot.
• Nalikhang Sagot: “Narito ang ilang nangungunang museo sa Paris: Louvre Museum, Musée d’Orsay, at Centre Pompidou.”

Paghahambing

Aspeto	Pamamaraan ng Prompting	Tool
Manwal kumpara sa Awtomatik	Manwal na pagbuo ng mga prompt para sa bawat query.	Awtomatikong proseso para sa retrieval at generation.
Kontrol	Nagbibigay ng mas maraming kontrol sa proseso ng retrieval.	Pinadadali at ina-awtomatiko ang retrieval at generation.
Kalayaan	Pinapayagan ang mga custom na prompt base sa tiyak na pangangailangan.	Mas epektibo para sa malakihang mga implementasyon.
Kompleksidad	Nangangailangan ng pagbuo at pagsasaayos ng mga prompt.	Mas madaling i-integrate sa arkitektura ng AI agent.

Mga Praktikal na Halimbawa

Halimbawa ng Pamamaraan ng Prompting:

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)

Halimbawa ng Tool:

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)

Pagsusuri ng Kaugnayan

Ang pagsusuri ng kaugnayan ay isang mahalagang aspeto ng performance ng AI agent. Tinitiyak nito na ang impormasyong nakukuha at nalilikha ng agent ay angkop, tama, at kapaki-pakinabang sa user. Tingnan natin kung paano magsagawa ng pagsusuri ng kaugnayan sa mga AI agent, kabilang ang mga praktikal na halimbawa at pamamaraan.

Mga Pangunahing Konsepto sa Pagsusuri ng Kaugnayan

1. Pagkaalam sa Konteksto:
   • Kailangang maunawaan ng agent ang konteksto ng query ng user para makakuha at makabuo ng may kaugnayang impormasyon.
   • Halimbawa: Kung nagtatanong ang user ng “pinakamagandang mga restoran sa Paris,” dapat isaalang-alang ng agent ang mga gusto ng user, tulad ng uri ng pagkain at budget.
2. Tumpak na Impormasyon:
   • Dapat tama at napapanahon ang impormasyong ibinibigay ng agent.
   • Halimbawa: Inirerekomenda ang mga bukas na restoran na may magagandang review kaysa sa mga lumang o saradong opsyon.
3. Intensiyon ng User:
   • Dapat mahinuha ng agent ang intensiyon ng user sa likod ng query upang magbigay ng pinaka-kaugnay na impormasyon.
   • Halimbawa: Kung nagtatanong ang user ng “mga hotel na abot-kaya,” dapat unahin ng agent ang mga murang opsyon.
4. Feedback Loop:
   • Patuloy na pagkolekta at pagsusuri ng feedback ng user ay nakatutulong upang pinuhin ng agent ang proseso ng pagsusuri ng kaugnayan.
   • Halimbawa: Pagsasama ng user ratings at feedback mula sa mga naunang rekomendasyon upang mapabuti ang mga susunod na sagot.

Mga Praktikal na Paraan sa Pagsusuri ng Kaugnayan

1. Pag-iskor ng Kaugnayan:
   • Magbigay ng relevance score sa bawat nakuhang item base sa tugma nito sa query at gusto ng user.

   • Halimbawa:

     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. Pag-filter at Pag-ranggo:
   • I-filter ang mga hindi kaugnay na item at i-ranggo ang natitirang mga item base sa kanilang relevance scores.

   • Halimbawa:

     def filter_and_rank(items, query):
         ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
         return ranked_items[:10]  # Ibalik ang nangungunang 10 kaugnay na mga item
     

3. Natural Language Processing (NLP):
   • Gamitin ang NLP techniques para maunawaan ang query ng user at makakuha ng may kaugnayang impormasyon.

   • Halimbawa:

     def process_query(query):
         # Gamitin ang NLP upang kunin ang mga pangunahing impormasyon mula sa query ng user
         processed_query = nlp(query)
         return processed_query
     

4. Integration ng Feedback ng User:
   • Kolektahin ang feedback ng user sa ibinigay na rekomendasyon at gamitin ito upang baguhin ang susunod na pagsusuri ng kaugnayan.

   • Halimbawa:

     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
     

Halimbawa: Pagsusuri ng Kaugnayan sa Travel Agent

Narito ang praktikal na halimbawa kung paano maaaring suriin ng Travel Agent ang kaugnayan ng mga rekomendasyon sa paglalakbay:

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]  # Ibalik ang nangungunang 10 kaugnay na mga item

    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

# Halimbawa ng paggamit
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)

Paghahanap na may Intensiyon

Ang paghahanap na may intensiyon ay kinabibilangan ng pag-unawa at interpretasyon sa pangunahing layunin o target sa likod ng query ng user upang makakuha at makabuo ng pinaka-kaugnay at kapaki-pakinabang na impormasyon. Lampas ito sa simpleng pagtugma ng mga keyword at nakatuon sa pagkuha ng tunay na pangangailangan at konteksto ng user.

Mga Pangunahing Konsepto sa Paghahanap na may Intensiyon

1. Pag-unawa sa Intensiyon ng User:
   • Maaaring ikategorya ang intensiyon ng user sa tatlong pangunahing uri: informational, navigational, at transactional.
     • Informational Intent: Naghahanap ang user ng impormasyon tungkol sa isang paksa (hal., “Ano ang mga pinakamagandang museo sa Paris?”).
     • Navigational Intent: Nais ng user na pumunta sa isang tiyak na website o pahina (hal., “Opisyal na website ng Louvre Museum”).
     • Transactional Intent: Nais ng user na magsagawa ng transaksyon, tulad ng pag-book ng flight o pagbili (hal., “Mag-book ng flight papuntang Paris”).
2. Pagkaalam sa Konteksto:
   • Ang pagsusuri sa konteksto ng query ng user ay nakatutulong upang tumpak na matukoy ang intensiyon nito. Kasama rito ang pag-isip sa mga naunang pakikipag-ugnayan, mga gusto ng user, at mga detalye ng kasalukuyang query.
3. Natural Language Processing (NLP):
   • Ginagamit ang NLP techniques upang maunawaan at ma-interpret ang mga natural na wikang query na ibinibigay ng mga user. Kasama rito ang mga gawain tulad ng entity recognition, sentiment analysis, at query parsing.
4. Personalization:
   • Ang pagpapersonalisa ng mga resulta ng paghahanap base sa kasaysayan, mga gusto, at feedback ng user ay nagpapahusay sa kaugnayan ng impormasyong nakukuha.

Praktikal na Halimbawa: Paghahanap na may Intensiyon sa Travel Agent

Tingnan natin ang Travel Agent bilang halimbawa kung paano maisasagawa ang paghahanap na may intensiyon.

1. Pagkolekta ng Mga Gusto ng User

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

2. Pag-unawa sa Intensiyon ng User

   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. Pagkaalam sa Konteksto

   def analyze_context(query, user_history):
       # Pagsamahin ang kasalukuyang query sa kasaysayan ng user upang maunawaan ang konteksto
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   

4. Maghanap at I-personalize ang mga Resulta

   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):
       # Halimbawang lohika ng paghahanap para sa impormatibong intensyon
       results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
       return results
   
   def search_navigation(query):
       # Halimbawang lohika ng paghahanap para sa navigasyonal na intensyon
       results = search_web(query)
       return results
   
   def search_transaction(query, preferences):
       # Halimbawang lohika ng paghahanap para sa transaksiyonal na intensyon
       results = search_web(f"book {query} to {preferences['destination']}")
       return results
   
   def personalize_results(results, user_history):
       # Halimbawang lohika ng personalisasyon
       personalized = [result for result in results if result not in user_history]
       return personalized[:10]  # Ibalik ang nangungunang 10 personalisadong resulta
   

5. Halimbawa ng Paggamit

   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. Paggawa ng Code bilang Isang Kasangkapan

Ang mga code generating agents ay gumagamit ng mga AI model para sumulat at magpatupad ng code, nalulutas ang mga komplikadong problema at nag-aautomat ng mga gawain.

Mga Code Generating Agents

Gumagamit ang mga code generating agents ng generative AI models upang sumulat at magpatupad ng code. Ang mga agent na ito ay maaaring maglutas ng mga komplikadong problema, mag-automat ng mga gawain, at magbigay ng mahahalagang pananaw sa pamamagitan ng paggawa at pagpapatakbo ng code sa iba’t ibang mga programming language.

Mga Praktikal na Aplikasyon

1. Automated Code Generation: Gumawa ng mga code snippet para sa mga tiyak na gawain, tulad ng data analysis, web scraping, o machine learning.
2. SQL bilang RAG: Gumamit ng mga SQL query para kunin at manipulahin ang data mula sa mga database.
3. Paglutas ng Problema: Lumikha at magpatupad ng code upang lutasin ang mga tiyak na problema, tulad ng pag-optimize ng mga algorithm o pagsusuri ng data.

Halimbawa: Code Generating Agent para sa Data Analysis

Isipin na kayo ay nagdidisenyo ng isang code generating agent. Ganito ang maaaring gawin nito:

1. Gawain: Suriin ang isang dataset upang tuklasin ang mga uso at pattern.
2. Mga Hakbang:
   • I-load ang dataset sa isang data analysis tool.
   • Gumawa ng mga SQL query para i-filter at i-aggregate ang data.
   • Ipatupad ang mga query at kunin ang mga resulta.
   • Gamitin ang mga resulta para gumawa ng mga visualization at pananaw.
3. Kailangang Resources: Access sa dataset, mga data analysis tool, at mga kakayahan sa SQL.
4. Karanasan: Gamitin ang mga nakaraang resulta ng pagsusuri para mapabuti ang katumpakan at kaugnayan ng mga susunod na pagsusuri.

Halimbawa: Code Generating Agent para sa Travel Agent

Sa halimbawang ito, gagawa tayo ng isang code generating agent, Travel Agent, upang tulungan ang mga gumagamit sa pagpaplano ng kanilang paglalakbay sa pamamagitan ng paggawa at pagpapatupad ng code. Kaya nitong hawakan ang mga gawain tulad ng paghahanap ng mga opsyon sa paglalakbay, pag-filter ng mga resulta, at pagbuo ng itinerary gamit ang generative AI.

Pangkalahatang Ideya ng Code Generating Agent

1. Pagkuha ng mga Kagustuhan ng Gumagamit: Kinokolekta ang mga input mula sa gumagamit tulad ng destinasyon, mga petsa ng paglalakbay, budget, at interes.
2. Pagbuo ng Code para Kunin ang Data: Gumagawa ng mga code snippet para kumuha ng data tungkol sa mga flight, hotel, at atraksyon.
3. Pagpapatupad ng Nabuo na Code: Pinapatakbo ang nabuo na code upang kunin ang mga real-time na impormasyon.
4. Pagbuo ng Itinerary: Tinutipon ang mga nakuha na data sa isang personalisadong plano sa paglalakbay.
5. Pag-aayos Batay sa Feedback: Tumatanggap ng feedback mula sa gumagamit at nire-regenerate ang code kung kinakailangan para mapaganda ang mga resulta.

Hakbang-hakbang na Implementasyon

1. Pagkuha ng mga Kagustuhan ng Gumagamit

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

2. Pagbuo ng Code para Kunin ang Data

   def generate_code_to_fetch_data(preferences):
       # Halimbawa: Gumawa ng code upang maghanap ng mga flight base sa mga kagustuhan ng gumagamit
       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):
       # Halimbawa: Gumawa ng code upang maghanap ng mga hotel
       code = f"""
       def search_hotels():
           import requests
           response = requests.get('https://api.example.com/hotels', params={preferences})
           return response.json()
       """
       return code
   

3. Pagpapatupad ng Nabuo na Code

   def execute_code(code):
       # Patakbuhin ang nabuo na code gamit ang 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. Pagbuo ng Itinerary

   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. Pag-aayos Batay sa Feedback

   def adjust_based_on_feedback(feedback, preferences):
       # Ayusin ang mga kagustuhan batay sa puna ng gumagamit
       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)
      
   # Muling likhain at patakbuhin ang code gamit ang na-update na mga kagustuhan
   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)
   

Paggamit ng environmental awareness at reasoning

Ang pagkakaalam sa schema ng table ay makatutulong sa proseso ng paggawa ng query sa pamamagitan ng paggamit ng environmental awareness at reasoning.

Narito ang isang halimbawa kung paano ito magagawa:

1. Pag-unawa sa Schema: Mauunawaan ng sistema ang schema ng table at gagamitin ang impormasyong ito bilang basehan sa paggawa ng query.
2. Pag-aayos Batay sa Feedback: Ia-adjust ng sistema ang mga kagustuhan ng gumagamit base sa feedback at magrereason kung aling mga field sa schema ang kailangang i-update.
3. Pagbuo at Pagpapatupad ng mga Query: Bubuo at magpapatupad ang sistema ng mga query upang kunin ang updated na flight at hotel data base sa mga bagong kagustuhan.

Narito ang isang updated na halimbawa ng Python code na nagpapaloob ng mga konseptong ito:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Ayusin ang mga kagustuhan base sa feedback ng user
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Pangangatwiran base sa iskema upang ayusin ang iba pang kaugnay na mga kagustuhan
    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):
    # Pasadyang lohika upang ayusin ang mga kagustuhan base sa iskema at feedback
    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):
    # Bumuo ng code upang kumuha ng datos ng flight base sa na-update na mga kagustuhan
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Bumuo ng code upang kumuha ng datos ng hotel base sa na-update na mga kagustuhan
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # I-simulate ang pagpapatupad ng code at magbalik ng huwad na datos
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Bumuo ng itineraryo base sa mga flight, hotel, at atraksyon
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Halimbawang iskema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Halimbawang paggamit
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Muling bumuo at isagawa ang code gamit ang na-update na mga kagustuhan
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)

Paliwanag - Pag-book base sa Feedback

1. Schema Awareness: Ang schema dictionary ay naglalarawan kung paano dapat i-adjust ang mga kagustuhan base sa feedback. May mga field ito tulad ng favorites at avoid, na may mga kaukulang adjustment.
2. Pag-aayos ng mga Preferences (adjust_based_on_feedback method): Ina-adjust ng method na ito ang mga kagustuhan base sa feedback ng gumagamit at schema.
3. Environment-Based Adjustments (adjust_based_on_environment method): Inaangkop ng method na ito ang mga adjustment base sa schema at feedback.
4. Pagbuo at Pagpapatupad ng mga Query: Ang sistema ay bumubuo ng code upang kunin ang updated na flight at hotel data base sa na-adjust na mga preference at isinasagawa ang mga query na ito sa simulated na paraan.
5. Pagbuo ng Itinerary: Gumagawa ang sistema ng updated na itinerary base sa bagong flight, hotel, at attraction data.

Sa pamamagitan ng paggawa ng sistema na may environmental awareness at reasoning base sa schema, makakagawa ito ng mas tumpak at kaugnay na mga query, na magreresulta sa mas magagandang rekomendasyon sa paglalakbay at mas personalisadong karanasan ng gumagamit.

Paggamit ng SQL bilang Retrieval-Augmented Generation (RAG) Technique

Ang SQL (Structured Query Language) ay isang makapangyarihang kasangkapan para sa pakikipag-ugnayan sa mga database. Kapag ginamit bilang bahagi ng Retrieval-Augmented Generation (RAG) approach, maaaring kumuha ang SQL ng mga kaugnay na datos mula sa mga database upang magbigay ng impormasyon at gumawa ng mga tugon o aksyon sa mga AI agent. Tingnan natin kung paano magagamit ang SQL bilang RAG technique sa konteksto ng Travel Agent.

Mga Pangunahing Konsepto

1. Pakikipag-ugnayan sa Database:
   • Ginagamit ang SQL para mag-query ng mga database, kumuha ng kaugnay na impormasyon, at manipulahin ang data.
   • Halimbawa: Pagkuha ng mga detalye ng flight, impormasyon ng hotel, at mga atraksyon mula sa travel database.
2. Integrasyon sa RAG:
   • Ang mga SQL query ay nililikha base sa input at kagustuhan ng gumagamit.
   • Ang nakuhang data ay ginagamit upang gumawa ng personalisadong rekomendasyon o aksyon.
3. Dynamic na Paggawa ng Query:
   • Ang AI agent ay gumagawa ng dynamic na SQL query base sa konteksto at pangangailangan ng gumagamit.
   • Halimbawa: Pag-customize ng SQL query upang i-filter ang mga resulta base sa budget, petsa, at interes.

Mga Aplikasyon

• Automated Code Generation: Gumawa ng mga code snippet para sa mga tiyak na gawain.
• SQL bilang RAG: Gumamit ng mga SQL query upang manipulahin ang data.
• Paglutas ng Problema: Lumikha at magpatupad ng code para lutasin ang mga problema.

Halimbawa: Isang data analysis agent:

1. Gawain: Suriin ang isang dataset upang makita ang mga uso.
2. Mga Hakbang:
   • I-load ang dataset.
   • Gumawa ng mga SQL query upang i-filter ang data.
   • Ipatupad ang mga query at kunin ang mga resulta.
   • Gumawa ng mga visualization at mga pananaw.
3. Mga Resources: Pag-access sa dataset, mga kakayahan sa SQL.
4. Karanasan: Gamitin ang mga nakaraang resulta upang mapabuti ang mga pagsusuri sa hinaharap.

Praktikal na Halimbawa: Paggamit ng SQL sa Travel Agent

1. Pagkuha ng mga Kagustuhan ng Gumagamit

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

2. Pagbuo ng mga SQL Query

   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. Pagpapatupad ng mga SQL Query

   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. Pagbuo ng mga Rekomendasyon

   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)
   

Halimbawa ng mga SQL Query

1. Flight Query

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

2. Hotel Query

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

3. Attraction Query

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

Sa paggamit ng SQL bilang bahagi ng Retrieval-Augmented Generation (RAG) technique, maaaring dinamiko na kunin at gamitin ng mga AI agent gaya ng Travel Agent ang kaugnay na data upang magbigay ng tumpak at personalisadong mga rekomendasyon.

Halimbawa ng Metacognition

Para ipakita ang implementasyon ng metacognition, gagawa tayo ng simpleng agent na naga-reflect sa paraan ng pagdedesisyon habang nilulutas ang isang problema. Sa halimbawa na ito, gagawa tayo ng sistema kung saan sinusubukan ng agent na i-optimize ang pagpili ng hotel, ngunit sinusuri ang sariling pangangatwiran at inaayos ang estratehiya sa oras na makagawa ito ng mga mali o hindi pinakamainam na pagpili.

Sisimit natin ito gamit ang isang basic na halimbawa kung saan pumipili ang agent ng mga hotel base sa kombinasyon ng presyo at kalidad, ngunit “naga-reflect” ito sa mga desisyon at inaayos ang sarili nito nang naaayon.

Paano ito nagpapakita ng metacognition:

1. Unang Desisyon: Pipili ang agent ng pinakamurang hotel, nang hindi nauunawaan ang epekto ng kalidad.
2. Pagmumuni at Pagsusuri: Matapos ang unang pagpili, titingnan ng agent kung ang hotel ba ay “masama” ang pagpili gamit ang feedback ng gumagamit. Kung makikita nitong mababa ang kalidad ng hotel, magninilay ito sa sariling pangangatwiran.
3. Pag-aayos ng Estratehiya: Aayusin ng agent ang estratehiya base sa pagmumuni nito at lilipat mula sa “pinakamura” patungo sa “pinakamataas na kalidad”, kaya mapapabuti ang proseso ng pagdedesisyon sa mga susunod pang pagkakataon.

Narito ang isang halimbawa:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Nagtatago ng mga hotel na napili noon
        self.corrected_choices = []  # Nagtatago ng mga naitamang pagpili
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Mga available na estratehiya

    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]
        # Ipagpalagay nating mayroon tayong feedback mula sa user na nagsasabi kung ang huling pagpili ay maganda o hindi
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # I-adjust ang estratehiya kung ang nakaraang pagpili ay hindi kasiya-siya
            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"

# I-simulate ang isang listahan ng mga hotel (presyo at kalidad)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Gumawa ng isang ahente
agent = HotelRecommendationAgent()

# Hakbang 1: Inirerekomenda ng ahente ang isang hotel gamit ang estratehiyang "pinakamura"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Hakbang 2: Sinusuri ng ahente ang pagpili at ina-adjust ang estratehiya kung kinakailangan
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Hakbang 3: Muling nagrerekomenda ang ahente, sa pagkakataong ito gamit ang na-adjust na estratehiya
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Mga Kakayahan ng Agents sa Metacognition

Ang mahalaga dito ay ang kakayahan ng agent na:

• Suriin ang mga naunang desisyon at proseso ng pagdedesisyon nito.
• Ayusin ang estratehiya nito batay sa pagmumuni — i.e., metacognition na ginagamit.

Ito ay isang simpleng anyo ng metacognition kung saan ang sistema ay kayang i-adjust ang proseso ng pangangatwiran nito base sa panloob na feedback.

Konklusyon

Ang metacognition ay isang makapangyarihang kasangkapan na maaaring lubos na mapabuti ang kakayahan ng mga AI agent. Sa pagsasama ng mga metacognitive na proseso, maaari kang magdisenyo ng mga agent na mas matalino, adaptable, at epektibo. Gamitin ang karagdagang mga resources upang higit pang tuklasin ang kahanga-hangang mundo ng metacognition sa mga AI agent.

May Iba ka Pang Mga Tanong Tungkol sa Metacognition Design Pattern?

Sumali sa Microsoft Foundry Discord para makipagkita sa ibang mga nag-aaral, dumalo sa office hours, at sagutin ang iyong mga tanong tungkol sa AI Agents.

Nakaraang Aralin

Multi-Agent Design Pattern

Susunod na Aralin

AI Agents in Production

---

Pagtatanggi: Ang dokumentong ito ay isinalin gamit ang serbisyo ng AI translation na Co-op Translator. Bagama’t nagsusumikap kami para sa katumpakan, pakatandaan na ang awtomatikong pagsasalin ay maaaring maglaman ng mga pagkakamali o hindi pagkakatugma. Ang orihinal na dokumento sa orihinal nitong wika ang dapat ituring na pangunahing sanggunian. Para sa mahahalagang impormasyon, inirerekomenda ang propesyonal na pagsasalin ng tao. Hindi kami mananagot sa anumang maling pagkakaintindi o maling interpretasyon na nagmula sa paggamit ng pagsasaling ito.

This site is open source. Improve this page.