Cara Membina Chatbot Soalan Lazim Pintar Menggunakan Rag Agentik

Ejen AI kini menjadi sebahagian daripada perusahaan besar dan kecil. Dari borang mengisi di hospital dan memeriksa dokumen undang -undang untuk menganalisis rakaman video dan mengendalikan sokongan pelanggan - kami mempunyai ejen AI untuk semua jenis tugas. Syarikat sering menghabiskan beratus -ratus ribu dolar untuk menyewa kakitangan sokongan pelanggan yang dapat memahami keperluan pelanggan dan menyelesaikannya berdasarkan garis panduan syarikat. Hari ini, mempunyai chatbot pintar untuk menjawab Soalan Lazim dapat meningkatkan perkhidmatan pelanggan dengan cekap. Dalam artikel ini, kita akan belajar bagaimana untuk membina FAQ Chatbot yang dapat menyelesaikan pertanyaan pelanggan dalam beberapa saat, menggunakan RAG Agentic (pengambilan semula Generasi), Langgraph dan Chromadb.

Jadual Kandungan

• Singkat mengenai Rag Agentic
• Seni bina Soalan Lazim Chatbot
• Pelaksanaan tangan untuk membina chatbot Soalan Lazim yang pintar
  • Langkah 1: Pasang kebergantungan
  • Langkah 2: Import perpustakaan yang diperlukan
  • Langkah 3: Sediakan Kunci API Terbuka
  • Langkah 4: Muat turun dataset
  • Langkah 5: Menentukan nama jabatan untuk pemetaan
  • Langkah 6: Tentukan fungsi penolong
  • Langkah 7: Tentukan komponen ejen Langgraph
  • Langkah 8: Tentukan fungsi grafik
  • Langkah 9: Memulakan pelaksanaan ejen
  • Langkah 10: Menguji ejen
• Kesimpulan

Singkat mengenai Rag Agentic

Rag adalah topik hangat pada masa kini. Semua orang bercakap tentang kain dan aplikasi membina di atasnya. RAG membantu LLM untuk mendapatkan akses kepada data masa nyata, yang menjadikan LLM lebih tepat daripada sebelumnya. Walau bagaimanapun, sistem kain tradisional cenderung gagal apabila memilih kaedah pengambilan terbaik, mengubah aliran kerja pengambilan semula, atau menyediakan penalaran pelbagai langkah. Di sinilah Agentic Rag masuk.

RAG Agentic meningkatkan kain tradisional dengan menggabungkan keupayaan agen AI ke dalamnya. Dengan kuasa besar ini, RAGS boleh mengubah aliran kerja secara dinamik berdasarkan sifat pertanyaan, melakukan penalaran multi-langkah, dan pengambilan semula pelbagai langkah juga. Kami juga boleh mengintegrasikan alat ke dalam sistem RAG yang agentik, dan ia secara dinamik boleh menentukan alat mana yang hendak digunakan ketika. Secara keseluruhannya, ia menghasilkan ketepatan yang lebih baik dan menjadikan sistem lebih cekap dan berskala.

Berikut adalah contoh aliran kerja rag yang agentik.

Imej di atas menandakan seni bina kerangka Rag Agentik. Ia menunjukkan bagaimana agen AI, apabila digabungkan dengan kain, boleh membuat keputusan di bawah syarat -syarat tertentu. Imej itu jelas menunjukkan bahawa jika nod bersyarat ada, ejen akan menentukan kelebihan yang dipilih berdasarkan konteks yang disediakan.

Juga Baca: 10 Aplikasi Perniagaan Ejen LLM

Seni bina Soalan Lazim Chatbot

Sekarang kita akan menyelam ke dalam seni bina chatbot yang akan kita bina. Kami akan meneroka bagaimana ia berfungsi dan komponen pentingnya.

Angka berikut menunjukkan struktur keseluruhan sistem kami. Kami akan melaksanakannya menggunakan Langgraph, yang merupakan rangka kerja agen AI sumber terbuka dari Langchain.

Komponen utama sistem kami termasuk:

1. Langgraph: Rangka kerja agen AI sumber terbuka yang kuat yang mewujudkan ejen berasaskan grafik yang kompleks, multi-agen, kitaran. Ejen -ejen ini dapat mengekalkan negeri -negeri di seluruh aliran kerja dan dapat mengendalikan pertanyaan kompleks dengan cekap.
2. LLM: Model bahasa besar yang cekap dan berkuasa yang dapat mengikuti arahan pengguna dan membalas dengan sewajarnya dengan pengetahuannya yang terbaik. Di sini kita akan menggunakan Openai's O4-Mini, yang merupakan model penalaran kecil yang direka khusus untuk kelajuan, kemampuan, dan penggunaan alat.
3. Pangkalan Data Vektor: Pangkalan data vektor digunakan untuk menyimpan, mengurus dan mengambil embeddings vektor yang biasanya merupakan perwakilan data angka. Di sini kita menggunakan Chromadb yang merupakan pangkalan data vektor asli AI sumber terbuka. Ia direka untuk memperkasakan sistem yang bergantung kepada carian kesamaan, carian semantik, dan tugas lain yang melibatkan data vektor.

Juga Baca: Cara Membina Ejen Suara Sokongan Pelanggan

Pelaksanaan tangan untuk membina chatbot Soalan Lazim yang pintar

Sekarang, kami akan melaksanakan aliran kerja akhir-ke-akhir chatbot kami berdasarkan seni bina yang telah kami bincangkan di atas. Kami akan melakukannya dengan langkah demi langkah dengan penjelasan terperinci, kod, serta output sampel. Oleh itu mari kita mulakan.

Langkah 1: Pasang kebergantungan

Kami akan bermula dengan memasang semua perpustakaan yang diperlukan ke dalam buku nota Jupyter kami. Ini termasuk perpustakaan seperti Langchain, Langgraph, Langchain-Openai, Langchain-Community, Chromadb, Openai, Python-Dotenv, Pydantic, dan Pysqlite3.

 ! pip pemasangan -q langchain langgraph langchain-openai langchain-community chromadbu openai python-dotenv pydantic pysqlite3

Langkah 2: Import perpustakaan yang diperlukan

Sekarang kami bersedia untuk mengimport semua perpustakaan yang tinggal yang kami perlukan untuk projek ini.

 Import OS
Import JSON
Dari senarai Import Menaip, Taipkan, Annotated, Dict
dari dotenv import load_dotenv

# Langchain & Langgraph Import Khusus
Dari Langchain_openai import Chatopenai, Openaiembeddings
dari langchain_core.Prompts import chatprompttemplate, mesej tempat
dari Pydantic Import Basemodel, Field
dari langchain_core.Messages Import SystemMessage, HumanMessage, Aimessage
dari langchain_core.documents Document Document
dari langchain_community.vectorstores import chroma
Dari Langgraph.Graph Import Stategraph, Tamat

Langkah 3: Sediakan Kunci API Terbuka

Masukkan kekunci OpenAI anda untuk menetapkannya sebagai pemboleh ubah persekitaran.

 dari Getpass Import Getpass
Openai_api_key = getpass ("Openai API Key:")
LOAD_DOTENV ()
os.getenv ("Openai_API_Key")

Langkah 4: Muat turun dataset

Kami telah membuat dataset FAQ sampel dalam format JSON untuk jabatan yang berbeza. Kami perlu memuat turunnya dari pemacu dan unzipnya.

 ! gdown 1j6pdiansfqzkozseuinnhd8w6glkke6w
! unzip -o /content/blog_faq_files.zip

Output:

Langkah 5: Menentukan nama jabatan untuk pemetaan

Sekarang, mari kita tentukan pemetaan jabatan supaya sistem agentik kita dapat memahami fail mana yang dimiliki oleh jabatan mana.

 # Tentukan nama jabatan (pastikan metadata perlawanan ini digunakan semasa pengambilan)
Jabatan = [
   "Sokongan Pelanggan",
   "Maklumat Produk",
   "Program Kesetiaan / Ganjaran"
]
Tidak diketahui_department = "tidak diketahui/lain"

Faq_files = {
   "Sokongan Pelanggan": "Customer_Support_faq.json",
   "Maklumat Produk": "Product_information_faq.json",
   "Program Kesetiaan / Ganjaran": "Kesetiaan_program_faq.json",
}

Langkah 6: Tentukan fungsi penolong

Kami akan menentukan beberapa fungsi penolong yang akan bertanggungjawab untuk memuatkan Soalan Lazim dari fail JSON dan juga menyimpannya di Chromadb.

1. LOAD_FAQS (...): Ia adalah fungsi penolong yang memuatkan FAQ dari fail JSON dan menyimpannya dalam senarai yang dipanggil All_FAQs.

 def load_faqs (file_paths: dict [str, str]) -> dict [str, list [dict [str, str]]:
   "" "Memuatkan pasangan QA dari fail JSON untuk setiap jabatan." ""
   all_faqs = {}
   Cetak ("Memuatkan Soalan Lazim ...")
   untuk jabatan, file_path dalam file_paths.items ():
       Cuba:
           dengan buka (file_path, 'r', encoding = 'utf-8') sebagai f:
               all_faqs [jabatan] = json.load (f)
               cetak (f " - dimuatkan {len (all_faqs [dept])} FAQs untuk {dept}")
       Kecuali FileNotFoundError:
           cetak (f " - Amaran: Fail FAQ tidak dijumpai untuk {dept}: {file_path}. Skipping.")
       Kecuali json.jsondecodeError:
           cetak (f " - ralat: tidak dapat menyahkod json untuk {dept} dari {file_path}. Skipping.")
   kembali all_faqs

2. Setup_chroma_vector_store (...): Fungsi ini menubuhkan ChromAdb untuk menyimpan embeddings vektor. Untuk ini, kami akan mula -mula menentukan konfigurasi Chroma iaitu, direktori yang akan mengandungi fail pangkalan data Chroma. Kemudian kami akan menukar Soalan Lazim ke dokumen Langchain. Ia akan mengandungi kandungan metadata dan halaman yang merupakan format yang telah ditetapkan untuk kain yang tepat. Kita boleh menggabungkan soalan dan jawapan untuk pengambilan semula kontekstual yang lebih baik atau hanya membenamkan jawapannya. Kami menyimpan soalan serta nama jabatan dalam metadata.

 # Konfigurasi Chromadb
Chroma_persist_directory = "./chroma_db_store"
Chroma_collection_name = "chatbot_faqs"

def setup_chroma_vector_store (
   all_faqs: dict [str, list [dict [str, str]],
   ENTERT_DIRECTORY: str,
   koleksi_name: str,
   embedding_model: Openaiembeddings,
) -> Chroma:
   "" "Mewujudkan atau memuatkan kedai vektor Chroma dengan data FAQ dan metadata." ""
   Dokumen = []
   Cetak ("Dokumen \ NPREARING untuk kedai vektor ...")
   untuk jabatan, Soalan Lazim di All_faqs.items ():
       Untuk Soalan Lazim di Soalan Lazim:
           # Menggabungkan Q & A untuk membenamkan kontekstual yang lebih baik, atau hanya menanamkan jawapan
           # kandungan = f "soalan: {faq ['soal']} \ nanswer: {faq ['answer']}"
           Kandungan = FAQ ['Jawapan'] # sering membenamkan hanya jawapannya berkesan untuk pengambilan FAQ
           DOC = Dokumen (
               page_content = kandungan,
               metadata = {
                   "Jabatan": Jabatan,
                   "Soalan": Soalan Lazim ['Soalan'] # Simpan soalan dalam metadata untuk paparan berpotensi
                   }
           )
           Documents.Append (Doc)

   cetak (f "jumlah dokumen yang disediakan: {len (dokumen)}")

   Sekiranya tidak dokumen:
       Naikkan ValueError ("Tiada dokumen yang ditemui untuk ditambah ke kedai vektor. Periksa Soalan Lazim.")

   cetak (f "memulakan kedai vektor chromadb (kegigihan: {exention_directory}) ...")
   vector_store = chroma (
       collection_name = collection_name,
       embedding_function = embedding_model,
       ENTERT_DIRECTORY = ENTERT_DIRECTORY,
   )
   Cuba:
     vector_store = chroma.from_documents (
             Dokumen = Dokumen,
             embedding = embedding_model,
             ENTERT_DIRECTORY = ENTERT_DIRECTORY,
             collection_name = collection_name
             )
     cetak (f "dicipta dan dihuni Chromadb dengan {len (dokumen)} Dokumen.")
     vector_store.persist () # Pastikan ketekunan selepas penciptaan
     Cetak ("Kedai vektor berterusan.")
   Kecuali pengecualian seperti create_e:
           cetak (f "ralat maut: tidak dapat membuat kedai vektor chroma: {create_e}")
           Naikkan create_e

   Cetak ("Persediaan Chromadb lengkap.")
   kembali vector_store

Langkah 7: Tentukan komponen ejen Langgraph

Mari kita tentukan komponen ejen AI kita yang merupakan komponen utama aliran kerja kita.

1. Definisi Negeri: Ia adalah kelas python yang mengandungi keadaan semasa ejen semasa berjalan. Ia mengandungi pembolehubah seperti pertanyaan, sentimen, jabatan.

 Kelas AgentState (TypeDDict):
   Pertanyaan: Str
   Sentimen: Str
   Jabatan: Str
   Konteks: STR # yang diambil konteks untuk kain
   Respons: str # respons akhir kepada pengguna
   Ralat: str | Tiada # untuk menangkap kesilapan yang berpotensi

2. Model Pydantic: Kami telah menentukan model Pydantic di sini yang akan memastikan output LLM berstruktur. Ia mengandungi sentimen yang akan mempunyai tiga nilai, "positif", "negatif" dan "neutral" dan nama jabatan yang akan diramalkan oleh LLM.

 Klasifikasi KelasResult (BaseModel):
   "" "Output berstruktur untuk klasifikasi pertanyaan." ""
   Sentimen: str = medan (keterangan = "Sentimen pertanyaan (positif, neutral, negatif)")
   Jabatan: str = medan (description = f "Jabatan yang paling relevan dari senarai: {Jabatan [Unknown_Department]}. Gunakan '{unknown_department}' jika tidak pasti atau tidak berkenaan.")

3. Nod: Berikut adalah fungsi nod yang akan mengendalikan setiap tugas satu demi satu.

• Classify_Query_node: Ia mengklasifikasikan pertanyaan masuk ke dalam sentimen serta nama jabatan sasaran berdasarkan sifat pertanyaan.
• RELIEVE_CONTEXT_NODE: Ia melakukan kain di atas pangkalan data vektor dan menapis hasilnya berdasarkan nama jabatan.
• Generate_response_node: Ia menghasilkan tindak balas akhir berdasarkan pertanyaan dan konteks yang diambil dari pangkalan data.
• Human_escalation_node: Jika sentimen negatif atau jabatan sasaran tidak diketahui, ia akan meningkatkan pertanyaan kepada pengguna manusia.
• route_query: Ia menentukan langkah seterusnya berdasarkan pertanyaan dan output nod klasifikasi.

 # 3. Nod
def Classify_Query_node (State: AgentState) -> Dict [str, str]:
   "" "
   Mengklasifikasikan pertanyaan pengguna untuk sentimen dan jabatan sasaran menggunakan LLM.
   "" "
   Cetak ("--- Klasifikasi pertanyaan ---")
   pertanyaan = Negeri ["pertanyaan"]
   llm = chatopenai (model = "o4-mini", api_key = openai_api_key) # Gunakan model yang boleh dipercayai, lebih murah

   # Sediakan cepat untuk klasifikasi
   prompt_template = chatprompttemplate.from_messages ([
       SystemMessage (
           Kandungan = f "" "Anda adalah pengelas pertanyaan pakar untuk ShopUnow, sebuah syarikat runcit.
Menganalisis pertanyaan pengguna untuk menentukan sentimennya dan jabatan yang paling relevan.
Jabatan yang ada adalah: {',' .join (jabatan)}.
Jika pertanyaan tidak sesuai dengan salah satu daripada ini, atau samar -samar, mengklasifikasikan jabatan sebagai '{unknown_department}'.
Jika pertanyaan itu menyatakan kekecewaan, kemarahan, ketidakpuasan, atau mengadu tentang masalah, mengklasifikasikan sentimen sebagai 'negatif'.
Jika pertanyaan itu bertanya soalan, mencari maklumat, atau membuat pernyataan neutral, mengklasifikasikan sentimen sebagai 'neutral'.
Jika pertanyaan itu menyatakan kepuasan, pujian, atau maklum balas positif, mengklasifikasikan sentimen sebagai 'positif'.
Balas hanya dengan format output JSON berstruktur. "" "
       ))
       HumanMessage (kandungan = f "pertanyaan pengguna: {query}")
   ])

   # Rantai llm dengan output berstruktur
   classifier_chain = prompt_template | llm.with_structured_output (klasifikasiResult)

   Cuba:
       Hasil: klasifikasiResult = classifier_chain.invoke ({}) # Pass kosong kosong kerana input nampaknya diperlukan sekarang
       cetak (f "hasil klasifikasi: sentimen = '{result.sentiment}', jabatan = '{result.department}'")
       kembali {
           "Sentimen": result.sentiment.lower (), # menormalkan
           "Jabatan": Hasil.Department
           }
   Kecuali pengecualian sebagai e:
       cetak (f "ralat semasa klasifikasi: {e}")
       kembali {
           "Sentimen": "Neutral", # Default on ERROR
           "Jabatan": Unknown_Department,
           "Ralat": f "Klasifikasi gagal: {e}"
           }

def pengambilan_context_node (State: AgentState) -> dict [str, str]:
   "" "
   Mendapatkan konteks yang relevan dari kedai vektor berdasarkan pertanyaan dan jabatan.
   "" "
   cetak ("--- mengambil konteks ---")
   pertanyaan = Negeri ["pertanyaan"]
   Jabatan = Negeri ["Jabatan"]

   Sekiranya tidak jabatan atau jabatan == tidak diketahui_department:
       Cetak ("Melangkau pengambilan semula: jabatan tidak diketahui atau tidak berkenaan.")
       kembali {"konteks": "", "ralat": "tidak dapat mengambil konteks tanpa jabatan yang sah."}

   # Inisialisasi Model Embedding dan Akses Kedai Vektor
   embedding_model = openaiembeddings (API_KEY = OPENAI_API_KEY)
   vector_store = chroma (
       collection_name = chroma_collection_name,
       embedding_function = embedding_model,
       ENTERT_DIRECTORY = CHROMA_PERSIST_DIRECTORY,
   )
   retriever = vector_store.as_retriever (
       search_type = "Persamaan",
       search_kwargs = {
           'K': 3, # Ambil 3 dokumen yang berkaitan
           'penapis': {'jabatan': jabatan} # *** Kritikal: penapis oleh jabatan ***
           }
   )

   Cuba:
       Retrieved_docs = retriever.invoke (pertanyaan)
       Jika diambil_docs:
           konteks = "\ n \ n --- \ n \ n" .join ([doc.page_content untuk doc in retrieved_docs])
           cetak (f "diambil {len (retrieved_docs)} Dokumen untuk jabatan '{jabatan}'.")
           # cetak (f "coretan konteks: {context [: 200]} ...") # Pilihan: Log coretan
           kembali {"konteks": konteks, "ralat": tiada}
       lain:
           Cetak ("Tiada dokumen yang berkaitan yang terdapat di kedai vektor untuk jabatan ini.")
           kembali {"konteks": "", "ralat": "Tiada konteks yang relevan dijumpai."}
   Kecuali pengecualian sebagai e:
       cetak (f "ralat semasa pengambilan semula konteks: {e}")
       kembali {"konteks": "", "ralat": f "pengambilan semula gagal: {e}"}

def Generate_response_node (state: AgentState) -> dict [str, str]:
   "" "
   Menjana respons menggunakan RAG berdasarkan pertanyaan dan konteks yang diambil.
   "" "
   Cetak ("--- Response Generating (RAG) ---")
   pertanyaan = Negeri ["pertanyaan"]
   konteks = keadaan ["konteks"]
   llm = chatopenai (model = "o4-mini", api_key = openai_api_key) # boleh menggunakan model yang lebih mampu untuk generasi

   Sekiranya tidak konteks:
       Cetak ("Tiada konteks yang disediakan, menjana tindak balas generik.")
       # Sandaran jika pengambilan semula gagal tetapi laluan diputuskan jalur rag pula
       response_text = "Saya tidak dapat mencari maklumat khusus yang berkaitan dengan pertanyaan anda di pangkalan pengetahuan kami. Bolehkah anda mengemukakan semula atau memberikan maklumat lanjut?"
       kembali {"respons": response_text}

   # Prompt rag
   prompt_template = chatprompttemplate.from_messages ([
       SystemMessage (
           kandungan = f "" "Anda adalah chatbot AI yang berguna untuk ShopUnow. Jawab pertanyaan pengguna berdasarkan * hanya * pada konteks yang disediakan.
Jadilah ringkas dan terus menangani pertanyaan. Sekiranya konteksnya tidak mengandungi jawapannya, nyatakan dengan jelas.
Jangan buat maklumat.
Konteks:
---
{konteks}
--- "" "
       ))
       HumanMessage (kandungan = f "pertanyaan pengguna: {query}")
   ])

   Rag_chain = prompt_template | llm

   Cuba:
       respons = rag_chain.invoke ({})
       response_text = response.content
       cetak (f "Respons Rag yang dihasilkan: {response_text [: 200]} ...")
       kembali {"respons": response_text}
   Kecuali pengecualian sebagai e:
       cetak (f "ralat semasa penjanaan tindak balas: {e}")
       kembali {"Response": "Maaf, saya mengalami ralat semasa menjana respons.", "Ralat": f "Gagal gagal: {e}"}

def human_escalation_node (State: AgentState) -> dict [str, str]:
   "" "
   Menyediakan mesej yang menunjukkan pertanyaan akan meningkat kepada manusia.
   "" "
   Cetak ("--- Meningkatkan Sokongan Manusia ---")
   alasan = ""
   jika state.get ("sentimen") == "negatif":
       alasan = "kerana sifat pertanyaan anda,"
   elif state.get ("jabatan") == Unknown_Department:
       Sebab = "Sebagai pertanyaan anda memerlukan perhatian khusus,"

   response_text = f "{reason} Saya perlu meningkatkan ini kepada pasukan sokongan manusia kami. Mereka akan menyemak permintaan anda dan kembali kepada anda tidak lama lagi. Terima kasih atas kesabaran anda."
   cetak (f "Mesej Escalation: {response_text}")
   kembali {"respons": response_text}

# 4. Logik penghalaan bersyarat
def route_query (state: ejenState) -> str:
   "" "Menentukan langkah seterusnya berdasarkan hasil klasifikasi." ""
   cetak ("--- keputusan penghalaan ---")
   sentimen = state.get ("sentimen", "neutral")
   jabatan = state.get ("Jabatan", Unknown_Department)

   jika sentimen == "negatif" atau jabatan == unknown_department:
       cetak (f "routing ke: human_escalation (sentimen: {sentimen}, jabatan: {jabatan})")
       kembali "Human_escalation"
   lain:
       cetak (f "routing to: retrieve_context (sentimen: {sentimen}, jabatan: {jabatan})")
       Kembali "RELIEVE_CONTEXT"

Langkah 8: Tentukan fungsi grafik

Mari kita bina fungsi untuk graf dan berikan nod dan tepi ke graf.

 # --- definisi graf ---

def build_agent_graph (vector_store: chroma) -> stategraph:
   "" "Membina ejen Langgraph." ""
   Grafik = Stategraph (AgentState)

   # Tambah nod
   graf.add_node ("Classify_Query", Classify_Query_node)
   graph.add_node ("pengambilan semula_context", pengambilan_context_node)
   graf.add_node ("Generate_response", Generate_response_node)
   graf.add_node ("human_escalation", human_escalation_node)

   # Tetapkan titik entri
   graf.set_entry_point ("Classify_Query")

   # Tambah tepi
   graph.add_conditional_edges (
       "Classify_Query", # Sumber Node
       route_query, # berfungsi untuk menentukan laluan
       { # Pemetaan: output route_query -> nod destinasi
           "Retrieve_context": "Retrieve_Context",
           "Human_escalation": "Human_escalation"
       }
   )
   graph.add_edge ("Retrieve_Context", "Generate_Response")
   graf.add_edge ("Generate_Response", end)
   graf.add_edge ("human_escalation", akhir)

   # Menyusun graf
   # memori = sqlitesaver.from_conn_string (": memori:") # Contoh untuk kegigihan dalam memori
   app = graph.compile () # checkPointer = memori pilihan untuk perbualan yang berkesudahan
   Cetak ("Grafik Nagent berjaya disusun.")
   Aplikasi Kembali

Langkah 9: Memulakan pelaksanaan ejen

Sekarang, kita akan memulakan ejen dan mula melaksanakan aliran kerja.

1. Mari kita mulakan dengan memuatkan Soalan Lazim.

 # 1. Beban Soalan Lazim
FAQS_DATA = LOAD_FAQS (FAQ_FILES)

Sekiranya tidak FAQS_DATA:
   Cetak ("Ralat: tiada data FAQ dimuatkan. Keluar.")
   keluar ()

Output:

2. Sediakan model embedding. Di sini, kami akan menubuhkan model penyembuhan terbuka untuk pengambilan yang lebih cepat.

 # 2. Stor Vektor Persediaan
embedding_model = openaiembeddings (API_KEY = OPENAI_API_KEY)
vector_store = setup_chroma_vector_store (
   FAQS_DATA,
   Chroma_persist_directory,
   Chroma_collection_name,
   embedding_model
)

Output:

Juga baca: Bagaimana untuk memilih penyembuhan yang betul untuk model RAG anda?

3. Sekarang, bina ejen menggunakan fungsi yang telah ditetapkan, menggambarkan aliran ejen menggunakan rajah duyung.

 # 3. Bina graf ejen
agen_app = binaan_agent_graph (vector_store)

dari paparan import ipython.display, imej, markdown

paparan (imej (ejen_app.get_graph (). Draw_mermaid_png ()))

Output:

Langkah 10: Menguji ejen

Kami telah tiba di bahagian terakhir aliran kerja kami. Setakat ini kami telah membina beberapa nod dan fungsi. Sekarang adalah masa untuk menguji ejen kami dan melihat output.

1. Pertama mari kita tentukan pertanyaan ujian.

 # Menguji ejen
test_queries = [
   "Bagaimana saya menjejaki pesanan saya?",
   "Apakah dasar pulangan?",
   "Beritahu saya tentang bahan jaket 'Urban Explorer'.",
]

2. Sekarang mari kita uji ejen.

 cetak ("\ n --- ejen ujian ---")
Untuk pertanyaan dalam test_queries:
   cetak (f "\ ninput query: {query}")
   # Tentukan input untuk pengambilan grafik
   input = {"query": query}
   # Cuba:
   # Memohon graf
   # Hujah konfigurasi adalah pilihan tetapi berguna untuk pelaksanaan negara jika diperlukan
   # config = {"configurable": {"thread_id": "user_123"}} # Contoh Config
   final_state = agen_app.invoke (input) #, config = config)

   cetak (f "Jabatan Negeri Akhir: {final_state.get ('Jabatan')}")
   cetak (f "Sentimen Negeri Akhir: {final_state.get ('sentimen')}")
   cetak (f "respons ejen: {final_state.get ('response')}")
   jika final_state.get ('ralat'):
         cetak (f "ralat ditemui: {final_state.get ('error')}")

   # kecuali pengecualian sebagai e:
   # cetak (f "graf ejen ralat untuk pertanyaan '{query}': {e}")
   # Import Traceback
   # traceback.print_exc () # cetak traceback terperinci untuk debugging

cetak ("\ n --- ujian ejen lengkap ---")

Cetak ("\ n- ejen ujian -")

Output:

Kita dapat melihat dalam output yang ejen kita berfungsi dengan baik. Pertama, ia mengklasifikasikan pertanyaan dan kemudian mengarahkan keputusan ke nod pengambilan atau nod manusia. Kemudian, bahagian pengambilan datangnya berjaya mendapatkan semula konteks dari pangkalan data vektor. Pada yang terakhir, menjana respons yang diperlukan. Oleh itu, kami telah membuat chatbot FAQ pintar kami.

Anda boleh mengakses buku nota Colab dengan semua kod di sini.

Kesimpulan

Jika anda telah mencapai sejauh ini, ini bermakna anda telah belajar bagaimana untuk membina chatbot FAQ pintar menggunakan Rag dan Langgraph. Di sini, kita melihat bahawa membina ejen pintar yang boleh membuat alasan dan membuat keputusan, tidak begitu sukar. Chatbot agentik yang kami bina adalah kos yang cekap, cepat, dan mampu memahami sepenuhnya konteks soalan atau pertanyaan input. Senibina yang kami gunakan di sini adalah disesuaikan sepenuhnya yang bermaksud seseorang boleh mengedit mana -mana nod ejen untuk kes penggunaan tertentu. Dengan Agentic Rag, Langgraph, dan Chromadb, membuat ejen tidak pernah mudah ini. tidak pernah begitu mudah sebelum ini. Saya yakin apa yang telah kami sampaikan dalam panduan ini telah memberi anda pengetahuan asas untuk membina sistem yang lebih kompleks menggunakan alat ini.

Atas ialah kandungan terperinci Cara Membina Chatbot Soalan Lazim Pintar Menggunakan Rag Agentik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!