RAG (Retrieval-Augmented Generation) - 검색으로 환각을 막다

# OpenAI Fine-tuning
training_data = [
    {"messages": [
        {"role": "user", "content": "휴가 정책은?"},
        {"role": "assistant", "content": "연차 15일입니다"}
    ]},
    # ... 수백~수천 개
]

# 모델 학습 (시간 + 비용 소요)
fine_tuned_model = openai.FineTuning.create(
    training_file="data.jsonl",
    model="gpt-3.5-turbo"
)

# 질문만 던짐
question = "2023년 우리 회사 매출은?"
response = llm.generate(question)

# 결과
→ "죄송하지만 해당 정보를 모릅니다."
# 또는 더 나쁜 경우
→ "약 150억원입니다." (환각 - 틀린 정보!)

# 1단계: 관련 문서 검색
question = "2023년 우리 회사 매출은?"
relevant_docs = vector_db.search(question, top_k=3)

# 검색 결과:
# - "2023 Annual Report.pdf" (관련도: 0.92)
# - "Q4 2023 Financial Summary.pdf" (관련도: 0.87)

# 2단계: 문서와 함께 LLM에게 질문
prompt = f"""
다음 문서를 바탕으로 질문에 답하세요:

문서:
{relevant_docs[0].content}
{relevant_docs[1].content}

질문: {question}
"""

response = llm.generate(prompt)

# 결과
→ "2023 Annual Report에 따르면, 2023년 매출은 157억원입니다."

# 텍스트 → 벡터 변환
text1 = "강아지가 공원에서 놀고 있다"
text2 = "개가 야외에서 뛰어놀고 있다"
text3 = "주식 시장이 급락했다"

# 임베딩 (1536차원 벡터로 변환)
vec1 = embedding_model.encode(text1)  # [0.234, -0.123, 0.456, ...]
vec2 = embedding_model.encode(text2)  # [0.221, -0.118, 0.447, ...]
vec3 = embedding_model.encode(text3)  # [-0.567, 0.890, -0.234, ...]

# 유사도 계산 (코사인 유사도)
similarity(vec1, vec2)  # 0.95 (매우 유사)
similarity(vec1, vec3)  # 0.12 (거의 무관)

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
embedding = model.encode("검색할 텍스트")

vector_db.search(
    query_vector,
    top_k=5,
    metric='cosine'
)
# "의미상 유사한" 문서 5개를 찾음

import chromadb

client = chromadb.Client()
collection = client.create_collection("my_docs")

# 문서 저장
collection.add(
    documents=["문서 내용 1", "문서 내용 2"],
    ids=["doc1", "doc2"]
)

# 검색
results = collection.query(
    query_texts=["질문"],
    n_results=3
)

def chunk_by_size(text, chunk_size=500):
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size):
        chunks.append(' '.join(words[i:i+chunk_size]))
    return chunks

# 문단, 섹션 단위로 분할
chunks = text.split('\n\n')  # 빈 줄 기준

# 또는 LangChain 사용
from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,  # 중복 허용 (맥락 유지)
    separators=['\n\n', '\n', '.', ' ']
)

chunks = splitter.split_text(long_document)

from openai import OpenAI
import chromadb

client = OpenAI()

# 1. 벡터 DB 초기화
chroma_client = chromadb.Client()
collection = chroma_client.create_collection("knowledge_base")

# 2. 문서 저장 (임베딩 자동 생성)
documents = [
    "우리 회사 휴가 정책: 연차 15일, 병가 10일",
    "재택근무는 주 2회 가능합니다",
    "점심시간은 12시부터 1시까지입니다"
]

collection.add(
    documents=documents,
    ids=["doc1", "doc2", "doc3"]
)

# 3. RAG 함수
def rag_query(question):
    # 3-1. 관련 문서 검색
    results = collection.query(
        query_texts=[question],
        n_results=2
    )

    context = '\n'.join(results['documents'][0])

    # 3-2. LLM에게 질문 + 문서 제공
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "system",
                "content": "다음 문서를 바탕으로 답하세요. 문서에 없는 내용은 '모르겠습니다'라고 답하세요."
            },
            {
                "role": "user",
                "content": f"문서:\n{context}\n\n질문: {question}"
            }
        ]
    )

    return response.choices[0].message.content

# 4. 사용
answer = rag_query("재택근무 가능한가요?")
print(answer)
# → "네, 주 2회 재택근무가 가능합니다."

answer = rag_query("회사 주소가 어디인가요?")
print(answer)
# → "죄송하지만, 제공된 문서에 회사 주소 정보가 없습니다."

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

# 1. PDF 로드
loader = PyPDFLoader("company_handbook.pdf")
pages = loader.load()

# 2. 청킹
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(pages)

print(f"총 {len(chunks)}개의 청크 생성")

# 3. 임베딩 + 벡터 DB 저장
embeddings = OpenAIEmbeddings()
vector_store = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"  # 디스크에 저장
)

# 4. RAG 체인 구성
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # 문서를 모두 프롬프트에 넣기
    retriever=vector_store.as_retriever(search_kwargs={"k": 3})
)

# 5. 사용
result = qa_chain.run("퇴직금 정책은 어떻게 되나요?")
print(result)

def rag_with_citation(question):
    # 검색
    results = vector_store.similarity_search_with_score(
        question,
        k=3
    )

    # 문서 + 출처 정보 수집
    context_parts = []
    sources = []

    for i, (doc, score) in enumerate(results):
        context_parts.append(f"[출처 {i+1}]\n{doc.page_content}")
        sources.append({
            "id": i+1,
            "file": doc.metadata.get("source", "unknown"),
            "page": doc.metadata.get("page", "unknown"),
            "score": score
        })

    context = '\n\n'.join(context_parts)

    # LLM에게 출처 번호 사용하도록 지시
    prompt = f"""
다음 문서를 바탕으로 질문에 답하세요.
답변할 때 반드시 출처 번호를 명시하세요. (예: [출처 1]에 따르면...)

{context}

질문: {question}
"""

    response = llm.generate(prompt)

    return {
        "answer": response,
        "sources": sources
    }

# 사용
result = rag_with_citation("재택근무 정책은?")
print(result["answer"])
# → "[출처 1]에 따르면, 주 2회 재택근무가 가능합니다."

print("\n출처:")
for source in result["sources"]:
    print(f"  {source['id']}. {source['file']} (페이지 {source['page']})")

from langchain.retrievers import BM25Retriever, EnsembleRetriever

# 벡터 검색기
vector_retriever = vector_store.as_retriever(search_kwargs={"k": 5})

# 키워드 검색기
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 5

# 앙상블 (가중 평균)
ensemble_retriever = EnsembleRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    weights=[0.5, 0.5]  # 50:50 비율
)

# 사용
results = ensemble_retriever.get_relevant_documents("GPT-4 가격")

from sentence_transformers import CrossEncoder

# 1단계: 벡터 검색 (빠르지만 덜 정확)
candidates = vector_store.similarity_search(question, k=20)

# 2단계: Re-ranking (느리지만 정확)
reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

pairs = [[question, doc.page_content] for doc in candidates]
scores = reranker.predict(pairs)

# 점수 기준 재정렬
ranked_docs = sorted(
    zip(candidates, scores),
    key=lambda x: x[1],
    reverse=True
)

# 상위 3개만 사용
top_docs = [doc for doc, score in ranked_docs[:3]]

def expand_query(question, chat_history):
    # LLM에게 이전 대화 맥락 포함하여 질문 재작성 요청
    prompt = f"""
대화 기록:
{chat_history}

사용자 질문: {question}

위 질문을 검색 가능하도록 구체적으로 재작성하세요.
"""

    expanded_query = llm.generate(prompt)
    return expanded_query

# 예시
chat_history = """
사용자: 재택근무 정책 알려줘
AI: 주 2회 재택근무가 가능합니다.
사용자: 그거 언제부터 시행된거야?
"""

expanded = expand_query("그거 언제부터 시행된거야?", chat_history)
# → "재택근무 정책의 시행 날짜는 언제인가요?"

def generate_multiple_queries(question):
    prompt = f"""
다음 질문에 대해 3가지 다른 방식으로 물어보세요:

원본 질문: {question}

1.
2.
3.
"""

    queries = llm.generate(prompt)
    return queries.split('\n')

# 예시
queries = generate_multiple_queries("GPT-4 가격")
# 1. GPT-4의 비용은 얼마인가요?
# 2. GPT-4 API 요금은?
# 3. GPT-4 사용료는 어떻게 되나요?

# 각 질문으로 검색 → 결과 합치기
all_results = []
for query in queries:
    results = vector_store.search(query, k=2)
    all_results.extend(results)

# 중복 제거 + 상위 5개
unique_results = deduplicate(all_results)[:5]

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# 압축기 설정
compressor = LLMChainExtractor.from_llm(llm)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=vector_store.as_retriever()
)

# 사용
compressed_docs = compression_retriever.get_relevant_documents(
    "재택근무 정책"
)

# 원본: 1000 tokens
# 압축: 200 tokens (질문과 관련된 부분만 추출)

# 도메인 특화 용어
question = "우리 시스템의 QPS는?"
document = "초당 쿼리 수(Queries Per Second)는 10,000입니다."

# 일반 임베딩 모델은 "QPS"와 "Queries Per Second"의 관계를 모를 수 있음

# 잘못된 청킹
청크 1: "우리 회사의 매출은 2022년에 100억,"
청크 2: "2023년에는 150억원을 기록했습니다."

# 질문: "2023년 매출은?"
# → 청크 2만 검색되면 문맥 부족

# Parent Document Retriever
from langchain.retrievers import ParentDocumentRetriever

# 작은 청크로 검색 (정확도↑)
# 하지만 원본 문서 반환 (맥락↑)
retriever = ParentDocumentRetriever(
    vectorstore=vector_store,
    docstore=InMemoryDocstore(),
    child_splitter=small_splitter,  # 검색용
    parent_splitter=large_splitter   # 반환용
)

# 1. 각 문서를 개별적으로 요약
summaries = []
for doc in retrieved_docs:
    summary = llm.generate(f"요약: {doc}")
    summaries.append(summary)

# 2. 요약들을 합쳐서 최종 답변
final_answer = llm.generate(f"""
요약들:
{summaries}

질문: {question}
""")

# 첫 문서로 초기 답변 생성
answer = llm.generate(f"{docs[0]}\n\n질문: {question}")

# 다음 문서들로 답변 개선
for doc in docs[1:]:
    answer = llm.generate(f"""
현재 답변: {answer}

추가 정보: {doc}

위 정보를 바탕으로 답변을 개선하세요.
""")

# 1만 개 문서, 각 500 tokens
total_tokens = 10000 * 500 = 5,000,000 tokens

# OpenAI text-embedding-3-small: $0.00002 / 1K tokens
embedding_cost = (5000 / 1000) * 0.00002 = $0.1

# 한 번만 하면 됨 (업데이트 제외)

# 하루 1000 질문
# 각 질문당 평균 2000 tokens (문서 포함)

# GPT-3.5-turbo: $0.0005 / 1K input tokens
daily_cost = 1000 * (2000/1000) * 0.0005 = $1/day
monthly_cost = $30/month

# 1. 캐싱
cache = {}
def cached_rag(question):
    if question in cache:
        return cache[question]

    answer = rag_query(question)
    cache[question] = answer
    return answer

# 2. 더 작은 모델 사용
# GPT-4 → GPT-3.5 (10배 저렴)

# 3. 청크 수 제한
retriever = vector_store.as_retriever(search_kwargs={"k": 3})
# k=5 → k=3 (40% 비용 절감)

# OpenAI는 API 데이터를 학습에 사용하지 않음 (명시)
# 하지만 서버를 거치는 건 사실

# 로컬 임베딩 모델
from sentence_transformers import SentenceTransformer
embeddings = SentenceTransformer('all-MiniLM-L6-v2')

# 로컬 벡터 DB
import chromadb
chroma_client = chromadb.Client()

# 로컬 LLM (오픈소스)
from langchain.llms import LlamaCpp
llm = LlamaCpp(model_path="./llama-2-7b.bin")

# 최신 문서만 검색
results = vector_store.similarity_search(
    question,
    k=5,
    filter={"date": {"$gte": "2025-01-01"}}  # 2025년 이후만
)

from datetime import datetime

def rerank_by_date(docs):
    now = datetime.now()

    scored_docs = []
    for doc in docs:
        doc_date = datetime.fromisoformat(doc.metadata['date'])
        days_old = (now - doc_date).days

        # 최신일수록 높은 점수
        recency_score = 1 / (1 + days_old / 30)  # 한 달마다 감소

        # 유사도 + 최신성
        final_score = doc.score * 0.7 + recency_score * 0.3
        scored_docs.append((doc, final_score))

    return sorted(scored_docs, key=lambda x: x[1], reverse=True)

prompt = f"""
다음 문서들을 바탕으로 답하세요.
주의: 날짜를 확인하고 가장 최신 정보를 사용하세요.

{context}

질문: {question}
"""

# 1. 간단한 구성
- 임베딩: OpenAI text-embedding-3-small
- 벡터 DB: Chroma (로컬)
- LLM: GPT-3.5-turbo
- 프레임워크: LangChain

# 2. 핵심 기능만
- 문서 업로드
- 질문-답변
- 출처 표시

# 3. 평가
- 10개 질문 셋 준비
- 수동으로 답변 품질 확인

# 1. 검색 개선
- Hybrid search 도입
- Re-ranking 추가
- 청킹 전략 최적화

# 2. 프롬프트 엔지니어링
- System prompt 튜닝
- Few-shot examples 추가
- 답변 형식 가이드

# 3. 평가 자동화
def evaluate_rag():
    test_cases = [
        {"question": "...", "expected": "...", "source": "..."},
        # 50개 이상
    ]

    correct = 0
    for case in test_cases:
        answer = rag_query(case["question"])
        if is_correct(answer, case["expected"]):
            correct += 1

    accuracy = correct / len(test_cases)
    print(f"정확도: {accuracy:.1%}")

# 1. 인프라
- 벡터 DB: Pinecone / Weaviate (확장성)
- 모니터링: LangSmith, Weights & Biases
- 로깅: 모든 질문-답변 저장

# 2. 성능 최적화
- 캐싱 (Redis)
- 비동기 처리
- 배치 임베딩

# 3. 안전장치
- Rate limiting
- 컨텐츠 필터링
- Fallback 메커니즘

# 1. 사용자 피드백 수집
def collect_feedback(question, answer, feedback):
    # 엄지 up/down
    db.save({
        "question": question,
        "answer": answer,
        "rating": feedback,
        "timestamp": now()
    })

# 2. 주기적 분석
- 낮은 평가 받은 답변 검토
- 자주 묻는 질문 파악
- 문서 갭 발견

# 3. 모델 업그레이드
- 새 임베딩 모델 A/B 테스트
- LLM 모델 업그레이드