Ver3.5 LangChain + Chroma로로컬 검색형 챗봇 구축하기

LangChain + Chroma로
로컬 검색형 챗봇 구축하기
야, 솔직히 말해봐. ChatGPT한테 회사 내부 문서 올려서 질문하고 싶었던 적 없어? 😅
근데 보안 때문에 못 하잖아. 개인정보도 걱정되고, 기업 기밀도 있고...
그래서 오늘은 완전히 로컬에서 돌아가는 검색형 챗봇을 직접 만드는 방법을 알려줄게!
핵심 기술은 딱 두 가지야.
LangChain — AI 앱 개발의 레고 블록 같은 프레임워크
Chroma — 로컬에서 돌아가는 벡터 데이터베이스
이 둘을 조합하면 RAG(Retrieval-Augmented Generation) 방식의 챗봇이 완성돼.
RAG가 뭔지 모른다고? 걱정 마, 지금부터 차근차근 설명해줄게. 커피 한 잔 들고 편하게 읽어봐 ☕
🧩 RAG가 뭔데? 왜 필요해?
일반 ChatGPT는 학습 데이터 기반으로만 답해. 그래서 네 회사 내부 문서, 개인 노트, 최신 데이터는 전혀 모르지.
RAG는 이 문제를 해결하는 방식이야.
쉽게 말하면: "AI한테 오픈북 시험 보게 해주는 것" 😄
시험 볼 때 교재 펼쳐놓고 답 찾는 것처럼, AI도 관련 문서를 찾아보고 답하는 거야.
왜 벡터 DB가 필요한가?
일반 검색은 키워드 매칭이야. "사과"를 검색하면 "사과"가 있는 문서만 나오지.
근데 벡터 검색은 의미 기반 검색이야. "과일"을 검색해도 "사과", "배", "포도" 관련 문서가 나와.
이게 가능한 이유는 텍스트를 임베딩(Embedding)이라는 숫자 벡터로 변환해서 저장하기 때문이야.
예: "안녕하세요" → [0.23, -0.87, 0.45, 0.12, ...]
의미가 비슷한 문장은 벡터 공간에서 가까이 위치해.
그래서 "유사도 검색"이 가능한 거야!
⚙️ 개발 환경 세팅하기
자, 이제 진짜 시작해보자! 먼저 필요한 것들을 설치해야 해.
Python 3.9 이상이 설치되어 있다고 가정할게. 없으면 먼저 설치해와! 🐍
필수 패키지 설치
pip install langchain langchain-community langchain-core
pip install chromadb
pip install sentence-transformers
pip install pypdf docx2txt
pip install ollama
langchain, langchain-community, langchain-core가 분리되어 있어.설치 후 버전 확인:
pip show langchain
로컬 LLM 설치 (Ollama)
완전 로컬 환경을 위해 Ollama를 사용할 거야.
Ollama는 LLM을 로컬에서 쉽게 실행할 수 있게 해주는 도구야.
ollama.ai에서 OS에 맞는 버전 다운로드 후 설치
ollama pull llama3.2
ollama pull nomic-embed-text
llama3.2는 답변 생성용, nomic-embed-text는 임베딩용이야.
ollama serve
기본적으로 http://localhost:11434에서 실행돼.
llama3.2 (3B 파라미터) 기준으로 CPU에서도 충분히 사용 가능해.
GPU가 있다면 훨씬 빠르게 동작하지!
📂 문서 로드 & 청크 분할
이제 실제 코드를 작성해보자! 먼저 문서를 불러오고 적절한 크기로 잘라야 해.
왜 잘라야 하냐고? LLM은 한 번에 처리할 수 있는 텍스트 양(컨텍스트 윈도우)이 제한되어 있거든.
다양한 문서 로더 사용하기
from langchain_community.document_loaders import (
PyPDFLoader,
TextLoader,
DirectoryLoader,
UnstructuredMarkdownLoader,
CSVLoader
)
# PDF 파일 로드
pdf_loader = PyPDFLoader("./docs/manual.pdf")
pdf_docs = pdf_loader.load()
# 텍스트 파일 로드
txt_loader = TextLoader("./docs/notes.txt", encoding="utf-8")
txt_docs = txt_loader.load()
# 폴더 전체 로드 (PDF 파일들)
dir_loader = DirectoryLoader(
"./docs/",
glob="**/*.pdf",
loader_cls=PyPDFLoader
)
all_docs = dir_loader.load()
print(f"총 {len(all_docs)}개 페이지 로드 완료!")
텍스트 청크 분할
문서를 적절한 크기로 잘라야 해. 너무 크면 LLM이 처리 못하고, 너무 작으면 문맥이 끊겨.
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, # 각 청크의 최대 글자 수
chunk_overlap=50, # 청크 간 겹치는 글자 수 (문맥 보존)
length_function=len,
separators=["\n\n", "\n", ".", " ", ""] # 분할 우선순위
)
# 문서 분할
chunks = text_splitter.split_documents(all_docs)
print(f"총 {len(chunks)}개 청크 생성!")
# 청크 확인
for i, chunk in enumerate(chunks[:3]):
print(f"\n--- 청크 {i+1} ---")
print(f"내용: {chunk.page_content[:100]}...")
print(f"메타데이터: {chunk.metadata}")
chunk_size: 800~1200 — 긴 문서, 문맥 보존 중요 시
chunk_overlap: 10~20% — 청크 크기의 10~20% 정도가 적당
처음엔 chunk_size=500, chunk_overlap=50으로 시작해서 결과 보면서 조정해봐!
🗄️ Chroma 벡터 DB 구축하기
이제 핵심이야! 청크들을 임베딩으로 변환해서 Chroma에 저장할 거야.
이 과정이 끝나면 의미 기반 검색이 가능해져!
임베딩 모델 설정 & Chroma 저장
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
# 로컬 임베딩 모델 설정 (Ollama 사용)
embeddings = OllamaEmbeddings(
model="nomic-embed-text",
base_url="http://localhost:11434"
)
# Chroma 벡터 DB 생성 및 저장
# persist_directory: 로컬 디스크에 영구 저장
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory="./chroma_db",
collection_name="my_documents"
)
print("✅ 벡터 DB 구축 완료!")
print(f"저장된 벡터 수: {vectorstore._collection.count()}")
기존 Chroma DB 불러오기
한 번 만들어두면 다음엔 그냥 불러오면 돼. 다시 임베딩할 필요 없어!
# 기존 DB 로드 (재실행 시)
vectorstore = Chroma(
persist_directory="./chroma_db",
embedding_function=embeddings,
collection_name="my_documents"
)
print(f"기존 DB 로드 완료! 벡터 수: {vectorstore._collection.count()}")
유사도 검색 테스트
# 유사도 검색 테스트
query = "환불 정책이 어떻게 되나요?"
results = vectorstore.similarity_search(query, k=3)
for i, doc in enumerate(results):
print(f"\n--- 검색 결과 {i+1} ---")
print(f"내용: {doc.page_content}")
print(f"출처: {doc.metadata.get('source', '알 수 없음')}")
# 유사도 점수와 함께 검색
results_with_score = vectorstore.similarity_search_with_score(query, k=3)
for doc, score in results_with_score:
print(f"유사도 점수: {score:.4f} | {doc.page_content[:80]}...")
점수가 낮을수록 더 유사한 거야 (거리 개념이라서).
0에 가까울수록 완벽히 유사, 2에 가까울수록 완전히 다른 내용이야.
문서 추가 & 삭제
from langchain.schema import Document
# 새 문서 추가
new_docs = [
Document(
page_content="2024년 신규 정책: 반품 기간이 30일로 연장되었습니다.",
metadata={"source": "policy_update_2024.txt", "date": "2024-01"}
)
]
vectorstore.add_documents(new_docs)
# 특정 문서 삭제 (ID 기반)
# vectorstore.delete(ids=["doc_id_1", "doc_id_2"])
🔗 LangChain으로 RAG 체인 구성하기
드디어 메인 이벤트야! LangChain으로 검색 → 답변 생성 파이프라인을 연결할 거야.
LangChain의 LCEL(LangChain Expression Language)을 사용하면 파이프라인 구성이 정말 직관적이야.
기본 RAG 체인 구성
from langchain_community.llms import Ollama
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser
# 로컬 LLM 설정
llm = Ollama(
model="llama3.2",
base_url="http://localhost:11434",
temperature=0.1, # 낮을수록 일관된 답변
num_predict=512 # 최대 생성 토큰 수
)
# 리트리버 설정 (검색기)
retriever = vectorstore.as_retriever(
search_type="similarity", # 유사도 검색
search_kwargs={"k": 4} # 상위 4개 문서 검색
)
# 프롬프트 템플릿
prompt = ChatPromptTemplate.from_template("""
당신은 주어진 문서를 기반으로 질문에 답하는 AI 어시스턴트입니다.
아래 컨텍스트를 참고하여 정확하고 도움이 되는 답변을 제공하세요.
컨텍스트에 없는 내용은 "해당 정보를 찾을 수 없습니다"라고 답하세요.
컨텍스트:
{context}
질문: {question}
답변:""")
# 문서 포맷팅 함수
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
# RAG 체인 구성 (LCEL 방식)
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# 실행!
question = "환불 정책이 어떻게 되나요?"
answer = rag_chain.invoke(question)
print(f"답변: {answer}")
retriever | format_docs → 질문으로 관련 문서 검색 후 텍스트로 변환RunnablePassthrough() → 질문을 그대로 통과시킴| prompt → 컨텍스트 + 질문을 프롬프트에 삽입| llm → LLM이 답변 생성| StrOutputParser() → 출력을 문자열로 파싱| 연산자로 체인을 연결하는 게 LCEL의 핵심이야. 직관적이지?
스트리밍 응답 구현
ChatGPT처럼 글자가 하나씩 나오는 스트리밍 효과를 구현해보자!
# 스트리밍으로 답변 받기
print("답변: ", end="", flush=True)
for chunk in rag_chain.stream(question):
print(chunk, end="", flush=True)
print() # 줄바꿈
대화 히스토리 추가 (멀티턴 챗봇)
이전 대화를 기억하는 챗봇을 만들려면 메모리를 추가해야 해!
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationalRetrievalChain
# 대화 메모리 (최근 5턴 기억)
memory = ConversationBufferWindowMemory(
k=5,
memory_key="chat_history",
return_messages=True,
output_key="answer"
)
# 대화형 RAG 체인
conv_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory,
return_source_documents=True, # 참조 문서도 반환
verbose=False
)
# 대화 실행
def chat(question):
result = conv_chain({"question": question})
answer = result["answer"]
sources = result.get("source_documents", [])
print(f"🤖 답변: {answer}")
print(f"\n📚 참조 문서:")
for doc in sources[:2]:
print(f" - {doc.metadata.get('source', '알 수 없음')}")
return answer
# 대화 테스트
chat("환불 정책이 어떻게 되나요?")
chat("그럼 교환은요?") # 이전 대화 맥락 유지!
🚀 완성된 챗봇 앱 만들기
이제 모든 조각을 합쳐서 실제로 사용할 수 있는 챗봇을 만들어보자!
CLI 버전과 간단한 웹 버전 두 가지를 보여줄게.
전체 코드 통합 (chatbot.py)
import os
from pathlib import Path
from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import Ollama
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser
class LocalRAGChatbot:
def __init__(
self,
docs_dir: str = "./docs",
db_dir: str = "./chroma_db",
embed_model: str = "nomic-embed-text",
llm_model: str = "llama3.2"
):
self.docs_dir = docs_dir
self.db_dir = db_dir
# 임베딩 모델
self.embeddings = OllamaEmbeddings(
model=embed_model,
base_url="http://localhost:11434"
)
# LLM
self.llm = Ollama(
model=llm_model,
base_url="http://localhost:11434",
temperature=0.1
)
# 벡터 DB 초기화
self.vectorstore = self._init_vectorstore()
# RAG 체인 구성
self.chain = self._build_chain()
# 대화 히스토리
self.chat_history = []
def _init_vectorstore(self):
"""벡터 DB 초기화 또는 로드"""
db_path = Path(self.db_dir)
if db_path.exists() and any(db_path.iterdir()):
print("📂 기존 벡터 DB 로드 중...")
return Chroma(
persist_directory=self.db_dir,
embedding_function=self.embeddings,
collection_name="my_documents"
)
else:
print("🔨 새 벡터 DB 구축 중...")
return self._build_vectorstore()
def _build_vectorstore(self):
"""문서 로드 → 청크 분할 → 임베딩 → Chroma 저장"""
# 문서 로드
loaders = []
docs_path = Path(self.docs_dir)
for pdf_file in docs_path.glob("**/*.pdf"):
loaders.append(PyPDFLoader(str(pdf_file)))
for txt_file in docs_path.glob("**/*.txt"):
loaders.append(TextLoader(str(txt_file), encoding="utf-8"))
all_docs = []
for loader in loaders:
all_docs.extend(loader.load())
print(f"📄 {len(all_docs)}개 문서 로드 완료")
# 청크 분할
splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50
)
chunks = splitter.split_documents(all_docs)
print(f"✂️ {len(chunks)}개 청크 생성 완료")
# Chroma 저장
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=self.embeddings,
persist_directory=self.db_dir,
collection_name="my_documents"
)
print("✅ 벡터 DB 구축 완료!")
return vectorstore
def _build_chain(self):
"""RAG 체인 구성"""
retriever = self.vectorstore.as_retriever(
search_type="mmr", # MMR: 다양성 보장 검색
search_kwargs={"k": 4, "fetch_k": 10}
)
prompt = ChatPromptTemplate.from_template("""
당신은 친절하고 정확한 AI 어시스턴트입니다.
주어진 컨텍스트를 바탕으로 질문에 답하세요.
컨텍스트에 없는 내용은 솔직하게 모른다고 하세요.
이전 대화:
{chat_history}
컨텍스트:
{context}
질문: {question}
답변:""")
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
def format_history(history):
if not history:
return "없음"
return "\n".join([
f"사용자: {h['human']}\nAI: {h['ai']}"
for h in history[-3:] # 최근 3턴만
])
chain = (
{
"context": retriever | format_docs,
"question": RunnablePassthrough(),
"chat_history": lambda _: format_history(self.chat_history)
}
| prompt
| self.llm
| StrOutputParser()
)
return chain
def chat(self, question: str, stream: bool = True) -> str:
"""챗봇과 대화"""
print(f"\n🤖 답변: ", end="", flush=True)
full_answer = ""
if stream:
for chunk in self.chain.stream(question):
print(chunk, end="", flush=True)
full_answer += chunk
else:
full_answer = self.chain.invoke(question)
print(full_answer)
print() # 줄바꿈
# 히스토리 저장
self.chat_history.append({
"human": question,
"ai": full_answer
})
return full_answer
def add_documents(self, file_paths: list):
"""새 문서 추가"""
new_docs = []
for path in file_paths:
if path.endswith(".pdf"):
loader = PyPDFLoader(path)
else:
loader = TextLoader(path, encoding="utf-8")
new_docs.extend(loader.load())
splitter = RecursiveCharacterTextSplitter(
chunk_size=500, chunk_overlap=50
)
chunks = splitter.split_documents(new_docs)
self.vectorstore.add_documents(chunks)
print(f"✅ {len(chunks)}개 청크 추가 완료!")
# 메인 실행
if __name__ == "__main__":
# 챗봇 초기화
bot = LocalRAGChatbot(
docs_dir="./docs",
db_dir="./chroma_db"
)
print("\n" + "="*50)
print("🤖 로컬 RAG 챗봇 시작!")
print("종료하려면 'quit' 또는 'exit' 입력")
print("="*50)
while True:
user_input = input("\n👤 질문: ").strip()
if not user_input:
continue
if user_input.lower() in ["quit", "exit", "종료"]:
print("챗봇을 종료합니다. 안녕히 계세요! 👋")
break
bot.chat(user_input)
Gradio로 웹 UI 추가하기
CLI도 좋지만 웹 UI가 있으면 훨씬 편하지! Gradio로 빠르게 만들어보자.
pip install gradio
import gradio as gr
# 챗봇 초기화
bot = LocalRAGChatbot()
def respond(message, history):
"""Gradio 챗봇 응답 함수"""
answer = bot.chat(message, stream=False)
return answer
# Gradio 인터페이스
demo = gr.ChatInterface(
fn=respond,
title="🤖 로컬 RAG 챗봇",
description="내 문서를 기반으로 답변하는 완전 로컬 AI 챗봇",
examples=[
"환불 정책이 어떻게 되나요?",
"제품 보증 기간은 얼마인가요?",
"고객센터 연락처를 알려주세요"
],
theme=gr.themes.Soft()
)
demo.launch(
server_name="0.0.0.0",
server_port=7860,
share=False # True로 하면 외부 접속 가능 (임시 URL 생성)
)
http://localhost:7860 접속!완전히 로컬에서 돌아가는 ChatGPT 같은 인터페이스가 나타나.
⚡ 성능 최적화 & 고급 기능
기본 챗봇은 완성됐어! 이제 더 똑똑하게 만들어보자. 🧠
MMR 검색으로 다양성 확보
일반 유사도 검색은 비슷한 내용의 청크를 중복으로 가져올 수 있어.
MMR(Maximal Marginal Relevance)은 관련성과 다양성을 동시에 고려해!
retriever = vectorstore.as_retriever(
search_type="mmr",
search_kwargs={
"k": 4, # 최종 반환 문서 수
"fetch_k": 20, # 후보 문서 수 (많을수록 다양성 증가)
"lambda_mult": 0.5 # 0=다양성 최대, 1=유사도 최대
}
)
Self-Query Retriever (메타데이터 필터링)
"2024년 문서에서만 찾아줘" 같은 조건 검색이 가능해!
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.chains.query_constructor.base import AttributeInfo
# 메타데이터 스키마 정의
metadata_field_info = [
AttributeInfo(
name="source",
description="문서 파일명",
type="string"
),
AttributeInfo(
name="page",
description="페이지 번호",
type="integer"
),
AttributeInfo(
name="date",
description="문서 날짜 (YYYY-MM 형식)",
type="string"
)
]
# Self-Query Retriever 생성
self_query_retriever = SelfQueryRetriever.from_llm(
llm=llm,
vectorstore=vectorstore,
document_contents="회사 정책 및 제품 매뉴얼",
metadata_field_info=metadata_field_info,
verbose=True
)
# 사용 예시
# "2024년 환불 정책 알려줘" → 자동으로 date="2024" 필터 적용!
앙상블 리트리버 (하이브리드 검색)
벡터 검색 + BM25 키워드 검색을 합쳐서 더 정확하게!
from langchain.retrievers import BM25Retriever, EnsembleRetriever
# BM25 키워드 검색기
bm25_retriever = BM25Retriever.from_documents(chunks)
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] # BM25 40%, 벡터 60%
)
BM25 검색 — 키워드 기반, 고유명사·코드·숫자에 강함
앙상블 — 두 방식의 장점을 합침, 일반적으로 가장 좋은 성능
실제 프로덕션에서는 앙상블 방식을 추천해!
Reranker로 검색 품질 향상
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
# Cross-Encoder 리랭커 (로컬)
model = HuggingFaceCrossEncoder(
model_name="BAAI/bge-reranker-base"
)
compressor = CrossEncoderReranker(model=model, top_n=3)
# 리랭킹 리트리버
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor,
base_retriever=ensemble_retriever
)
# 검색 → 리랭킹 → 상위 3개만 LLM에 전달
🔧 자주 겪는 문제 & 해결법
개발하다 보면 꼭 막히는 부분들이 있어. 미리 알아두면 시간 절약이 돼! ⏰
ConnectionRefusedError: [Errno 111] Connection refused✅ 해결: Ollama 서버가 실행 중인지 확인
ollama serve # 터미널에서 실행
ollama list # 설치된 모델 확인
llama3.2는 영어 중심 모델이라 한국어 품질이 낮을 수 있어.
✅ 해결: 한국어 특화 모델 사용
ollama pull EEVE-Korean-10.8B # 한국어 특화
ollama pull qwen2.5:7b # 다국어 지원 우수
또는 프롬프트에 "반드시 한국어로 답변하세요" 추가!
큰 모델 실행 시 RAM/VRAM 부족
✅ 해결: 더 작은 모델 사용
ollama pull llama3.2:1b # 1B 파라미터 (가장 가벼움)
ollama pull phi3:mini # Microsoft Phi-3 Mini
✅ 해결 체크리스트:
1. 청크 크기 조정 (너무 크거나 작지 않게)
2. k 값 증가 (더 많은 문서 검색)
3. 임베딩 모델 변경
4. 프롬프트 개선 (컨텍스트 활용 강조)
ValueError: Chroma collection already exists✅ 해결:
import shutil
shutil.rmtree("./chroma_db") # DB 삭제 후 재생성
또는 collection_name을 다르게 설정
💼 실전 활용 사례
이 기술로 뭘 만들 수 있을까? 실제로 많이 쓰이는 케이스들을 소개할게!
프리랜서 개발자들이 기업 고객을 위한 맞춤형 로컬 RAG 챗봇 구축 서비스를 제공하고 있어.
특히 보안이 중요한 법무법인, 병원, 금융기관에서 수요가 높아지고 있지!
🌐 배포 & 운영 팁
Docker로 패키징하기
팀원들과 공유하거나 서버에 배포할 때 Docker를 사용하면 편해!
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 7860
CMD ["python", "app.py"]
# docker-compose.yml
version: '3.8'
services:
chatbot:
build: .
ports:
- "7860:7860"
volumes:
- ./docs:/app/docs
- ./chroma_db:/app/chroma_db
environment:
- OLLAMA_BASE_URL=http://ollama:11434
ollama:
image: ollama/ollama
ports:
- "11434:11434"
volumes:
- ollama_data:/root/.ollama
volumes:
ollama_data:
성능 모니터링
import time
from functools import wraps
def timing_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
elapsed = time.time() - start
print(f"⏱️ {func.__name__} 실행 시간: {elapsed:.2f}초")
return result
return wrapper
# 검색 성능 측정
@timing_decorator
def search_test(query):
return vectorstore.similarity_search(query, k=4)
# 전체 응답 시간 측정
@timing_decorator
def chat_test(question):
return rag_chain.invoke(question)
벡터 검색 — 10만 개 벡터 기준 약 0.01~0.1초
LLM 답변 생성 — CPU에서 약 10~60초 (GPU는 1~5초)
GPU가 있다면 전체 응답 시간을 5초 이내로 줄일 수 있어!
🎯 핵심 정리 & 다음 단계
오늘 배운 내용을 정리해보자!
① LangGraph로 더 복잡한 에이전트 구축
② Fine-tuning으로 도메인 특화 모델 만들기
③ Multi-modal RAG (이미지 + 텍스트 검색)
④ GraphRAG로 지식 그래프 기반 검색
⑤ FastAPI로 REST API 서버 구축
LangChain + Chroma 조합은 로컬 AI 개발의 황금 조합이야.
보안이 중요한 환경, 인터넷이 없는 환경, 비용을 아끼고 싶은 환경 모두에서 최고의 선택이지.
재능넷에서도 이런 기술을 활용한 프리랜서 프로젝트들이 활발하게 올라오고 있으니 참고해봐!
처음엔 복잡해 보여도, 한 단계씩 따라하다 보면 어느새 완성되어 있을 거야.
직접 만들어보는 게 최고의 학습이야! 화이팅! 💪
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.