Ver3.0 ๐ค ํ์ด์ฌ + LangChain์ผ๋ก ๊ฒ์ ๊ธฐ๋ฐ AI ๋น์ ๊ตฌํ

๐ค ํ์ด์ฌ + LangChain์ผ๋ก ๊ฒ์ ๊ธฐ๋ฐ AI ๋น์ ๊ตฌํ
๋๋ง์ ๋๋ํ AI ๋น์ ๋ง๋ค๊ธฐ ์์ ์ ๋ณต ๊ฐ์ด๋ ใ ใ ใ
๐ฏ ์์ฆ AI ๋น์ ๋ง๋๋ ๊ฑฐ ์์ ํซํ์์์?
์์งํ ChatGPT ๋์ค๊ณ ๋์ ๋ค๋ค "๋๋ ์ด๋ฐ ๊ฑฐ ๋ง๋ค ์ ์์๊น?" ์๊ฐํด๋ดค์ ๊ฑฐ์์ ใ
ใ
ใ
๊ทผ๋ฐ ๋ง์ ์์ํ๋ ค๋๊น ๋ญ๋ถํฐ ํด์ผ ํ ์ง ๋ชจ๋ฅด๊ฒ ๊ณ ... ๊ทธ๋ฅ OpenAI API ํธ์ถํ๋ ๊ฒ๋ง์ผ๋ก๋ ๋ญ๊ฐ 2% ๋ถ์กฑํ์์์? ๐ค
ํนํ ํ์ฌ ๋ด๋ถ ๋ฌธ์ ๊ฒ์ํ๊ฑฐ๋, ํน์ ๋๋ฉ์ธ ์ง์์ ๊ฐ์ง AI ๋น์๋ฅผ ๋ง๋ค๊ณ ์ถ์ ๋๋ ๋จ์ GPT ํธ์ถ๋ง์ผ๋ก๋ ํ๊ณ๊ฐ ๋ช
ํํด์. ์ฌ๊ธฐ์ ๋ฑ์ฅํ๋ ๊ฒ ๋ฐ๋ก **๊ฒ์ ๊ธฐ๋ฐ AI ๋น์(RAG: Retrieval-Augmented Generation)** ์์คํ
์ด์์! ๐ก
์ด ๊ธ์์๋ ํ์ด์ฌ๊ณผ LangChain์ ํ์ฉํด์ ์ค์ ๋ก ์๋ํ๋ ๊ฒ์ ๊ธฐ๋ฐ AI ๋น์๋ฅผ ์ฒ์๋ถํฐ ๋๊น์ง ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์. ์ฝ๋ ์์ ๋ ํํ ๋ฃ๊ณ , ์ค์ ํ๋ ๊ฐ๋ ๋ด์์ผ๋๊น ๋๊น์ง ์ง์คํด์ฃผ์ธ์~ ๐
๐ RAG๊ฐ ๋ญ๋ฐ? ์ ํ์ํ ๊ฑฐ์ผ?
RAG(Retrieval-Augmented Generation)๋ ๋ง ๊ทธ๋๋ก "๊ฒ์์ผ๋ก ์ฆ๊ฐ๋ ์์ฑ" ๊ธฐ์ ์ด์์. ์ฝ๊ฒ ๋งํ๋ฉด AI๊ฐ ๋ต๋ณํ๊ธฐ ์ ์ ๋จผ์ ๊ด๋ จ ์๋ฃ๋ฅผ ์ฐพ์๋ณด๊ณ , ๊ทธ ์๋ฃ๋ฅผ ์ฐธ๊ณ ํด์ ๋ต๋ณํ๋ ๋ฐฉ์์ด์ฃ ๐
์ผ๋ฐ GPT ๋ชจ๋ธ์ ํ์ต๋ ๋ฐ์ดํฐ๊น์ง๋ง ์๊ณ ์์ด์. 2023๋
์ดํ ์ ๋ณด๋ ํ์ฌ ๋ด๋ถ ๋ฌธ์ ๊ฐ์ ๊ฑด ์ ํ ๋ชจ๋ฅด์ฃ . ๊ทผ๋ฐ RAG๋ฅผ ์ฐ๋ฉด ์ด๋ฐ ๋ฌธ์ ๊ฐ ์น ํด๊ฒฐ๋ผ์!
2. ํ๊ฐ(Hallucination) ๊ฐ์ - ์ค์ ๋ฌธ์ ๊ธฐ๋ฐ์ผ๋ก ๋ต๋ณํ๋๊น ๊ฑฐ์ง๋ง ํ ์ค์ด๋ฆ ใ ใ ใ
3. ์ถ์ฒ ๋ช ์ ๊ฐ๋ฅ - "์ด ์ ๋ณด๋ XX ๋ฌธ์ 3ํ์ด์ง์์ ๊ฐ์ ธ์์ด์" ์ด๋ฐ ์์ผ๋ก ์ ๋ขฐ๋ UP
4. ๋๋ฉ์ธ ํนํ - ๋ฒ๋ฅ , ์๋ฃ, ๊ธ์ต ๋ฑ ์ ๋ฌธ ๋ถ์ผ์ ํนํ๋ AI ๋น์ ๊ตฌ์ถ ๊ฐ๋ฅ
5. ๋น์ฉ ํจ์จ์ - ๋ชจ๋ธ ์ฌํ์ต ์์ด๋ ์ง์ ์ ๋ฐ์ดํธ ๊ฐ๋ฅ
๐ ๏ธ LangChain์ด ๋ญ๊ธธ๋ ๋ค๋ค ์ฐ๋ ๊ฑฐ์ผ?
LangChain์ LLM(Large Language Model) ์ ํ๋ฆฌ์ผ์ด์
์ ์ฝ๊ฒ ๋ง๋ค ์ ์๊ฒ ํด์ฃผ๋ ํ๋ ์์ํฌ์์. ์์งํ ์ฒ์์๋ "์ด๊ฑฐ ์ ํ์ํด? ๊ทธ๋ฅ OpenAI API ์ฐ๋ฉด ๋๋ ๊ฑฐ ์๋?" ํ๋๋ฐ... ์จ๋ณด๋๊น ์์ ๊ฟ์ด๋๋ผ๊ณ ์ ๐ฏ
LangChain ์์ด RAG ์์คํ
๋ง๋ค๋ ค๋ฉด ์ง์ง ํ ๊ฒ ์ฐ๋๋ฏธ์์. ๋ฌธ์ ๋ก๋ฉํ๊ณ , ์ฒญํฌ๋ก ๋๋๊ณ , ์๋ฒ ๋ฉ ๋ง๋ค๊ณ , ๋ฒกํฐ DB์ ์ ์ฅํ๊ณ , ๊ฒ์ํ๊ณ , ํ๋กฌํํธ ๋ง๋ค๊ณ ... ํํ ๐ต
๊ทผ๋ฐ LangChain ์ฐ๋ฉด? ์ด ๋ชจ๋ ๊ฒ ๋ช ์ค ์ฝ๋๋ก ๋๋์ ใ
ใ
ใ
โข Text Splitters - ๊ธด ๋ฌธ์๋ฅผ ์ ์ ํ ํฌ๊ธฐ๋ก ๋ถํ
โข Embeddings - ํ ์คํธ๋ฅผ ๋ฒกํฐ๋ก ๋ณํ
โข Vector Stores - ๋ฒกํฐ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐ ๊ฒ์
โข Retrievers - ์ง๋ฌธ๊ณผ ๊ด๋ จ๋ ๋ฌธ์ ๊ฒ์
โข Chains - ์ฌ๋ฌ ์ปดํฌ๋ํธ๋ฅผ ์ฐ๊ฒฐํด์ ๋ณต์กํ ์ํฌํ๋ก์ฐ ๊ตฌ์ฑ
โข Agents - ๋๊ตฌ๋ฅผ ์ฌ์ฉํด์ ์์จ์ ์ผ๋ก ์์ ์ํ
๐ป ๊ฐ๋ฐ ํ๊ฒฝ ์ธํ ๋ถํฐ ์์ํด๋ณผ๊น์?
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝ๋ฉ ๋ค์ด๊ฐ๋๋ค! ๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค ์ค์นํด์ผ์ฃ . ๊ฐ์ํ๊ฒฝ ๋ง๋๋ ๊ฑฐ ์์ง ๋ง์๊ณ ์~ ๐
# ๊ฐ์ํ๊ฒฝ ์์ฑ
python -m venv langchain_env
# Windows
langchain_env\Scripts\activate
# Mac/Linux
source langchain_env/bin/activate
pip install langchain
pip install openai
pip install chromadb
pip install tiktoken
pip install pypdf
pip install python-dotenv
pip install langchain-community
pip install langchain-openai
ํ๋ก์ ํธ ๋ฃจํธ์ .env ํ์ผ ๋ง๋ค๊ณ OpenAI API ํค ๋ฃ์ด์ฃผ์ธ์.
# .env ํ์ผ
OPENAI_API_KEY=sk-your-api-key-here
๐ ๋ฌธ์ ๋ก๋ฉ๊ณผ ์ ์ฒ๋ฆฌ - ์ฒซ ๋ฒ์งธ ๊ด๋ฌธ
์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก RAG ์์คํ ์ ๋ง๋ค์ด๋ณผ ๊ฑฐ์์. ์ฒซ ๋จ๊ณ๋ ๋ฌธ์๋ฅผ ๋ก๋ฉํ๊ณ ์ ์ฒ๋ฆฌํ๋ ๊ฑฐ์ฃ . PDF ํ์ผ์ ์์๋ก ๋ค์ด๋ณผ๊ฒ์ ๐
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from dotenv import load_dotenv
import os
# ํ๊ฒฝ๋ณ์ ๋ก๋
load_dotenv()
# PDF ํ์ผ ๋ก๋ฉ
loader = PyPDFLoader("company_manual.pdf")
documents = loader.load()
print(f"์ด {len(documents)}๊ฐ์ ํ์ด์ง๋ฅผ ๋ก๋ฉํ์ต๋๋ค!")
print(f"์ฒซ ๋ฒ์งธ ํ์ด์ง ๋ด์ฉ ๋ฏธ๋ฆฌ๋ณด๊ธฐ: {documents[0].page_content[:200]}...")
๊ทผ๋ฐ ์ฌ๊ธฐ์ ๋์ด ์๋์์! ๋ฌธ์๋ฅผ ๊ทธ๋ฅ ํต์งธ๋ก ๋ฃ์ผ๋ฉด ์ ๋๊ณ , ์ ์ ํ ํฌ๊ธฐ๋ก ์ชผ๊ฐ์ผ ํด์. ์ด๊ฑธ "์ฒญํน(Chunking)"์ด๋ผ๊ณ ํ๋๋ฐ, ์ด๊ฒ ์ง์ง ์ค์ํด์ ๐ช
์ฒญํฌ ํฌ๊ธฐ๊ฐ ๋๋ฌด ์์ผ๋ฉด โ ๋ฌธ๋งฅ ์ ๋ณด ์์ค, ๊ฒ์ ๊ฒฐ๊ณผ ๋๋ฌด ๋ง์
๋ณดํต 500~1000 ํ ํฐ ์ ๋๊ฐ ์ ๋นํ๋ค๊ณ ์๋ ค์ ธ ์์ด์. ๊ทผ๋ฐ ์ด๊ฒ๋ ๋๋ฉ์ธ๋ง๋ค ๋ค๋ฅด๋๊น ์คํํด๋ณด๋ฉด์ ์ต์ ๊ฐ ์ฐพ์์ผ ํด์!
# ํ
์คํธ ๋ถํ ๊ธฐ ์ค์
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, # ์ฒญํฌ ํฌ๊ธฐ
chunk_overlap=200, # ์ฒญํฌ ๊ฐ ๊ฒน์น๋ ๋ถ๋ถ
length_function=len,
separators=["\n\n", "\n", " ", ""]
)
# ๋ฌธ์ ๋ถํ
splits = text_splitter.split_documents(documents)
print(f"์ด {len(splits)}๊ฐ์ ์ฒญํฌ๋ก ๋ถํ ๋์์ต๋๋ค!")
# ์ฒญํฌ ์์ ํ์ธ
for i, split in enumerate(splits[:3]):
print(f"\n=== ์ฒญํฌ {i+1} ===")
print(f"๋ด์ฉ: {split.page_content[:150]}...")
print(f"๋ฉํ๋ฐ์ดํฐ: {split.metadata}")
๐งฎ ์๋ฒ ๋ฉ๊ณผ ๋ฒกํฐ ์คํ ์ด - AI์ ๊ธฐ์ต ์ ์ฅ์
์ด์ ๋ถํ ๋ ํ ์คํธ๋ฅผ ๋ฒกํฐ๋ก ๋ณํํด์ผ ํด์. ๋ฒกํฐ๋ก ๋ณํํ๋ค๋ ๊ฒ ๋ญ๋๊ณ ์? ์ฝ๊ฒ ๋งํ๋ฉด ํ ์คํธ๋ฅผ ์ซ์ ๋ฐฐ์ด๋ก ๋ฐ๊พธ๋ ๊ฑฐ์์. ์ด๋ ๊ฒ ํ๋ฉด ์ปดํจํฐ๊ฐ "์๋ฏธ์ ์ผ๋ก ๋น์ทํ" ํ ์คํธ๋ฅผ ์ฐพ์ ์ ์๊ฑฐ๋ ์ ๐ข
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
# OpenAI ์๋ฒ ๋ฉ ๋ชจ๋ธ ์ด๊ธฐํ
embeddings = OpenAIEmbeddings(
model="text-embedding-3-small" # ์ต์ ์๋ฒ ๋ฉ ๋ชจ๋ธ
)
# ๋ฒกํฐ ์คํ ์ด ์์ฑ ๋ฐ ๋ฌธ์ ์ ์ฅ
vectorstore = Chroma.from_documents(
documents=splits,
embedding=embeddings,
persist_directory="./chroma_db" # ๋ก์ปฌ์ ์ ์ฅ
)
print("๋ฒกํฐ ์คํ ์ด ์์ฑ ์๋ฃ! ๐")
print(f"์ด {vectorstore._collection.count()}๊ฐ์ ๋ฒกํฐ๊ฐ ์ ์ฅ๋์์ต๋๋ค.")
ChromaDB๋ ์คํ์์ค ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ธ๋ฐ, ๋ก์ปฌ์์ ๋๋ฆด ์ ์์ด์ ๊ฐ๋ฐํ ๋ ์์ ํธํด์. ํ๋ก๋์ ์์๋ Pinecone์ด๋ Weaviate ๊ฐ์ ๊ฑธ ์ฐ๋ ๊ฒ ์ข์ง๋ง, ์ผ๋จ ๋ฐฐ์ฐ๋ ๋จ๊ณ์์๋ Chroma๊ฐ ์ต๊ณ ์ฃ ใ ใ ใ
Pinecone - ํด๋ผ์ฐ๋ ๊ธฐ๋ฐ, ํ์ฅ์ฑ ์ข์, ์ ๋ฃ
Weaviate - ์คํ์์ค, ์์ฒด ํธ์คํ ๊ฐ๋ฅ, ๊ธฐ๋ฅ ๋ง์
FAISS - Facebook์ด ๋ง๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ๋น ๋ฆ, ํด๋ผ์ฐ๋ ๊ธฐ๋ฅ ์์
Milvus - ์ํฐํ๋ผ์ด์ฆ๊ธ, ๋์ฉ๋ ์ฒ๋ฆฌ ๊ฐ์
# ๋ฒกํฐ ์คํ ์ด ๊ฒ์ ํ
์คํธ
query = "ํ์ฌ์ ํด๊ฐ ์ ์ฑ
์ ์ด๋ป๊ฒ ๋๋์?"
docs = vectorstore.similarity_search(query, k=3)
print(f"\n์ง๋ฌธ: {query}")
print("\n=== ๊ฒ์ ๊ฒฐ๊ณผ ===")
for i, doc in enumerate(docs):
print(f"\n[๋ฌธ์ {i+1}]")
print(f"๋ด์ฉ: {doc.page_content[:200]}...")
print(f"์ถ์ฒ: {doc.metadata.get('source', 'Unknown')}, ํ์ด์ง: {doc.metadata.get('page', 'N/A')}")
๐ Retriever์ Chain ๊ตฌ์ฑ - ์ง์ง ๋ง๋ฒ์ด ์์๋๋ ๊ณณ
์ด์ ๊ฒ์๊ธฐ(Retriever)๋ฅผ ๋ง๋ค๊ณ , LLM๊ณผ ์ฐ๊ฒฐํด์ ์ค์ ๋ก ์ง๋ฌธ์ ๋ต๋ณํ๋ ์์คํ ์ ๊ตฌ์ถํ ๊ฑฐ์์. ์ฌ๊ธฐ์๋ถํฐ๊ฐ ์ง์ง ์ฌ๋ฐ์ด์ ใ ใ ใ ๐ช
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
# LLM ์ด๊ธฐํ
llm = ChatOpenAI(
model_name="gpt-4o-mini", # ๋๋ gpt-4
temperature=0.3 # ์ฐฝ์์ฑ vs ์ผ๊ด์ฑ ์กฐ์
)
# Retriever ์์ฑ
retriever = vectorstore.as_retriever(
search_type="similarity", # ์ ์ฌ๋ ๊ฒ์
search_kwargs={"k": 4} # ์์ 4๊ฐ ๋ฌธ์ ๊ฒ์
)
# ์ปค์คํ
ํ๋กฌํํธ ํ
ํ๋ฆฟ
template = """๋น์ ์ ํ์ฌ ๋ด๋ถ ๋ฌธ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ต๋ณํ๋ AI ๋น์์
๋๋ค.
์ฃผ์ด์ง ์ปจํ
์คํธ๋ฅผ ๋ฐํ์ผ๋ก ์ ํํ๊ณ ์น์ ํ๊ฒ ๋ต๋ณํด์ฃผ์ธ์.
๋ง์ฝ ์ปจํ
์คํธ์ ๋ต์ด ์๋ค๋ฉด, "์ ๊ณต๋ ๋ฌธ์์์ ํด๋น ์ ๋ณด๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค"๋ผ๊ณ ๋ต๋ณํ์ธ์.
์ปจํ
์คํธ: {context}
์ง๋ฌธ: {question}
๋ต๋ณ:"""
PROMPT = PromptTemplate(
template=template,
input_variables=["context", "question"]
)
# RetrievalQA ์ฒด์ธ ์์ฑ
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # ๋ชจ๋ ๋ฌธ์๋ฅผ ํ ๋ฒ์ ๋ฃ๋ ๋ฐฉ์
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": PROMPT}
)
print("QA ์ฒด์ธ ์์ฑ ์๋ฃ! ์ด์ ์ง๋ฌธ์ ๋ฐ์ ์ค๋น๊ฐ ๋์ด์ ๐")
map_reduce - ๊ฐ ๋ฌธ์๋ฅผ ๊ฐ๋ณ ์ฒ๋ฆฌ ํ ๊ฒฐ๊ณผ ํตํฉ. ๋ง์ ๋ฌธ์ ์ฒ๋ฆฌ ๊ฐ๋ฅ
refine - ์์ฐจ์ ์ผ๋ก ๋ต๋ณ์ ๊ฐ์ . ์ ํ๋ ๋์ง๋ง ๋๋ฆผ
map_rerank - ๊ฐ ๋ฌธ์๋ณ ๋ต๋ณ์ ์ ์ ๋งค๊ฒจ์ ์ต๊ณ ์ ์ ์ ํ
# ์ค์ ์ง๋ฌธ ํ
์คํธ
questions = [
"์ฐ์ฐจ ํด๊ฐ๋ ๋ช ์ผ์ธ๊ฐ์?",
"์ฌํ๊ทผ๋ฌด ์ ์ฑ
์ ๋ํด ์๋ ค์ฃผ์ธ์",
"ํ์ฌ ๋ณต์ง ์ ๋๋ ์ด๋ค ๊ฒ ์๋์?"
]
for question in questions:
print(f"\n{'='*50}")
print(f"์ง๋ฌธ: {question}")
print(f"{'='*50}")
result = qa_chain.invoke({"query": question})
print(f"\n๋ต๋ณ: {result['result']}")
print(f"\n์ฐธ๊ณ ๋ฌธ์:")
for i, doc in enumerate(result['source_documents']):
print(f" [{i+1}] {doc.metadata.get('source', 'Unknown')} - ํ์ด์ง {doc.metadata.get('page', 'N/A')}")
โข 0์ ๊ฐ๊น์ธ์๋ก โ ์ผ๊ด๋๊ณ ์์ธก ๊ฐ๋ฅํ ๋ต๋ณ (์ฌ์ค ๊ธฐ๋ฐ QA์ ์ ํฉ)
โข 2์ ๊ฐ๊น์ธ์๋ก โ ์ฐฝ์์ ์ด๊ณ ๋ค์ํ ๋ต๋ณ (๋ธ๋ ์ธ์คํ ๋ฐ์ ์ ํฉ)
๋ณดํต RAG ์์คํ ์์๋ 0.1~0.3 ์ ๋๊ฐ ์ ๋นํด์!
๐จ ๊ณ ๊ธ ๊ธฐ๋ฅ - ๋ํ ๊ธฐ๋ก ์ ์งํ๊ธฐ
์ง๊ธ๊น์ง ๋ง๋ ๊ฑด ์ผํ์ฑ ์ง๋ฌธ-๋ต๋ณ ์์คํ ์ด์์. ๊ทผ๋ฐ ์ง์ง ๋น์์ฒ๋ผ ๋ง๋ค๋ ค๋ฉด ๋ํ ๋งฅ๋ฝ์ ๊ธฐ์ตํด์ผ๊ฒ ์ฃ ? ์ด์ ๋ํ ๋ด์ฉ์ ๊ธฐ์ตํ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณผ๊ฒ์ ๐ง
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
# ๋ํ ๊ธฐ๋ก ์ ์ฅ์ฉ ๋ฉ๋ชจ๋ฆฌ
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
output_key="answer"
)
# ๋ํํ Retrieval ์ฒด์ธ
conversational_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory,
return_source_documents=True,
verbose=True # ๋๋ฒ๊น
์ฉ
)
# ๋ํ ์๋ฎฌ๋ ์ด์
print("=== ๋ํํ AI ๋น์ ํ
์คํธ ===\n")
# ์ฒซ ๋ฒ์งธ ์ง๋ฌธ
response1 = conversational_chain.invoke({
"question": "์ฐ๋ฆฌ ํ์ฌ ์ฐ์ฐจ๋ ๋ช ์ผ์ธ๊ฐ์?"
})
print(f"์ฌ์ฉ์: ์ฐ๋ฆฌ ํ์ฌ ์ฐ์ฐจ๋ ๋ช ์ผ์ธ๊ฐ์?")
print(f"AI: {response1['answer']}\n")
# ๋ ๋ฒ์งธ ์ง๋ฌธ (์ด์ ๋งฅ๋ฝ ์ฐธ์กฐ)
response2 = conversational_chain.invoke({
"question": "๊ทธ๋ผ ์ ์
์ฌ์๋ ๋์ผํ๊ฐ์?"
})
print(f"์ฌ์ฉ์: ๊ทธ๋ผ ์ ์
์ฌ์๋ ๋์ผํ๊ฐ์?")
print(f"AI: {response2['answer']}\n")
# ์ธ ๋ฒ์งธ ์ง๋ฌธ (๋ ์ด์ ๋งฅ๋ฝ๊น์ง ์ฐธ์กฐ)
response3 = conversational_chain.invoke({
"question": "๊ทธ ์ฐ์ฐจ๋ฅผ ์ธ์ ๋ถํฐ ์ฌ์ฉํ ์ ์์ฃ ?"
})
print(f"์ฌ์ฉ์: ๊ทธ ์ฐ์ฐจ๋ฅผ ์ธ์ ๋ถํฐ ์ฌ์ฉํ ์ ์์ฃ ?")
print(f"AI: {response3['answer']}")
ConversationBufferWindowMemory - ์ต๊ทผ N๊ฐ ๋ํ๋ง ์ ์ฅ
ConversationSummaryMemory - ๋ํ๋ฅผ ์์ฝํด์ ์ ์ฅ, ํ ํฐ ์ ์ฝ
ConversationSummaryBufferMemory - ์ต๊ทผ ๋ํ๋ ๊ทธ๋๋ก, ์ค๋๋ ๊ฑด ์์ฝ
VectorStoreBackedMemory - ๋ฒกํฐ DB์ ์ ์ฅ, ๊ด๋ จ ๋ํ๋ง ๊ฒ์
๐ ์ค์ ์ต์ ํ ํ ํฌ๋
์ด์ ๊ธฐ๋ณธ์ ๋ค ๋ฐฐ์ ์ผ๋๊น, ์ค์ ์์ ์ธ ์ ์๋ ์ต์ ํ ๊ธฐ๋ฒ๋ค์ ์๋ ค๋๋ฆด๊ฒ์. ์ด๊ฑฐ ์๊ณ ๋ชจ๋ฅด๊ณ ์ ์ฐจ์ด๊ฐ ์์ฒญ๋์ ใ ใ ใ
๋ฒกํฐ ๊ฒ์๋ง ์ฐ๋ฉด ํค์๋ ๋งค์นญ์ด ์ฝํด์. BM25 ๊ฐ์ ํค์๋ ๊ฒ์๊ณผ ๊ฒฐํฉํ๋ฉด ์ ํ๋๊ฐ ํ ์ฌ๋ผ๊ฐ์!
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
# BM25 ํค์๋ ๊ฒ์๊ธฐ
bm25_retriever = BM25Retriever.from_documents(splits)
bm25_retriever.k = 4
# ๋ฒกํฐ ๊ฒ์๊ธฐ
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
# ์์๋ธ ๊ฒ์๊ธฐ (๋ ๋ฐฉ์ ๊ฒฐํฉ)
ensemble_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, vector_retriever],
weights=[0.4, 0.6] # ๋ฒกํฐ ๊ฒ์์ ๋ ๋์ ๊ฐ์ค์น
)
# ์ด์ ensemble_retriever๋ฅผ ์ฒด์ธ์ ์ฌ์ฉ
hybrid_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=ensemble_retriever,
memory=memory
)
ํน์ ๋ถ์, ๋ ์ง, ์นดํ ๊ณ ๋ฆฌ ๋ฌธ์๋ง ๊ฒ์ํ๊ณ ์ถ์ ๋ ์ ์ฉํด์!
# ๋ฉํ๋ฐ์ดํฐ ์ถ๊ฐํด์ ๋ฌธ์ ์ ์ฅ
from datetime import datetime
for split in splits:
split.metadata["department"] = "HR"
split.metadata["date"] = "2024-01-15"
split.metadata["category"] = "policy"
# ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ง ๊ฒ์
filtered_retriever = vectorstore.as_retriever(
search_kwargs={
"k": 4,
"filter": {
"department": "HR",
"category": "policy"
}
}
)
๊ฒ์๋ ๋ฌธ์๋ฅผ ๋ค์ ํ๋ฒ ์ ๋ ฌํด์ ๊ฐ์ฅ ๊ด๋ จ์ฑ ๋์ ๊ฒ๋ง LLM์ ์ ๋ฌํด์.
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
# LLM ๊ธฐ๋ฐ ์์ถ๊ธฐ
compressor = LLMChainExtractor.from_llm(llm)
# ์์ถ ๊ฒ์๊ธฐ
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor,
base_retriever=vector_retriever
)
# ์ด์ ๋ ์ ํํ ๋ฌธ์๋ง ๊ฐ์ ธ์์!
compressed_docs = compression_retriever.get_relevant_documents(
"์ฐ์ฐจ ํด๊ฐ ์ ์ฑ
"
)
๊ฐ์ ์ง๋ฌธ์ด ๋ฐ๋ณต๋๋ฉด ์บ์์์ ๋ฐ๋ก ๋ต๋ณํด์. API ํธ์ถ ์ค์ด๊ณ ์๋๋ ๋นจ๋ผ์ ธ์!
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
# ์บ์ ์ค์
set_llm_cache(InMemoryCache())
# ์ด์ ๊ฐ์ ์ง๋ฌธ์ ์บ์์์ ์ฆ์ ์๋ต!
# ์ฒซ ๋ฒ์งธ ํธ์ถ - API ํธ์ถ (๋๋ฆผ)
result1 = qa_chain.invoke({"query": "์ฐ์ฐจ๋ ๋ช ์ผ์ธ๊ฐ์?"})
# ๋ ๋ฒ์งธ ํธ์ถ - ์บ์์์ ์๋ต (๋น ๋ฆ!)
result2 = qa_chain.invoke({"query": "์ฐ์ฐจ๋ ๋ช ์ผ์ธ๊ฐ์?"})
๐ง ์ค์ ํ๋ก์ ํธ ๊ตฌ์กฐ ์์
์ค์ ํ๋ก์ ํธ์์๋ ์ฝ๋๋ฅผ ๋ชจ๋ํํด์ ๊ด๋ฆฌํด์ผ ํด์. ์ ๊ฐ ์ถ์ฒํ๋ ๊ตฌ์กฐ๋ฅผ ๋ณด์ฌ๋๋ฆด๊ฒ์ ๐
rag_chatbot/
โ
โโโ .env # API ํค ๋ฑ ํ๊ฒฝ๋ณ์
โโโ requirements.txt # ์์กด์ฑ ํจํค์ง
โโโ config.py # ์ค์ ํ์ผ
โ
โโโ data/ # ์๋ณธ ๋ฌธ์
โ โโโ pdfs/
โ โโโ docs/
โ โโโ txts/
โ
โโโ vectorstore/ # ๋ฒกํฐ DB ์ ์ฅ์
โ โโโ chroma_db/
โ
โโโ src/
โ โโโ __init__.py
โ โโโ document_loader.py # ๋ฌธ์ ๋ก๋ฉ ๋ก์ง
โ โโโ embeddings.py # ์๋ฒ ๋ฉ ์์ฑ
โ โโโ retriever.py # ๊ฒ์๊ธฐ ์ค์
โ โโโ chain.py # ์ฒด์ธ ๊ตฌ์ฑ
โ โโโ utils.py # ์ ํธ๋ฆฌํฐ ํจ์
โ
โโโ app.py # ๋ฉ์ธ ์ ํ๋ฆฌ์ผ์ด์
โโโ streamlit_app.py # Streamlit UI (์ ํ์ฌํญ)
# config.py ์์
import os
from dotenv import load_dotenv
load_dotenv()
class Config:
# API ์ค์
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
# ๋ชจ๋ธ ์ค์
LLM_MODEL = "gpt-4o-mini"
EMBEDDING_MODEL = "text-embedding-3-small"
TEMPERATURE = 0.3
# ๊ฒ์ ์ค์
CHUNK_SIZE = 1000
CHUNK_OVERLAP = 200
SEARCH_K = 4
# ๋ฒกํฐ ์คํ ์ด ์ค์
VECTORSTORE_PATH = "./vectorstore/chroma_db"
# ๋ฉ๋ชจ๋ฆฌ ์ค์
MAX_HISTORY_LENGTH = 10
# document_loader.py ์์
from langchain_community.document_loaders import (
PyPDFLoader,
TextLoader,
DirectoryLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from config import Config
class DocumentProcessor:
def __init__(self):
self.text_splitter = RecursiveCharacterTextSplitter(
chunk_size=Config.CHUNK_SIZE,
chunk_overlap=Config.CHUNK_OVERLAP
)
def load_pdfs(self, directory_path):
"""PDF ํ์ผ๋ค์ ๋ก๋ฉ"""
loader = DirectoryLoader(
directory_path,
glob="**/*.pdf",
loader_cls=PyPDFLoader
)
documents = loader.load()
return self.text_splitter.split_documents(documents)
def load_texts(self, directory_path):
"""ํ
์คํธ ํ์ผ๋ค์ ๋ก๋ฉ"""
loader = DirectoryLoader(
directory_path,
glob="**/*.txt",
loader_cls=TextLoader
)
documents = loader.load()
return self.text_splitter.split_documents(documents)
๐จ Streamlit์ผ๋ก UI ๋ง๋ค๊ธฐ
CLI๋ก๋ง ์ฐ๊ธฐ์ ์ข ๊ทธ๋ ์ฃ ? Streamlit์ผ๋ก ๊ฐ๋จํ ์น UI ๋ง๋ค์ด๋ณผ๊ฒ์. ์ง์ง 5๋ถ์ด๋ฉด ๋ผ์ ใ ใ ใ
# streamlit_app.py
import streamlit as st
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from config import Config
# ํ์ด์ง ์ค์
st.set_page_config(
page_title="AI ๋ฌธ์ ๋น์",
page_icon="๐ค",
layout="wide"
)
# ์ ๋ชฉ
st.title("๐ค AI ๋ฌธ์ ๊ฒ์ ๋น์")
st.markdown("---")
# ์ธ์
์ํ ์ด๊ธฐํ
if "messages" not in st.session_state:
st.session_state.messages = []
if "chain" not in st.session_state:
# ์ฒด์ธ ์ด๊ธฐํ
embeddings = OpenAIEmbeddings(model=Config.EMBEDDING_MODEL)
vectorstore = Chroma(
persist_directory=Config.VECTORSTORE_PATH,
embedding_function=embeddings
)
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
output_key="answer"
)
llm = ChatOpenAI(
model_name=Config.LLM_MODEL,
temperature=Config.TEMPERATURE
)
st.session_state.chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=vectorstore.as_retriever(search_kwargs={"k": Config.SEARCH_K}),
memory=memory,
return_source_documents=True
)
# ์ฑํ
๊ธฐ๋ก ํ์
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# ์ฌ์ฉ์ ์
๋ ฅ
if prompt := st.chat_input("์ง๋ฌธ์ ์
๋ ฅํ์ธ์..."):
# ์ฌ์ฉ์ ๋ฉ์์ง ์ถ๊ฐ
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
# AI ์๋ต ์์ฑ
with st.chat_message("assistant"):
with st.spinner("์๊ฐ ์ค..."):
response = st.session_state.chain.invoke({"question": prompt})
answer = response["answer"]
sources = response["source_documents"]
st.markdown(answer)
# ์ถ์ฒ ํ์
if sources:
with st.expander("๐ ์ฐธ๊ณ ๋ฌธ์"):
for i, doc in enumerate(sources):
st.markdown(f"**[{i+1}]** {doc.metadata.get('source', 'Unknown')}")
st.caption(doc.page_content[:200] + "...")
# AI ๋ฉ์์ง ์ถ๊ฐ
st.session_state.messages.append({"role": "assistant", "content": answer})
# ์ฌ์ด๋๋ฐ
with st.sidebar:
st.header("โ๏ธ ์ค์ ")
st.markdown(f"**๋ชจ๋ธ:** {Config.LLM_MODEL}")
st.markdown(f"**Temperature:** {Config.TEMPERATURE}")
st.markdown(f"**๊ฒ์ ๋ฌธ์ ์:** {Config.SEARCH_K}")
if st.button("๐๏ธ ๋ํ ๊ธฐ๋ก ์ญ์ "):
st.session_state.messages = []
st.session_state.chain.memory.clear()
st.rerun()
# ์คํ ๋ฐฉ๋ฒ
streamlit run streamlit_app.py
์ด๋ ๊ฒ ํ๋ฉด ๋ธ๋ผ์ฐ์ ์์ ๋ฐ๋ก ์ฑํ ํ๋ฉด์ ํ ์คํธํ ์ ์์ด์! ์์ ๊ฐ๋จํ์ฃ ? ใ ใ ใ
โก ์ฑ๋ฅ ์ต์ ํ์ ๋น์ฉ ๊ด๋ฆฌ
์ค์ ์๋น์ค์ ๋ฐฐํฌํ๋ฉด ์ฑ๋ฅ๊ณผ ๋น์ฉ์ด ์ง์ง ์ค์ํด์ ธ์. ๋ช ๊ฐ์ง ๊ฟํ ์๋ ค๋๋ฆด๊ฒ์ ๐ฐ
text-embedding-3-small์ด large๋ณด๋ค 5๋ฐฐ ์ ๋ ดํด์. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ small์ผ๋ก ์ถฉ๋ถ!
2. ์บ์ฑ ์ ๊ทน ํ์ฉ
Redis๋ Memcached๋ก ์์ฃผ ๋ฌป๋ ์ง๋ฌธ ์บ์ฑํ๋ฉด API ํธ์ถ 80% ์ด์ ์ค์ผ ์ ์์ด์.
3. ๋ฐฐ์น ์ฒ๋ฆฌ
๋ฌธ์ ์๋ฒ ๋ฉ ์์ฑํ ๋ ๋ฐฐ์น๋ก ์ฒ๋ฆฌํ๋ฉด ๋น์ฉ ์ ๊ฐ ๊ฐ๋ฅ.
4. ํ ํฐ ์ ํ
max_tokens ํ๋ผ๋ฏธํฐ๋ก ์๋ต ๊ธธ์ด ์ ํํ๋ฉด ๋ถํ์ํ ๋น์ฉ ๋ฐฉ์ง.
5. ์ ๋ ดํ ๋ชจ๋ธ ํ์ฉ
๊ฐ๋จํ ์์ ์ gpt-3.5-turbo, ๋ณต์กํ ์์ ๋ง gpt-4 ์ฌ์ฉ
# ๋น์ฉ ์ต์ ํ ์ค์ ์์
from langchain.callbacks import get_openai_callback
# ํ ํฐ ์ฌ์ฉ๋ ์ถ์
with get_openai_callback() as cb:
response = qa_chain.invoke({"query": "์ฐ์ฐจ ์ ์ฑ
์?"})
print(f"์ด ํ ํฐ: {cb.total_tokens}")
print(f"ํ๋กฌํํธ ํ ํฐ: {cb.prompt_tokens}")
print(f"์๋ฃ ํ ํฐ: {cb.completion_tokens}")
print(f"์ด ๋น์ฉ: ${cb.total_cost:.4f}")
# ํ ํฐ ์ ํ ์ค์
llm = ChatOpenAI(
model_name="gpt-4o-mini",
temperature=0.3,
max_tokens=500 # ์๋ต ๊ธธ์ด ์ ํ
)
# ๊ฒ์ ๋ฌธ์ ์ ์ต์ ํ
retriever = vectorstore.as_retriever(
search_kwargs={
"k": 3 # 4๊ฐ ๋์ 3๊ฐ๋ก ์ค์ด๋ฉด ํ ํฐ ์ ์ฝ
}
)
โข ๋น๋๊ธฐ ์ฒ๋ฆฌ - asyncio๋ก ์ฌ๋ฌ ๊ฒ์ ๋์ ์ฒ๋ฆฌ
โข ๋ฌธ์ ์ ์ฒ๋ฆฌ - ๋ถํ์ํ ๊ณต๋ฐฑ, ํน์๋ฌธ์ ์ ๊ฑฐ๋ก ์๋ฒ ๋ฉ ํ์ง ํฅ์
โข ๋ก๋ ๋ฐธ๋ฐ์ฑ - ์ฌ๋ฌ API ํค ๋กํ ์ด์ ์ผ๋ก Rate Limit ํํผ
โข ์คํธ๋ฆฌ๋ฐ ์๋ต - ๊ธด ๋ต๋ณ์ ์คํธ๋ฆฌ๋ฐ์ผ๋ก ์ฌ์ฉ์ ๊ฒฝํ ๊ฐ์
# ์คํธ๋ฆฌ๋ฐ ์๋ต ์์
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
llm = ChatOpenAI(
model_name="gpt-4o-mini",
temperature=0.3,
streaming=True,
callbacks=[StreamingStdOutCallbackHandler()]
)
# ์ด์ ๋ต๋ณ์ด ์์ฑ๋๋ ๋๋ก ์ค์๊ฐ์ผ๋ก ์ถ๋ ฅ๋ผ์!
response = qa_chain.invoke({"query": "ํ์ฌ ๋ณต์ง ์ ๋ ์ค๋ช
ํด์ค"})
๐ ์์ฃผ ๋ง๋๋ ์๋ฌ์ ํด๊ฒฐ๋ฒ
๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์๋ฌ ์ง์ง ๋ง์ด ๋ง๋์ฃ ใ ใ ใ ์ ๊ฐ ๊ฒช์๋ ์ฃผ์ ์๋ฌ๋ค๊ณผ ํด๊ฒฐ๋ฒ ์ ๋ฆฌํด๋๋ฆด๊ฒ์!
ํด๊ฒฐ:
โข ์์ฒญ ๊ฐ time.sleep() ์ถ๊ฐ
โข ๋ฐฐ์น ํฌ๊ธฐ ์ค์ด๊ธฐ
โข ์ ๋ฃ ํ๋์ผ๋ก ์ ๊ทธ๋ ์ด๋
โข ์ฌ๋ฌ API ํค ๋กํ ์ด์
ํด๊ฒฐ:
โข chunk_size ์ค์ด๊ธฐ
โข ๊ฒ์ ๋ฌธ์ ์(k) ์ค์ด๊ธฐ
โข map_reduce chain type ์ฌ์ฉ
โข ๊ธด ๋ํ ๊ธฐ๋ก ์์ฝ ๋๋ ์ญ์
ํด๊ฒฐ:
โข ๊ธฐ์กด ์ปฌ๋ ์ ์ญ์ ํ ์ฌ์์ฑ
โข ๋ค๋ฅธ ์ปฌ๋ ์ ์ด๋ฆ ์ฌ์ฉ
โข get_or_create ๋ฉ์๋ ์ฌ์ฉ
# ์๋ฌ ์ฒ๋ฆฌ ์์
import time
from openai import RateLimitError
def safe_query(chain, question, max_retries=3):
"""์ฌ์๋ ๋ก์ง์ด ํฌํจ๋ ์์ ํ ์ฟผ๋ฆฌ ํจ์"""
for attempt in range(max_retries):
try:
response = chain.invoke({"query": question})
return response
except RateLimitError:
if attempt < max_retries - 1:
wait_time = (attempt + 1) * 2 # ์ง์ ๋ฐฑ์คํ
print(f"Rate limit ๋๋ฌ. {wait_time}์ด ๋๊ธฐ ์ค...")
time.sleep(wait_time)
else:
raise
except Exception as e:
print(f"์๋ฌ ๋ฐ์: {str(e)}")
if attempt < max_retries - 1:
time.sleep(1)
else:
raise
# ์ฌ์ฉ ์์
try:
result = safe_query(qa_chain, "์ฐ์ฐจ ์ ์ฑ
์?")
print(result["answer"])
except Exception as e:
print(f"์ต์ข
์คํจ: {str(e)}")
๐ ๋ณด์๊ณผ ํ๋ผ์ด๋ฒ์ ๊ณ ๋ ค์ฌํญ
ํ์ฌ ๋ด๋ถ ๋ฌธ์ ๋ค๋ฃจ๋ ๊ฑฐ๋๊น ๋ณด์ ์ง์ง ์ค์ํด์! ์ด๊ฑฐ ๋์น๋ฉด ํฐ์ผ ๋์ ๐ฑ
โข ํ๊ฒฝ๋ณ์ ์ฌ์ฉ, ์ ๋ ์ฝ๋์ ํ๋์ฝ๋ฉ ๊ธ์ง
โข .env ํ์ผ .gitignore์ ์ถ๊ฐ
โข ํ๋ก๋์ ์์๋ AWS Secrets Manager ๊ฐ์ ์๋น์ค ์ฌ์ฉ
โ ๋ฐ์ดํฐ ์ํธํ
โข ๋ฒกํฐ DB ์ ์ฅ ์ ์ํธํ
โข ์ ์ก ์ค ๋ฐ์ดํฐ๋ HTTPS ์ฌ์ฉ
โข ๋ฏผ๊ฐ ์ ๋ณด๋ ๋ง์คํน ์ฒ๋ฆฌ
โ ์ ๊ทผ ์ ์ด
โข ์ฌ์ฉ์ ์ธ์ฆ/์ธ๊ฐ ๊ตฌํ
โข ๋ถ์๋ณ, ๊ถํ๋ณ ๋ฌธ์ ์ ๊ทผ ์ ํ
โข ๊ฐ์ฌ ๋ก๊ทธ ๊ธฐ๋ก
โ ๋ฐ์ดํฐ ๋ณด์กด
โข ๊ฐ์ธ์ ๋ณด ํฌํจ ๋ฌธ์๋ ๋ณด์กด ๊ธฐ๊ฐ ์ค์
โข ์ ๊ธฐ์ ์ธ ๋ฐ์ดํฐ ์ญ์ ์ ์ฑ
โข GDPR, ๊ฐ์ธ์ ๋ณด๋ณดํธ๋ฒ ์ค์
# ๋ฏผ๊ฐ ์ ๋ณด ๋ง์คํน ์์
import re
def mask_sensitive_info(text):
"""๋ฏผ๊ฐ ์ ๋ณด ๋ง์คํน ํจ์"""
# ์ฃผ๋ฏผ๋ฑ๋ก๋ฒํธ ๋ง์คํน
text = re.sub(r'\d{6}-\d{7}', '******-*******', text)
# ์ด๋ฉ์ผ ๋ง์คํน
text = re.sub(r'[\w\.-]+@[\w\.-]+', '***@***.com', text)
# ์ ํ๋ฒํธ ๋ง์คํน
text = re.sub(r'\d{2,3}-\d{3,4}-\d{4}', '***-****-****', text)
# ์นด๋๋ฒํธ ๋ง์คํน
text = re.sub(r'\d{4}-\d{4}-\d{4}-\d{4}', '****-****-****-****', text)
return text
# ๋ฌธ์ ์ ์ฒ๋ฆฌ ์ ์ ์ฉ
for doc in documents:
doc.page_content = mask_sensitive_info(doc.page_content)
๐ ์ค์ ํ์ฉ ์ฌ๋ก
์ด๋ก ๋ง ๋ฐฐ์ฐ๋ฉด ์ฌ๋ฏธ์์์์? ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉ๋๋์ง ์ฌ๋ก ๋ช ๊ฐ ๋ณด์ฌ๋๋ฆด๊ฒ์ ๐ฏ
์ ํ ๋งค๋ด์ผ, FAQ, ์ด์ ์๋ด ๋ด์ญ์ ํ์ตํด์ 24/7 ๊ณ ๊ฐ ์๋. ์๋ด์ฌ ์ ๋ฌด ๋ถ๋ด 70% ๊ฐ์ ํจ๊ณผ!
ํ์ฌ ๊ท์ , ์ ๋ฌด ๋งค๋ด์ผ, ํ๋ก์ ํธ ๋ฌธ์ ๊ฒ์. ์ ์ ์ฌ์ ์จ๋ณด๋ฉ ์๊ฐ 50% ๋จ์ถ. ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ ์์คํ ๊ตฌ์ถ ์ฌ๋ฅ์ ๊ฑฐ๋ํ ์ ์์ด์!
ํ๋ก, ๋ฒ๋ น, ๊ณ์ฝ์ ๊ฒ์ ๋ฐ ๋ถ์. ๋ณํธ์ฌ๋ค์ ๋ฆฌ์์น ์๊ฐ 60% ์ ๊ฐ.
์ํ ๋ ผ๋ฌธ, ์ง๋ฃ ๊ฐ์ด๋๋ผ์ธ ๊ฒ์. ์์ฌ๋ค์ ์์ฌ๊ฒฐ์ ์ง์ (์ง๋จ/์ฒ๋ฐฉ ์๋!).
์์ฒ ๊ฐ์ ๋ ผ๋ฌธ์์ ๊ด๋ จ ์ฐ๊ตฌ ์ฐพ๊ณ ์์ฝ. ์ฐ๊ตฌ์๋ค์ ๋ฌธํ ์กฐ์ฌ ์๊ฐ ๋ํญ ๋จ์ถ.
๐ ๋ค์ ๋จ๊ณ - ๋ ๋ฐ์ ์ํค๊ธฐ
๊ธฐ๋ณธ์ ๋ค ๋ฐฐ์ ์ผ๋ ์ด์ ๋ ๊ณ ๊ธ ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํด๋ณผ ์ฐจ๋ก์์! ๐
ํ ์คํธ๋ฟ๋ง ์๋๋ผ ์ด๋ฏธ์ง, ํ, ๊ทธ๋ํ๋ ์ดํดํ๋ ์์คํ . GPT-4 Vision ํ์ฉ!
2. Agent ๊ธฐ๋ฐ ์์คํ
์ฌ๋ฌ ๋๊ตฌ(์น ๊ฒ์, ๊ณ์ฐ๊ธฐ, ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฑ)๋ฅผ ์์จ์ ์ผ๋ก ์ฌ์ฉํ๋ AI ์์ด์ ํธ.
3. ๋ค๊ตญ์ด ์ง์
ํ๊ตญ์ด, ์์ด, ์ผ๋ณธ์ด ๋ฑ ์ฌ๋ฌ ์ธ์ด ๋ฌธ์ ํตํฉ ๊ฒ์.
4. ์ค์๊ฐ ์ ๋ฐ์ดํธ
์ ๋ฌธ์ ์ถ๊ฐ๋๋ฉด ์๋์ผ๋ก ๋ฒกํฐ DB ์ ๋ฐ์ดํธ.
5. ํผ๋๋ฐฑ ๋ฃจํ
์ฌ์ฉ์ ํผ๋๋ฐฑ ๋ฐ์์ ๊ฒ์ ํ์ง ์ง์์ ์ผ๋ก ๊ฐ์ .
6. ์์ฑ ์ธํฐํ์ด์ค
Whisper API๋ก ์์ฑ ์ง๋ฌธ ๋ฐ๊ณ , TTS๋ก ๋ต๋ณ ์ถ๋ ฅ.
# Agent ์์ (๊ฐ๋จ ๋ฒ์ )
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
# ๋๊ตฌ ์ ์
tools = [
Tool(
name="Document Search",
func=qa_chain.invoke,
description="ํ์ฌ ๋ด๋ถ ๋ฌธ์๋ฅผ ๊ฒ์ํ ๋ ์ฌ์ฉ. ์ง๋ฌธ์ ์
๋ ฅ์ผ๋ก ๋ฐ์."
),
Tool(
name="Calculator",
func=lambda x: eval(x),
description="์ํ ๊ณ์ฐ์ด ํ์ํ ๋ ์ฌ์ฉ. ์์์ ์
๋ ฅ์ผ๋ก ๋ฐ์."
)
]
# Agent ์ด๊ธฐํ
agent = initialize_agent(
tools=tools,
llm=llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
# Agent ์คํ
result = agent.run("์ฐ์ฐจ๊ฐ 15์ผ์ธ๋ฐ, ์ด๋ฏธ 5์ผ ์ผ์ด. ๋จ์ ์ฐ์ฐจ๋?")
print(result)
๐ ์ฑ๋ฅ ์ธก์ ๊ณผ ํ๊ฐ
๋ง๋ค๊ธฐ๋ง ํ๊ณ ๋์ด ์๋์์! ์ผ๋ง๋ ์ ์๋ํ๋์ง ์ธก์ ํด์ผ์ฃ . ํ๊ฐ ์งํ ์๋ ค๋๋ฆด๊ฒ์ ๐
โข Answer Relevance - ๋ต๋ณ์ด ์ง๋ฌธ๊ณผ ์ผ๋ง๋ ๊ด๋ จ์๋๊ฐ?
โข Faithfulness - ๋ต๋ณ์ด ๊ฒ์๋ ๋ฌธ์์ ์ถฉ์คํ๊ฐ? (ํ๊ฐ ๋ฐฉ์ง)
โข Response Time - ๋ต๋ณ ์์ฑ ์๋
โข User Satisfaction - ์ฌ์ฉ์ ๋ง์กฑ๋ (ํผ๋๋ฐฑ ๊ธฐ๋ฐ)
# ํ๊ฐ ๋ฐ์ดํฐ์
์์
evaluation_dataset = [
{
"question": "์ฐ์ฐจ๋ ๋ช ์ผ์ธ๊ฐ์?",
"expected_answer": "15์ผ",
"relevant_docs": ["hr_policy.pdf"]
},
{
"question": "์ฌํ๊ทผ๋ฌด ๊ฐ๋ฅํ๊ฐ์?",
"expected_answer": "์ฃผ 2ํ ๊ฐ๋ฅ",
"relevant_docs": ["work_policy.pdf"]
}
]
# ๊ฐ๋จํ ํ๊ฐ ํจ์
def evaluate_rag_system(chain, dataset):
results = []
for item in dataset:
response = chain.invoke({"query": item["question"]})
# ๋ต๋ณ ๊ด๋ จ์ฑ ์ฒดํฌ (๊ฐ๋จ ๋ฒ์ )
answer_contains_expected = item["expected_answer"].lower() in response["answer"].lower()
# ๊ฒ์ ์ ํ๋ ์ฒดํฌ
retrieved_sources = [doc.metadata.get("source") for doc in response["source_documents"]]
retrieval_correct = any(doc in retrieved_sources for doc in item["relevant_docs"])
results.append({
"question": item["question"],
"answer_relevant": answer_contains_expected,
"retrieval_correct": retrieval_correct
})
# ์ ์ฒด ์ ํ๋ ๊ณ์ฐ
answer_accuracy = sum(r["answer_relevant"] for r in results) / len(results)
retrieval_accuracy = sum(r["retrieval_correct"] for r in results) / len(results)
print(f"๋ต๋ณ ์ ํ๋: {answer_accuracy:.2%}")
print(f"๊ฒ์ ์ ํ๋: {retrieval_accuracy:.2%}")
return results
# ํ๊ฐ ์คํ
eval_results = evaluate_rag_system(qa_chain, evaluation_dataset)
๐ ํ์ต ๋ฆฌ์์ค์ ์ปค๋ฎค๋ํฐ
ํผ์ ๊ณต๋ถํ๊ธฐ ํ๋ค์ฃ ? ๋์ ๋ฐ์ ์ ์๋ ๊ณณ๋ค ์ ๋ฆฌํด๋๋ฆด๊ฒ์ ๐
โข LangChain ๊ณต์ ๋ฌธ์ (python.langchain.com)
โข OpenAI API ๋ฌธ์ (platform.openai.com/docs)
์จ๋ผ์ธ ๊ฐ์
โข DeepLearning.AI - LangChain ๊ฐ์ข
โข Udemy - RAG ์์คํ ๊ตฌ์ถ ์ค์
์ปค๋ฎค๋ํฐ
โข LangChain Discord
โข Reddit r/LangChain
โข Stack Overflow
๋ธ๋ก๊ทธ/๋ด์ค๋ ํฐ
โข LangChain ๊ณต์ ๋ธ๋ก๊ทธ
โข Towards Data Science
โข The Batch (Andrew Ng)
โข "RAG ์์คํ ๊ตฌ์ถ ์ปจ์คํ "
โข "๋ง์ถคํ AI ์ฑ๋ด ๊ฐ๋ฐ"
โข "LangChain ํ๋ก์ ํธ ๋ฉํ ๋ง"
๊ฐ์ ์ฌ๋ฅ์ ๋ฑ๋กํด์ ์์ต๋ ์ฐฝ์ถํ๊ณ , ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ง์๋ ๋๋ ๋ณด์ธ์ ใ ใ ใ
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์... ์ฌ๊ธฐ๊น์ง ์ฝ์ผ์
จ๋ค๋ฉด ์ง์ง ๋๋จํ์ธ์! ๐๐๐
ํ์ด์ฌ๊ณผ LangChain์ผ๋ก ๊ฒ์ ๊ธฐ๋ฐ AI ๋น์๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ, ์ฒ์๋ถํฐ ๋๊น์ง ๋ค ์๋ ค๋๋ ธ์ด์. ๋ฌธ์ ๋ก๋ฉ๋ถํฐ ์๋ฒ ๋ฉ, ๋ฒกํฐ ๊ฒ์, ์ฒด์ธ ๊ตฌ์ฑ, UI ๋ง๋ค๊ธฐ, ์ต์ ํ, ๋ณด์๊น์ง... ์ง์ง ์์ฐจ๊ฒ ๋ด์์ฃ ? ใ
ใ
ใ
์์งํ ์ฒ์์๋ ์ด๋ ค์ ๋ณด์ผ ์ ์์ด์. ๊ทผ๋ฐ ํ๋์ฉ ๋ฐ๋ผํ๋ค ๋ณด๋ฉด "์ด? ์๊ฐ๋ณด๋ค ํ ๋งํ๋ฐ?" ํ๋ ์๊ฐ์ด ์์. ๊ทธ๋์ ํฌ์ด์ด ์ง์ง ์ง๋ฆฟํ๊ฑฐ๋ ์ ๐
์ค์ํ ๊ฑด ์ผ๋จ ์์ํ๋ ๊ฑฐ์์. ์๋ฒฝํ ์ฝ๋ ์ง๋ ค๊ณ ํ์ง ๋ง๊ณ , ์ผ๋จ ๋์๊ฐ๋ ๊ฑฐ ๋ง๋ค์ด๋ณด์ธ์. ๊ทธ๋ค์์ ์กฐ๊ธ์ฉ ๊ฐ์ ํ๋ฉด ๋ผ์. ์๋ฌ ๋๋ ๋นํฉํ์ง ๋ง๊ณ ๊ตฌ๊ธ๋งํ๋ฉด์ ํ๋์ฉ ํด๊ฒฐํด๋๊ฐ๋ฉด ๋ฉ๋๋ค!
AI ๊ธฐ์ ์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด์. LangChain๋ ์
๋ฐ์ดํธ๊ฐ ์์ฒญ ๋น ๋ฅด๊ณ , ์๋ก์ด ๊ธฐ๋ฅ๋ค์ด ๊ณ์ ๋์ค๊ณ ์์ฃ . ๊ทธ๋ฌ๋๊น ์ด ๊ธ์ ๊ธฐ๋ฐ์ผ๋ก ๊ณ์ ๊ณต๋ถํ๊ณ ์คํํด๋ณด์ธ์. ๊ณต์ ๋ฌธ์๋ ์์ฃผ ํ์ธํ๊ณ ์!
๋ง์ง๋ง์ผ๋ก, ํผ์ ํ๊ธฐ ํ๋ค๋ฉด ์ปค๋ฎค๋ํฐ์ ๋์์ ๋ฐ์ผ์ธ์. ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋ฉํ ๋ฅผ ์ฐพ๊ฑฐ๋, ๋ฐ๋๋ก ์ฌ๋ฌ๋ถ์ด ๋ฐฐ์ด ๊ฑธ ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ ์๋ ค์ฃผ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์์. ๊ฐ๋ฅด์น๋ค ๋ณด๋ฉด ๋ ๊น์ด ์ดํดํ๊ฒ ๋๊ฑฐ๋ ์ ๐
์, ์ด์ ์ฌ๋ฌ๋ถ ์ฐจ๋ก์์! ์ด ๊ธ ๋ซ๊ณ ๋ฐ๋ก ์ฝ๋ ์๋ํฐ ์ผ์ ์ฒซ RAG ์์คํ
๋ง๋ค์ด๋ณด์ธ์. ํ์ดํ
! ๐๐ช
๐ฏ ํต์ฌ ์์ฝ
1. RAG๋ ๊ฒ์ + ์์ฑ์ ๊ฒฐํฉํ ๊ฐ๋ ฅํ AI ์์คํ
2. LangChain์ผ๋ก ๋ณต์กํ ์ํฌํ๋ก์ฐ๋ฅผ ๊ฐ๋จํ๊ฒ ๊ตฌํ
3. ๋ฌธ์ ๋ก๋ฉ โ ์ฒญํน โ ์๋ฒ ๋ฉ โ ๋ฒกํฐ ์ ์ฅ โ ๊ฒ์ โ ๋ต๋ณ ์์ฑ
4. ์ต์ ํ์ ๋ณด์์ ์์ง ๋ง ๊ฒ
5. ์ค์ ๊ฒฝํ์ด ๊ฐ์ฅ ์ค์! ์ผ๋จ ๋ง๋ค์ด๋ณด๊ธฐ ๐ฅ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.