1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_core.output_parsers import StrOutputParser
from langchain.prompts import ChatPromptTemplate

# 벡터 스토어 생성 및 문서 로드
documents = ["This is document 1 about LLM.", "This is document 2 about AI agents."]

vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=OpenAIEmbeddings(),
)

retriever = vectorstore.as_retriever()

# 쿼리 생성 및 검색
query = "What is LLM?"
results = retriever.get_relevant_documents(query)

# RRF 재정렬 함수
def reciprocal_rank_fusion(results, k=60):
    fused_scores = {}
    for rank, doc in enumerate(results):
        if doc not in fused_scores:
            fused_scores[doc] = 0
        fused_scores[doc] += 1 / (rank + k)

    reranked_results = sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
    return reranked_results

# RRF를 적용한 재정렬
reranked_results = reciprocal_rank_fusion(results)
print("Reranked results:", reranked_results)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# 검색기 및 검색 도구
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
web_search_tool = TavilySearchResults(k=3)

# 질문 재작성 LLM
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
rewrite_prompt = ChatPromptTemplate.from_template(
    "Here is the initial question: {question}. Rephrase this question for better search."
)

def corrective_rag(question):
    # 1단계: 벡터 스토어 검색
    results = retriever.get_relevant_documents(question)

    # 2단계: 문서 평가
    if not results or len(results) < 1:
        # 3단계: 질문 재작성 및 웹 검색
        rewritten_question = rewrite_prompt.invoke({"question": question})
        web_results = web_search_tool.invoke({"query": rewritten_question})
        results.extend(web_results)

    return results

question = "What are AI agents?"
corrected_docs = corrective_rag(question)
print(corrected_docs)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# 문서 및 벡터 스토어 설정
documents = ["Document 1 about LLM", "Document 2 about AI agents"]
vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=OpenAIEmbeddings(),
)
retriever = vectorstore.as_retriever()

# LLM 및 문서 평가
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

def self_rag(question):
    # 1단계: 검색
    results = retriever.get_relevant_documents(question)

    # 2단계: 답변 생성
    generated_answer = llm.invoke({
        "context": results,
        "question": question
    })

    # 3단계: 생성된 답변 평가
    if "insufficient" in generated_answer:
        # 문서가 충분하지 않다면 추가 검색
        additional_results = retriever.get_relevant_documents(f"{question} more details")
        results.extend(additional_results)
        generated_answer = llm.invoke({
            "context": results,
            "question": question
        })

    return generated_answer

question = "What are the types of AI agents?"
answer = self_rag(question)
print(answer)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import ChatPromptTemplate

# 질문 분석 및 웹 검색 도구
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
web_search_tool = TavilySearchResults(k=3)

# 질문 라우팅 및 Active RAG
def active_rag(question):
    # 질문 분석
    initial_results = retriever.get_relevant_documents(question)

    if len(initial_results) < 2:  # 문서가 부족하면 웹 검색 수행
        additional_results = web_search_tool.invoke({"query": question})
        initial_results.extend(additional_results)

    # 최종 답변 생성
    answer = llm.invoke({
        "context": initial_results,
        "question": question
    })

    return answer

question = "What is LLM task decomposition?"
final_answer = active_rag(question)
print(final_answer)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from langchain_openai import OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate

# 벡터 스토어 검색기
vector_retriever = vectorstore.as_retriever()

# LLM 설정
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

# 질문 라우팅 함수
def adaptive_rag(question):
    # 질문 분석 및 라우팅
    if "LLM" in question:
        results = vector_retriever.get_relevant_documents(question)
    else:
        results = web_search_tool.invoke({"query": question})

    # 답변 생성
    answer = llm.invoke({
        "context": results,
        "question": question
    })
    return answer

question = "What are the types of LLM agents?"
adaptive_answer = adaptive_rag(question)
print(adaptive_answer)