에이전트 걸레를 사용하여 지능형 FAQ 챗봇을 만드는 방법

AI 에이전트는 이제 크고 작은 기업의 일부입니다. 병원의 양식 작성 및 법률 문서 확인에서 비디오 장면 분석 및 고객 지원 처리에 이르기까지 모든 종류의 작업에 대한 AI 에이전트가 있습니다. 회사는 종종 고객의 요구를 이해하고 회사의 지침에 따라이를 해결할 수있는 고객 지원 직원을 고용하는 데 수십만 달러를 소비합니다. 오늘날 FAQ에 답변하는 지능형 챗봇이 있으면 고객 서비스를 효율적으로 향상시킬 수 있습니다. 이 기사에서는 에이전트 래그 (검색 증강 생성), Langgraph 및 ChromADB를 사용하여 몇 초 안에 고객 쿼리를 해결할 수있는 FAQ 챗봇을 구축하는 방법을 배웁니다.

목차

• 에이전트 래그에 대한 간단한
• 지능형 FAQ 챗봇의 아키텍처
• 지능형 FAQ 챗봇 구축에 대한 실습 구현
  • 1 단계 : 종속성을 설치합니다
  • 2 단계 : 필수 라이브러리 가져 오기
  • 3 단계 : OpenAI API 키를 설정하십시오
  • 4 단계 : 데이터 세트를 다운로드하십시오
  • 5 단계 : 매핑의 부서 이름 정의
  • 6 단계 : 도우미 기능을 정의합니다
  • 7 단계 : Langgraph 에이전트 구성 요소를 정의하십시오
  • 8 단계 : 그래프 함수를 정의합니다
  • 9 단계 : 에이전트 실행을 시작합니다
  • 10 단계 : 에이전트 테스트
• 결론

에이전트 래그에 대한 간단한

래그는 요즘 인기있는 주제입니다. 모든 사람들은 걸레에 대해 이야기하고 있으며 그 위에 응용 프로그램을 구축하고 있습니다. Rag는 LLM이 실시간 데이터에 액세스 할 수 있도록 도와줍니다. 이는 LLM이 그 어느 때보 다 정확하게 만듭니다. 그러나 기존의 래그 시스템은 최고의 검색 방법을 선택하거나 검색 워크 플로를 변경하거나 다단계 추론을 제공 할 때 실패하는 경향이 있습니다. 이것은 에이전트 헝겊이 들어오는 곳입니다.

에이전트 래그는 AI 에이전트의 기능을 통합하여 전통적인 래그를 향상시킵니다. 이 초강대국을 통해 Rags는 쿼리의 특성, 다단계 추론 및 다단계 검색에 따라 워크 플로를 동적으로 변경할 수 있습니다. 우리는 도구를 에이전트 래그 시스템에 통합 할 수 있으며 언제 사용할 도구를 동적으로 결정할 수 있습니다. 전반적으로 정확도가 향상되고 시스템을보다 효율적이고 확장 가능하게 만듭니다.

다음은 에이전트 헝겊 워크 플로의 예입니다.

위의 이미지는 에이전트 래그 프레임 워크의 아키텍처를 나타냅니다. AI 요원이 RAG와 결합 할 때 특정 조건에서 결정을 내릴 수있는 방법을 보여줍니다. 이미지는 조건부 노드가있는 경우 에이전트가 제공된 컨텍스트에 따라 어떤 모서리를 선택할 것인지 결정할 것임을 분명히 보여줍니다.

또한 LLM 에이전트의 10 비즈니스 애플리케이션도 읽습니다

지능형 FAQ 챗봇의 아키텍처

이제 우리는 우리가 구축 할 챗봇의 아키텍처에 뛰어들 것입니다. 우리는 그것이 어떻게 작동하는지, 그리고 중요한 구성 요소가 무엇인지 탐구 할 것입니다.

다음 그림은 시스템의 전체 구조를 보여줍니다. 우리는 Langgraph를 사용하여 이것을 구현할 것입니다. Langgraph는 Langchain의 오픈 소스 AI 에이전트 프레임 워크입니다.

시스템의 주요 구성 요소는 다음과 같습니다.

1. Langgraph : 복잡한 다중 에이전트, 순환 그래프 기반 에이전트를 효율적으로 생성하는 강력한 오픈 소스 AI 에이전트 프레임 워크. 이 에이전트는 워크 플로 전체에서 상태를 유지할 수 있으며 복잡한 쿼리를 효율적으로 처리 할 수 ​​있습니다.
2. LLM : 사용자의 지침을 따르고 그에 따라 최선을 다하면 대답 할 수있는 효율적이고 강력한 대형 언어 모델입니다. 여기서 우리는 OpenAI의 O4-Mini를 사용합니다. 이는 속도, 경제성 및 공구 사용을 위해 특별히 설계된 작은 추론 모델입니다.
3. 벡터 데이터베이스 : 벡터 데이터베이스는 일반적으로 데이터의 숫자 표현 인 벡터 임베딩을 저장, 관리 및 검색하는 데 사용됩니다. 여기서 우리는 오픈 소스 AI 네이티브 벡터 데이터베이스 인 ChromADB를 사용하고 있습니다. 유사성 검색, 시맨틱 검색 및 벡터 데이터와 관련된 기타 작업에 의존하는 시스템에 권한을 부여하도록 설계되었습니다.

또한 읽으십시오 : 고객 지원 음성 에이전트를 구축하는 방법

지능형 FAQ 챗봇 구축에 대한 실습 구현

이제 우리는 위에서 논의한 아키텍처를 기반으로 챗봇의 엔드 투 엔드 워크 플로우를 구현할 것입니다. 우리는 자세한 설명, 코드 및 샘플 출력으로 단계별로 수행 할 것입니다. 그래서 시작하자.

1 단계 : 종속성을 설치합니다

필요한 모든 라이브러리를 Jupyter 노트북에 설치하는 것으로 시작합니다. 여기에는 Langchain, Langgraph, Langchain-Openai, Langchain-Community, Chromadb, Openai, Python-Dotenv, Pydantic 및 Pysqlite3과 같은 라이브러리가 포함됩니다.

 ! PIP 설치 -Q Langchain Langgraph Langgraph-Openai Langchain-Community Chromadb Openai Python-Dotenv Pydantic Pysqlite3

2 단계 : 필수 라이브러리 가져 오기

이제 우리는이 프로젝트에 필요한 나머지 라이브러리를 모두 가져올 준비가되었습니다.

 OS 가져 오기
JSON 수입
입력 가져 오기 목록, typeddict, 주석이 달린, dict
dotenv import load_dotenv에서

# langchain & langgraph 특정 수입
langchain_openai import chatopenai, openaiembeddings에서
langchain_core.prompts import chatprompttemplate, messageplaceholder를 가져옵니다
Pydantic Import Basemodel, Field에서
Langchain_core에서 Messages Import SystemMessage, HumanMessage, Aimessage
langchain_core에서 문서 가져 오기
langchain_community.vectorstores import Chroma에서
langgraph.graph import Stategraph, End

3 단계 : OpenAI API 키를 설정하십시오

OpenAI 키를 입력하여 환경 변수로 설정하십시오.

 getpass import getpass에서
Openai_api_key = getpass ( "OpenAi API 키 :")
load_dotenv ()
os.getenv ( "openai_api_key")

4 단계 : 데이터 세트를 다운로드하십시오

우리는 다른 부서의 샘플 FAQ 데이터 세트를 JSON 형식으로 만들었습니다. 드라이브에서 다운로드하고 압축을 풀어야합니다.

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

산출:

5 단계 : 매핑의 부서 이름 정의

이제 에이전트 시스템이 어떤 부서에 속하는 파일을 이해할 수 있도록 부서의 매핑을 정의해 봅시다.

 # Define Department Names (섭취 중에 사용되는이 메타 데이터를 확인하십시오)
부서 = [
   "고객 지원",
   "제품 정보",
   "충성도 프로그램 / 보상"
]]
unknown_department = "알 수없는/기타"

faq_files = {
   "고객 지원": "고객 _support_faq.json",
   "제품 정보": "product_information_faq.json",
   "로열티 프로그램 / 보상": "Loyalty_Program_faq.json",
}

6 단계 : 도우미 기능을 정의합니다

JSON 파일에서 FAQ를로드하고 ChromADB에 저장하는 일부 도우미 기능을 정의합니다.

1. load_faqs (…) : JSON 파일에서 FAQ를로드하고 All_FAQS라는 목록에 저장하는 도우미 기능입니다.

 def load_faqs (file_paths : dict [str, str]) -> dict [str, list [dict [str, str]] :
   "" "각 부서의 JSON 파일에서 QA 쌍을로드합니다." ""
   all_faqs = {}
   인쇄 ( "FAQ로드 ...")
   Dept의 경우 file_paths.items ()의 file_path
       노력하다:
           flo ost as wash open (file_path, 'r', encoding = 'utf-8').
               all_faqs [dept] = json.load (f)
               print (f " -로드 된 {len (all_faqs [dept])} faqs for {dept}")
       filenotfounderRor를 제외하고 :
           print (f " - 경고 : {dept} : {file_path}에 대해 찾을 수 없음. 건너 뛰기.")
       json.jsondecodeerror를 제외하고 :
           print (f " - 오류 : {file_path}에서 {dept}를 위해 JSON을 디코딩 할 수 없습니다. 건너 뛰기.")
   all_faqs를 반환하십시오

2. SETUP_CHROMA_VECTOR_STORE (…) : 이 함수는 벡터 임베딩을 저장하기 위해 ChromADB를 설정합니다. 이를 위해 먼저 Chroma 데이터베이스 파일을 포함하는 디렉토리 인 Chroma 구성을 정의합니다. 그런 다음 FAQ를 Langchain의 문서로 변환합니다. 여기에는 정확한 걸레에 대한 사전 정의 된 형식 인 메타 데이터 및 페이지 컨텐츠가 포함됩니다. 더 나은 상황 검색을 위해 질문과 답변을 결합하거나 답을 포함시킬 수 있습니다. 우리는 메타 데이터에서 부서 이름과 부서 이름을 유지하고 있습니다.

 # 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]]],
   persist_directory : str,
   collection_name : str,
   Embedding_Model : OpenAiEmbeddings,
) -> 크로마 :
   "" "FAQ 데이터 및 메타 데이터로 크로마 벡터 스토어를 생성하거나로드합니다." ""
   문서 = []
   print ( "\ npreparing documents for Vector Store ...")
   부서의 경우 All_faqs.items ()의 FAQ
       FAQ의 경우 :
           # Q & A를 더 나은 상황에 맞게 포함 시키거나 답변을 포함시키기 위해 Q & A를 결합하십시오.
           # content = f "Question : {faq [ 'Question']} \ nanswer : {faq [ 'derson']}"
           Content = FAQ [ 'Answer'] # 종종 대답 만 포함되는 경우 FAQ 검색에 효과적입니다.
           doc = document (
               page_content = content,
               메타 데이터 = {
                   "부서": 부서,
                   "질문": FAQ [ 'Question'] # 잠재적 인 디스플레이를위한 메타 데이터에 대한 질문 유지
                   }
           ))
           문서.

   print (f "총 문서 준비 : {len (문서)}")

   문서가 아닌 경우 :
       ValueError Raise ( "벡터 저장소에 추가 된 문서가 없음. FAQ로드를 확인하십시오.")

   print (f "ChromADB 벡터 저장소 초기화 (persistence : {persist_directory}) ...")
   vector_store = Chroma (
       collection_name = collection_name,
       embedding_function = embedding_model,
       persist_directory = persist_directory,
   ))
   노력하다:
     vector_store = Chroma.from_documents (
             문서 = 문서,
             임베딩 = embedding_model,
             persist_directory = persist_directory,
             collection_name = collection_name
             ))
     {len (문서)} 문서를 사용하여 print (f "생성 및 채워진 ChromADB.")
     vector_store.persist () # 생성 후 지속성을 보장합니다
     인쇄 ( "벡터 저장소 지속.")
   create_e로 예외를 제외하고 :
           print (f "치명적인 오류 : 크로마 벡터 저장소를 만들 수 없습니다 : {create_e}")
           Create_e를 높이십시오

   인쇄 ( "ChromADB 설정 완료")
   vector_store를 반환합니다

7 단계 : Langgraph 에이전트 구성 요소를 정의하십시오

이제 작업 흐름의 주요 구성 요소 인 AI 에이전트 구성 요소를 정의해 봅시다.

1. 상태 정의 : 실행 중에 에이전트의 현재 상태를 포함하는 파이썬 클래스입니다. 여기에는 쿼리, 감정, 부서와 같은 변수가 포함되어 있습니다.

 클래스 에이전트 스테이트 (typeddict) :
   쿼리 : str
   감정 : str
   부서 : str
   컨텍스트 : RAG에 대한 STR # 검색 컨텍스트
   응답 : STR # 사용자에 대한 최종 응답
   오류 : str | 잠재적 오류를 캡처 할 수 없습니다

2. Pydantic Model : 우리는 여기에서 구조화 된 LLM 출력을 보장하는 Pydantic 모델을 정의했습니다. 여기에는 "긍정적", "음성"및 "중립"의 세 가지 값과 LLM이 예측할 부서 이름을 갖는 감정이 포함되어 있습니다.

 클래스 ClassificationResult (Basemodel) :
   "" "쿼리 분류를위한 구조화 된 출력." ""
   감정 : str = field (description = "쿼리의 감정 (긍정적, 중립, 부정)")
   Department : str = field (description = f "목록에서 가장 관련성있는 부서 : {Departments [Unknown_Department]}. '{unknown_department}'확실하지 않거나 적용 할 수없는 경우 ').

3. 노드 : 다음은 각 작업을 하나씩 처리하는 노드 함수입니다.

• classify_query_node : 쿼리의 특성에 따라 들어오는 쿼리를 감정과 대상 부서 이름으로 분류합니다.
• retieve_context_node : 벡터 데이터베이스를 통해 래그를 수행하고 부서 이름을 기준으로 결과를 필터링합니다.
• generate_response_node : 쿼리를 기반으로 최종 응답을 생성하고 데이터베이스에서 검색된 컨텍스트를 생성합니다.
• Human_escalation_node : 감정이 음수이거나 대상 부서를 알 수없는 경우 쿼리를 사람에게 에스컬레이션합니다.
• Route_Query : 분류 노드의 쿼리 및 출력을 기반으로 다음 단계를 결정합니다.

 # 3. 노드
def classify_query_node (state : agerstate) -> dict [str, str] :
   "" "
   LLM을 사용하여 감정 및 대상 부서의 사용자 쿼리를 분류합니다.
   "" "
   print ( "--- 쿼리 분류 ---")
   query = state [ "query"]
   llm = chatopenai (model = "o4-mini", api_key = openai_api_key) # 신뢰할 수 있고 저렴한 모델 사용

   # 분류 프롬프트 준비
   prompt_template = chatprompttemplate.from_messages ([[
       SystemMessage (
           Content = F "" ""귀하는 소매 회사 인 ShopUnow의 전문가 쿼리 분류기입니다.
사용자의 쿼리를 분석하여 정서와 가장 관련성이 높은 부서를 결정하십시오.
사용 가능한 부서는 다음과 같습니다. { ','.join (부서)}.
쿼리가 이들 중 하나에 명확하게 맞지 않거나 모호한 경우 부서를 '{unknown_department}'로 분류하십시오.
쿼리가 좌절, 분노, 불만족 또는 문제에 대해 불평하는 경우 감정을 '부정적인'것으로 분류하십시오.
쿼리가 질문을하고 정보를 구하거나 중립적 인 진술을하는 경우 감정을 '중립적'으로 분류하십시오.
쿼리가 만족, 칭찬 또는 긍정적 인 피드백을 표현하면 감정을 '긍정적'으로 분류하십시오.
구조화 된 JSON 출력 형식으로 만 응답하십시오. "" "
       ),)
       HumanMessage (content = f "사용자 쿼리 : {query}")
   ])))

   # 구조화 된 출력이있는 LLM 체인
   classifier_chain = prompt_template | llm.with_structured_output (classificationResult)

   노력하다:
       결과 : classificationResult = classifier_chain.invoke ({}) # 입력이 필요한 것처럼 비워진 dict를 전달합니다.
       print (f "분류 결과 : sentiment = '{result.sentiment}', department = '{result.department}'")
       반품 {
           "정서": result.sentiment.lower (), # 정상화
           "부서": result.department
           }
   E로 예외를 제외하고 :
       print (f "분류 중 오류 : {e}")
       반품 {
           "정서": "중립", # 오류의 기본값
           "부서": unknown_department,
           "오류": f "분류 실패 : {e}"
           }

def retrieve_context_node (state : agerstate) -> dict [str, str] :
   "" "
   쿼리 및 부서를 기반으로 벡터 스토어에서 관련 컨텍스트를 검색합니다.
   "" "
   print ( "--- 컨텍스트 검색 ---")
   query = state [ "query"]
   부서 = 주 [ "부서"]

   부서 또는 부서가 아닌 경우 == unknown_department :
       인쇄 ( "검색 검색 건너 뛰기 : 부서 알 수 없거나 적용 할 수 없음")
       반환 { "context": "", "error": "유효한 부서 없이는 컨텍스트를 검색 할 수 없습니다."}

   # 임베딩 모델 및 벡터 매장 액세스 초기화
   embedding_model = OpenAiembedDings (api_key = OpenAi_api_key)
   vector_store = Chroma (
       collection_name = chroma_collection_name,
       embedding_function = embedding_model,
       persist_directory = chroma_persist_directory,
   ))
   Retriever = vector_store.as_retriever (
       search_type = "유사성",
       search_kwargs = {
           'K': 3, # 상위 3 개의 관련 문서를 검색합니다
           '필터': { 'Department': Department} # *** 중요 : 부서별 필터 ***
           }
   ))

   노력하다:
       retrieved_docs = retriever.invoke (query)
       검색된 경우 _docs :
           context = "\ n \ n --- \ n \ n".join
           print (f "검색 {len (retrieved_docs)} 부서 용 문서 '{department}').
           # print (f "context snippet : {context [: 200]} ...") # 선택 사항 : 로그 스 니펫
           return { "context": 컨텍스트, "오류": none}
       또 다른:
           인쇄 ( "이 부서의 벡터 스토어에 관련 문서가 없습니다.")
           return { "context": "", "error": "관련 컨텍스트가 발견되지 않음"}
   E로 예외를 제외하고 :
       print (f "컨텍스트 검색 중 오류 : {e}")
       return { "context": "", "error": f "검색 실패 : {e}"}

def generate_response_node (state : agerstate) -> dict [str, str] :
   "" "
   쿼리 및 검색된 컨텍스트를 기반으로 RAG를 사용하여 응답을 생성합니다.
   "" "
   print ( "--- 응답 생성 (rag) ---")
   query = state [ "query"]
   context = state [ "Context"]
   llm = chatopenai (model = "o4-mini", api_key = openai_api_key) # 생성에 더 유능한 모델을 사용할 수 있습니다.

   컨텍스트가 아닌 경우 :
       print ( "컨텍스트 없음, 일반적인 응답 생성")
       # 검색이 실패한 경우 낙하했지만 라우팅은 어쨌든 래그 경로를 결정했습니다.
       response_text = "지식 기반에서 귀하의 쿼리와 관련된 특정 정보를 찾을 수 없었습니다. 자세한 내용을 보내거나 자세히 설명해 주시겠습니까?"
       return { "response": response_text}

   # Rag 프롬프트
   prompt_template = chatprompttemplate.from_messages ([[
       SystemMessage (
           content = f "" ""당신은 shopUnow에 유용한 AI 챗봇입니다. 제공된 컨텍스트에서 사용자의 쿼리 기반 *에만 답하십시오.
간결하고 쿼리를 직접 해결하십시오. 컨텍스트에 답을 포함하지 않으면 명확하게 설명하십시오.
정보를 구성하지 마십시오.
문맥:
---
{문맥}
--- "" "
       ),)
       HumanMessage (content = f "사용자 쿼리 : {query}")
   ])))

   rag_chain = prompt_template | LLM

   노력하다:
       응답 = rag_chain.invoke ({})
       response_text = response.content
       print (f "생성 래그 응답 : {response_text [: 200]} ...")
       return { "response": response_text}
   E로 예외를 제외하고 :
       print (f "응답 생성 중 오류 : {e}")
       return { "response": "죄송합니다. 응답을 생성하는 동안 오류가 발생했습니다.", "오류": F "생성 실패 : {e}"}.

def human_escalation_node (state : agerstate) -> dict [str, str] :
   "" "
   쿼리가 인간에게 에스컬레이션 될 것이라는 메시지를 제공합니다.
   "" "
   print ( "--- 인간 지원으로 확대 ---")
   이유 = ""
   state.get ( "sentiment") == "negative"인 경우 :
       이유 = "쿼리의 특성으로 인해"
   Elif State.get ( "Department") == unknown_department :
       이유 = "쿼리가 특별한주의를 기울여야하므로"

   response_text = f "{rasy} 나는 이것을 인간 지원 팀으로 에스컬레이션해야합니다. 그들은 당신의 요청을 검토하고 곧 당신에게 돌아갈 것입니다. 인내심에 감사드립니다."
   print (f "에스컬레이션 메시지 : {response_text}")
   return { "response": response_text}

# 4. 조건부 라우팅 로직
def route_Query (state : agerstate) -> str :
   "" "분류 결과를 기반으로 다음 단계를 결정합니다." ""
   print ( "--- 라우팅 결정 ---")
   sentiment = state.get ( "정서", "중립")
   Department = State.get ( "부서", Unknown_department)

   If Sentiment == "Negative"또는 Department == unknown_department :
       print (f "라우팅 : human_escalation (sentiment : {sentiment}, department : {department})")
       "Human_escalation"을 반환하십시오.
   또 다른:
       print (f "라우팅 : retieve_context (sentiment : {sentiment}, 부서 : {department})")
       "retrieve_context"를 반환합니다.

8 단계 : 그래프 함수를 정의합니다

그래프의 기능을 작성하고 노드와 모서리를 그래프에 할당하겠습니다.

 # --- 그래프 정의 ---

def build_agent_graph (vector_store : chroma) -> stategraph :
   "" "Langgraph 에이전트를 구축합니다." ""
   그래프 = stategraph (AgentState)

   # 노드 추가
   graph.add_node ( "classify_query", classify_query_node)
   graph.add_node ( "retrieve_context", retieve_context_node)
   graph.add_node ( "generate_response", generate_response_node)
   graph.add_node ( "human_escalation", human_escalation_node)

   # 입력 지점을 설정합니다
   Graph.set_entry_point ( "Classify_Query")

   # 가장자리를 추가하십시오
   graph.add_conditional_edges (
       "Classify_Query", # 소스 노드
       Route_Query, # 기능을 결정하는 기능
       { # 매핑 : Route_Query의 출력 -> 대상 노드
           "retieve_context": "retieve_context",
           "Human_escalation": "Human_escalation"
       }
   ))
   graph.add_edge ( "retieve_context", "generate_response")
   graph.add_edge ( "generate_response", end)
   graph.add_edge ( "human_escalation", end)

   # 그래프를 컴파일합니다
   # memory = sqlitesaver.from_conn_string ( ": memory :") # 메모리 지속성에 대한 예제
   app = graph.compile () # checkpointer = memory 옵션 상태 상태의 대화에 대한 선택 사항
   print ( "\ nagent 그래프가 성공적으로 컴파일되었습니다.")
   반환 앱

9 단계 : 에이전트 실행을 시작합니다

이제 우리는 에이전트를 초기화하고 워크 플로를 실행하기 시작할 것입니다.

1. FAQ를로드하여 시작합시다.

 # 1.로드 FAQ
faqs_data = load_faqs (faq_files)

FAQS_DATA가 아닌 경우 :
   인쇄 ( "오류 : FAQ 데이터가로드되지 않았습니다. 종료.")
   출구()

산출:

2. 임베딩 모델을 설정하십시오. 여기에서는 더 빠른 검색을 위해 OpenAi 임베딩 모델을 설정할 것입니다.

 # 2. 설정 벡터 스토어
embedding_model = OpenAiembedDings (api_key = OpenAi_api_key)
vector_store = setup_chroma_vector_store (
   FAQS_DATA,
   chroma_persist_directory,
   chroma_collection_name,
   embedding_model
))

산출:

또한 읽으십시오 : RAG 모델에 적합한 임베딩을 선택하는 방법은 무엇입니까?

3. 이제 미리 정의 된 함수를 사용하여 에이전트를 구축하여 인어 다이어그램을 사용하여 에이전트 흐름을 시각화하십시오.

 # 3. 에이전트 그래프를 빌드하십시오
agent_app = build_agent_graph (vector_store)

IPYTHON.DISPLY 가져 오기 디스플레이, 이미지, 마크 다운

display (image (agent_app.get_graph (). draw_mermaid_png ()))

산출:

10 단계 : 에이전트 테스트

우리는 워크 플로의 마지막 부분에 도착했습니다. 지금까지 우리는 여러 노드와 기능을 구축했습니다. 이제 에이전트를 테스트하고 출력을 볼 때입니다.

1. 먼저 테스트 쿼리를 정의 해 봅시다.

 # 에이전트를 테스트하십시오
test_queries = [
   "내 주문을 어떻게 추적합니까?",
   "반환 정책은 무엇입니까?",
   " 'Urban Explorer'재킷 재료에 대해 알려주세요.",
]]

2. 이제 에이전트를 테스트합시다.

 print ( "\ n --- 테스트 에이전트 ---")
test_queries의 쿼리 :
   print (f "\ ninput query : {query}")
   # 그래프 호출에 대한 입력을 정의하십시오
   입력 = { "쿼리": 쿼리}
   # 노력하다:
   # 그래프를 호출합니다
   # 구성 인수는 선택 사항이지만 필요한 경우 상태가 적합한 실행에 유용합니다.
   # config = { "configurable": { "strand_id": "user_123"}} # config
   final_state = agent_app.invoke (입력) #, config = config)

   print (f "최종 국무부 : {final_state.get ( 'department')}")
   print (f "최종 상태 감정 : {final_state.get ( 'sentiment')}")
   print (f "에이전트 응답 : {final_state.get ( 'response')}")
   if final_state.get ( 'error') :
         print (f "오류가 발생 : {final_state.get ( 'error')}")

   # E로 예외를 제외하고 :
   # print (f "query '{query}'의 오류 실행 에이전트 그래프. : {e}")
   # 트레이스 백을 가져옵니다
   # traceback.print_exc () # 디버깅을위한 상세한 추적을 인쇄합니다

print ( "\ n --- 에이전트 테스트 완료 ---")

print (“\ n - 테스트 에이전트 -“)

산출:

우리는 출력에서 ​​에이전트가 잘 수행되고 있음을 알 수 있습니다. 먼저 쿼리를 분류 한 다음 결정을 검색 노드 또는 사람 노드로 라우팅합니다. 그런 다음 검색 부분이 벡터 데이터베이스에서 컨텍스트를 성공적으로 검색합니다. 마지막으로, 필요에 따라 응답을 생성합니다. 따라서 우리는 지능형 FAQ 챗봇을 만들었습니다.

모든 코드와 함께 Colab 노트북에 액세스 할 수 있습니다.

결론

지금까지 도달했다면 에이전트 래그와 랑그 그라프를 사용하여 지능형 FAQ 챗봇을 구축하는 방법을 배웠습니다. 여기서, 우리는 추론하고 결정을 내릴 수있는 지능형 에이전트를 구축하는 것이 그렇게 어렵지 않다는 것을 알았습니다. 우리가 구축 한 에이전트 챗봇은 비용 효율적이고 빠르며 질문 또는 입력 쿼리의 컨텍스트를 완전히 이해할 수 있습니다. 우리가 여기서 사용한 아키텍처는 완전히 사용자 정의 할 수 있으므로 특정 사용 사례에 대해 에이전트의 노드를 편집 할 수 있습니다. 에이전트 헝겊, 랑그 그라프 및 크로마 브로 인해 에이전트를 만드는 것은 결코 쉽지 않았습니다. 전에는 그렇게 쉽지 않습니다. 이 안내서에서 우리가 다루었던 것이 이러한 도구를 사용하여보다 복잡한 시스템을 구축하기위한 기본 지식을 제공했다고 확신합니다.

위 내용은 에이전트 걸레를 사용하여 지능형 FAQ 챗봇을 만드는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!