4. 다양한 임베딩 모델 비교 🔍

임베딩 모델에 따라 성능이 달라져. 몇 가지 추천 모델을 소개할게:

모델 변경은 간단해:

embeddings = HuggingFaceEmbeddings(
    model_name="jhgan/ko-sroberta-multitask",  # 모델명만 바꾸면 돼!
    model_kwargs={'device': 'cpu'}
)

5. 스트리밍 응답 구현하기 ⚡

ChatGPT처럼 답변이 실시간으로 나타나게 만들 수 있어:

from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

# 스트리밍 콜백 설정
llm = Ollama(
    model="llama2",
    callbacks=[StreamingStdOutCallbackHandler()],
    temperature=0.7
)

# 이제 답변이 한 글자씩 실시간으로 출력돼!
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

시스템을 만들었으면 이제 빠르고 효율적으로 만들어야지! 실전 최적화 팁을 알려줄게. 🚀

1. GPU 활용하기 🎮

NVIDIA GPU가 있다면 반드시 활용해야 해! 속도가 10배 이상 빨라질 수 있어.

# 임베딩 모델 GPU 사용
embeddings = HuggingFaceEmbeddings(
    model_name="jhgan/ko-sroberta-multitask",
    model_kwargs={'device': 'cuda'}  # CPU → CUDA로 변경
)

# Ollama도 자동으로 GPU 감지해서 사용해
# 확인하려면:
# nvidia-smi 명령어로 GPU 사용률 체크!

2. 벡터 저장소 최적화 💾

ChromaDB 말고 다른 벡터 DB도 시도해볼 수 있어:

# FAISS - 페이스북이 만든 고속 벡터 검색 라이브러리
from langchain.vectorstores import FAISS

vectorstore = FAISS.from_documents(
    documents=texts,
    embedding=embeddings
)

# 로컬에 저장
vectorstore.save_local("./faiss_index")

# 나중에 불러오기
vectorstore = FAISS.load_local(
    "./faiss_index",
    embeddings
)

3. 캐싱 전략 🗄️

같은 질문이 반복되면 매번 계산하지 말고 캐시를 활용하자:

from functools import lru_cache
import hashlib

# 질문 해시 생성
def hash_question(question):
    return hashlib.md5(question.encode()).hexdigest()

# 간단한 캐시 딕셔너리
answer_cache = {}

def ask_with_cache(question):
    q_hash = hash_question(question)
    
    # 캐시에 있으면 바로 반환
    if q_hash in answer_cache:
        print("💨 캐시에서 답변을 가져왔습니다!")
        return answer_cache[q_hash]
    
    # 없으면 새로 생성
    result = qa_chain({"query": question})
    answer_cache[q_hash] = result['result']
    
    return result['result']

4. 청크 크기 최적화 ✂️

청크 크기는 성능에 큰 영향을 미쳐. 실험을 통해 최적값을 찾아야 해:

# 실험용 함수
def test_chunk_sizes():
    sizes = [500, 1000, 1500, 2000]
    overlaps = [50, 100, 200, 300]
    
    for size in sizes:
        for overlap in overlaps:
            print(f"\n테스트: chunk_size={size}, overlap={overlap}")
            
            splitter = RecursiveCharacterTextSplitter(
                chunk_size=size,
                chunk_overlap=overlap
            )
            
            chunks = splitter.split_documents(documents)
            print(f"생성된 청크 수: {len(chunks)}")
            
            # 여기서 실제 질문 테스트하고 성능 측정
            # ...

# 일반적인 권장사항:
# - 기술 문서: 1000-1500 (상세한 설명 필요)
# - 뉴스/블로그: 500-800 (짧고 간결)
# - 코드: 2000-3000 (컨텍스트 많이 필요)
# - overlap은 chunk_size의 10-20% 정도

5. 배치 처리로 속도 올리기 ⚡

여러 문서를 한 번에 처리하면 더 빠를 수 있어:

# 문서를 배치로 나눠서 처리
def process_documents_in_batches(documents, batch_size=10):
    vectorstores = []
    
    for i in range(0, len(documents), batch_size):
        batch = documents[i:i+batch_size]
        print(f"배치 {i//batch_size + 1} 처리 중...")
        
        batch_texts = text_splitter.split_documents(batch)
        batch_vectorstore = Chroma.from_documents(
            documents=batch_texts,
            embedding=embeddings,
            persist_directory=f"./vectorstore_batch_{i}"
        )
        vectorstores.append(batch_vectorstore)
    
    return vectorstores

실전에서 사용하려면 안정성이 중요해! 에러 처리와 보안을 신경 써야 해. 🔒

1. 에러 처리 추가하기 ⚠️

import logging
from typing import Optional

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def safe_ask_question(question: str) -> Optional[str]:
    """안전한 질문 처리 함수"""
    try:
        # 입력 검증
        if not question or len(question.strip()) == 0:
            logger.warning("빈 질문이 입력되었습니다.")
            return "질문을 입력해주세요."
        
        if len(question) > 1000:
            logger.warning("질문이 너무 깁니다.")
            return "질문이 너무 깁니다. 1000자 이내로 입력해주세요."
        
        # 질문 처리
        logger.info(f"질문 처리 시작: {question[:50]}...")
        result = qa_chain({"query": question})
        logger.info("질문 처리 완료")
        
        return result['result']
        
    except Exception as e:
        logger.error(f"에러 발생: {str(e)}", exc_info=True)
        return "죄송합니다. 답변 생성 중 오류가 발생했습니다. 다시 시도해주세요."

# 연결 상태 확인
def check_ollama_connection():
    """Ollama 서버 연결 확인"""
    try:
        import requests
        response = requests.get("http://localhost:11434/api/tags")
        if response.status_code == 200:
            logger.info("✅ Ollama 서버 연결 성공")
            return True
        else:
            logger.error("❌ Ollama 서버 응답 이상")
            return False
    except Exception as e:
        logger.error(f"❌ Ollama 서버 연결 실패: {str(e)}")
        return False

# 시작 전 체크
if not check_ollama_connection():
    print("Ollama 서버를 먼저 시작해주세요!")
    print("터미널에서 'ollama serve' 실행")
    exit(1)

2. 입력 필터링 🔍

import re

def sanitize_input(text: str) -> str:
    """입력 텍스트 정제"""
    # 특수문자 제거 (필요한 것만 남김)
    text = re.sub(r'[^\w\s가-힣.,!?-]', '', text)
    
    # 연속된 공백 제거
    text = re.sub(r'\s+', ' ', text)
    
    # 앞뒤 공백 제거
    text = text.strip()
    
    return text

def is_safe_question(question: str) -> bool:
    """질문 안전성 검사"""
    # 금지어 목록
    forbidden_words = ['해킹', '크랙', '불법']
    
    question_lower = question.lower()
    for word in forbidden_words:
        if word in question_lower:
            logger.warning(f"금지어 감지: {word}")
            return False
    
    return True

# 사용 예시
def process_user_input(raw_input: str) -> str:
    # 1. 정제
    clean_input = sanitize_input(raw_input)
    
    # 2. 안전성 검사
    if not is_safe_question(clean_input):
        return "부적절한 질문입니다."
    
    # 3. 처리
    return safe_ask_question(clean_input)

3. 리소스 모니터링 📊

import psutil
import time

class ResourceMonitor:
    """시스템 리소스 모니터링"""
    
    def __init__(self):
        self.start_time = time.time()
        self.start_memory = psutil.Process().memory_info().rss / 1024 / 1024
    
    def get_stats(self):
        """현재 리소스 사용량 반환"""
        current_memory = psutil.Process().memory_info().rss / 1024 / 1024
        elapsed_time = time.time() - self.start_time
        
        return {
            'memory_mb': current_memory,
            'memory_increase_mb': current_memory - self.start_memory,
            'cpu_percent': psutil.cpu_percent(interval=1),
            'elapsed_seconds': elapsed_time
        }
    
    def print_stats(self):
        """통계 출력"""
        stats = self.get_stats()
        print(f"\n📊 리소스 사용 현황:")
        print(f"  메모리: {stats['memory_mb']:.1f} MB "
              f"(+{stats['memory_increase_mb']:.1f} MB)")
        print(f"  CPU: {stats['cpu_percent']:.1f}%")
        print(f"  실행 시간: {stats['elapsed_seconds']:.1f}초\n")

# 사용 예시
monitor = ResourceMonitor()

# 작업 수행
result = qa_chain({"query": "질문"})

# 통계 확인
monitor.print_stats()

터미널에서만 쓰기 아쉽지? 웹 인터페이스를 만들어보자! Gradio나 Streamlit을 사용하면 정말 쉬워. 😊

Gradio로 간단한 UI 만들기 🎨

pip install gradio

import gradio as gr

def gradio_interface(question, history):
    """Gradio 인터페이스 함수"""
    try:
        result = qa_chain({"query": question})
        answer = result['result']
        
        # 출처 정보 추가
        sources = "\n\n📚 참고 문서:\n"
        for i, doc in enumerate(result['source_documents'], 1):
            sources += f"{i}. {doc.metadata.get('source', '알 수 없음')}\n"
        
        return answer + sources
        
    except Exception as e:
        return f"오류가 발생했습니다: {str(e)}"

# Gradio 인터페이스 생성
demo = gr.ChatInterface(
    fn=gradio_interface,
    title="🤖 로컬 Q&A 시스템",
    description="Ollama + LangChain 기반 로컬 AI 챗봇입니다.",
    examples=[
        "이 문서의 주요 내용은 무엇인가요?",
        "Python에서 리스트를 정렬하는 방법은?",
        "재능넷에서 어떤 서비스를 제공하나요?"
    ],
    theme=gr.themes.Soft(),
    retry_btn="🔄 다시 시도",
    undo_btn="↩️ 되돌리기",
    clear_btn="🗑️ 대화 초기화"
)

# 실행
if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",  # 외부 접속 허용
        server_port=7860,
        share=False  # True로 하면 공개 URL 생성
    )

실행하면 브라우저에서 http://localhost:7860으로 접속할 수 있어! 정말 간단하지? 🎉

Streamlit으로 더 커스텀한 UI 만들기 🎯

pip install streamlit

import streamlit as st
from datetime import datetime

# 페이지 설정
st.set_page_config(
    page_title="로컬 Q&A 시스템",
    page_icon="🤖",
    layout="wide"
)

# 제목
st.title("🤖 로컬 Q&A 시스템")
st.markdown("*Ollama + LangChain 기반 AI 챗봇*")

# 사이드바
with st.sidebar:
    st.header("⚙️ 설정")
    
    # 모델 선택
    model = st.selectbox(
        "LLM 모델",
        ["llama2", "mistral", "phi"]
    )
    
    # 온도 설정
    temperature = st.slider(
        "창의성 (Temperature)",
        min_value=0.0,
        max_value=1.0,
        value=0.7,
        step=0.1
    )
    
    # 검색 문서 수
    k_docs = st.slider(
        "참고 문서 수",
        min_value=1,
        max_value=5,
        value=3
    )
    
    st.divider()
    
    # 통계
    st.header("📊 통계")
    if 'question_count' not in st.session_state:
        st.session_state.question_count = 0
    st.metric("총 질문 수", st.session_state.question_count)

# 메인 영역
col1, col2 = st.columns([2, 1])

with col1:
    st.header("💬 대화")
    
    # 대화 기록 초기화
    if 'messages' not in st.session_state:
        st.session_state.messages = []
    
    # 대화 기록 표시
    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("생각하는 중..."):
                try:
                    result = qa_chain({"query": prompt})
                    response = result['result']
                    
                    st.markdown(response)
                    
                    # 출처 표시
                    with st.expander("📚 참고 문서"):
                        for i, doc in enumerate(result['source_documents'], 1):
                            st.write(f"{i}. {doc.metadata.get('source', '알 수 없음')}")
                    
                    # 응답 저장
                    st.session_state.messages.append({
                        "role": "assistant",
                        "content": response
                    })
                    
                    # 통계 업데이트
                    st.session_state.question_count += 1
                    
                except Exception as e:
                    st.error(f"오류 발생: {str(e)}")

with col2:
    st.header("📖 도움말")
    
    st.markdown("""
    ### 사용 방법
    1. 왼쪽에서 모델과 설정을 조정하세요
    2. 아래 입력창에 질문을 입력하세요
    3. AI가 문서를 참고해서 답변합니다
    
    ### 예시 질문
    - 이 문서의 주요 내용은?
    - Python 리스트 사용법은?
    - 특정 개념에 대해 설명해줘
    
    ### 팁
    - 구체적으로 질문할수록 좋은 답변을 받아요
    - 이전 대화를 참고해서 답변해요
    - 출처 문서를 확인해보세요
    """)
    
    st.divider()
    
    # 시스템 상태
    st.header("🔧 시스템 상태")
    
    if check_ollama_connection():
        st.success("✅ Ollama 연결됨")
    else:
        st.error("❌ Ollama 연결 안 됨")
    
    # 리소스 사용량
    monitor = ResourceMonitor()
    stats = monitor.get_stats()
    
    st.metric("메모리 사용", f"{stats['memory_mb']:.0f} MB")
    st.metric("CPU 사용률", f"{stats['cpu_percent']:.1f}%")

실행은 간단해:

streamlit run app.py

브라우저가 자동으로 열리면서 멋진 UI가 나타날 거야! 🎨

이론은 충분히 배웠으니, 이제 실제로 어떻게 활용할 수 있는지 알아보자! 💡

1. 회사 내부 문서 Q&A 시스템 🏢

회사의 규정, 매뉴얼, 프로젝트 문서를 학습시켜서 직원들이 쉽게 정보를 찾을 수 있게 해:

# 회사 문서 구조
company_docs/
├── hr/              # 인사 규정
│   ├── 휴가규정.pdf
│   └── 복리후생.pdf
├── tech/            # 기술 문서
│   ├── API문서.md
│   └── 개발가이드.md
└── projects/        # 프로젝트 문서
    └── 프로젝트A.docx

# 특화된 프롬프트
company_template = """당신은 우리 회사의 AI 어시스턴트입니다.
직원들의 질문에 회사 문서를 기반으로 정확하게 답변해주세요.

규정이나 정책에 관한 질문이면 정확한 조항을 인용해주세요.
기술 문서 관련 질문이면 코드 예시를 포함해주세요.

컨텍스트: {context}
질문: {question}
답변:"""

2. 고객 지원 챗봇 💬

FAQ, 제품 매뉴얼, 이전 고객 문의 내역을 학습시켜서 자동 응답 시스템을 만들어:

# 고객 지원 특화 설정
support_template = """당신은 친절한 고객 지원 AI입니다.
고객의 문제를 해결하는 것이 목표입니다.

답변 시 다음을 지켜주세요:
1. 친절하고 공감하는 톤으로 답변
2. 단계별로 명확하게 설명
3. 추가 도움이 필요한지 물어보기
4. 해결 방법을 모르면 담당자 연결 안내

고객 질문: {question}
관련 정보: {context}

답변:"""

# 감정 분석 추가
from transformers import pipeline

sentiment_analyzer = pipeline(
    "sentiment-analysis",
    model="beomi/kcbert-base"
)

def analyze_customer_mood(question):
    """고객 감정 분석"""
    result = sentiment_analyzer(question)[0]
    
    if result['label'] == 'negative' and result['score'] > 0.8:
        return "고객이 불만족 상태입니다. 더 신중하게 답변하세요."
    return ""

3. 학습 도우미 📚

교재, 강의 자료, 참고 문헌을 학습시켜서 학생들의 공부를 도와줘:

# 교육용 프롬프트
education_template = """당신은 친절한 선생님 AI입니다.
학생이 개념을 이해할 수 있도록 쉽게 설명해주세요.

설명 방식:
1. 먼저 핵심 개념을 간단히 설명
2. 실생활 예시를 들어 설명
3. 단계별로 자세히 설명
4. 이해를 확인하는 질문 제시

학생 질문: {question}
교재 내용: {context}

답변:"""

# 난이도 조절 기능
def adjust_difficulty(question, user_level):
    """사용자 수준에 맞춰 답변 조절"""
    if user_level == "beginner":
        return "초등학생도 이해할 수 있게 아주 쉽게 설명해주세요."
    elif user_level == "intermediate":
        return "중학생 수준으로 설명해주세요."
    else:
        return "전문적인 용어를 사용해서 자세히 설명해주세요."

4. 코드 문서화 도우미 💻

프로젝트 코드베이스를 학습시켜서 개발자들이 코드를 이해하고 사용하도록 도와줘:

# 코드 특화 로더
from langchain.document_loaders import DirectoryLoader

code_loader = DirectoryLoader(
    './src',
    glob="**/*.py",
    loader_cls=TextLoader
)

# 코드 분석 프롬프트
code_template = """당신은 코드 리뷰어 AI입니다.
개발자의 질문에 코드를 분석해서 답변해주세요.

답변 형식:
1. 해당 코드의 위치와 목적
2. 코드 동작 방식 설명
3. 사용 예시 제공
4. 주의사항이나 개선점

질문: {question}
관련 코드: {context}

답변:"""

# 코드 하이라이팅
def format_code_response(response):
    """코드 부분을 마크다운 형식으로 변환"""
    import re
    
    # 코드 블록 감지 및 포맷팅
    code_pattern = r'```(\w+)?\n(.*?)```'
    formatted = re.sub(
        code_pattern,
        r'```\1\n\2```',
        response,
        flags=re.DOTALL
    )
    
    return formatted

5. 재능넷 맞춤 활용 🎯

재능넷 같은 플랫폼에서는 이렇게 활용할 수 있어:

# 재능넷 특화 예시
jaenung_template = """당신은 재능넷의 AI 어시스턴트입니다.
재능넷은 다양한 재능을 거래하는 플랫폼입니다.

사용자 질문에 다음 정보를 활용해서 답변하세요:
- 플랫폼 이용 방법
- 재능 카테고리 정보
- 전문가 프로필
- 이용 후기

질문: {question}
관련 정보: {context}

친절하고 도움이 되는 답변:"""

로컬 AI 기술은 정말 빠르게 발전하고 있어! 앞으로 어떻게 변할지 한번 살펴보자. 🚀

1. 모델 경량화 기술 📉

앞으로는 더 작고 빠른 모델들이 나올 거야. 이미 진행 중인 기술들:

2. 멀티모달 AI 🎨

텍스트만이 아니라 이미지, 음성, 비디오까지 처리하는 통합 AI가 나올 거야:

# 미래의 멀티모달 Q&A (개념적 예시)
from langchain.document_loaders import ImageLoader, AudioLoader

# 이미지 문서 로드
image_loader = ImageLoader('./images')
image_docs = image_loader.load()

# 음성 문서 로드
audio_loader = AudioLoader('./audio')
audio_docs = audio_loader.load()

# 모든 모달리티 통합
multimodal_vectorstore = create_multimodal_store(
    text_docs + image_docs + audio_docs
)

# 질문: "이 제품 사진에서 설명하는 기능은?"
# AI가 이미지를 보고 텍스트 문서를 참고해서 답변!

3. 개인화 및 적응형 AI 🎯

사용자의 패턴을 학습해서 점점 더 나은 답변을 제공하는 AI:

# 사용자 프로필 기반 답변
class PersonalizedQA:
    def __init__(self):
        self.user_profiles = {}
    
    def learn_from_feedback(self, user_id, question, answer, rating):
        """사용자 피드백으로 학습"""
        if user_id not in self.user_profiles:
            self.user_profiles[user_id] = {
                'preferences': {},
                'history': []
            }
        
        # 선호도 업데이트
        self.user_profiles[user_id]['history'].append({
            'question': question,
            'answer': answer,
            'rating': rating
        })
        
        # 패턴 분석
        self.analyze_preferences(user_id)
    
    def get_personalized_answer(self, user_id, question):
        """개인화된 답변 생성"""
        profile = self.user_profiles.get(user_id, {})
        
        # 사용자 선호도를 반영한 프롬프트 조정
        if profile.get('prefers_detailed'):
            style = "매우 자세하게"
        elif profile.get('prefers_concise'):
            style = "간결하게"
        else:
            style = "적절하게"
        
        # 맞춤 답변 생성
        return self.generate_answer(question, style)

4. 연합 학습 (Federated Learning) 🤝

여러 로컬 AI가 데이터를 공유하지 않고도 함께 학습하는 기술:

5. 엣지 AI와 IoT 통합 🌐

스마트폰, 스마트워치, IoT 기기에서 직접 AI가 실행되는 시대:

# 엣지 디바이스용 초경량 모델
from langchain.llms import TinyLlama

# 모바일 최적화 모델
mobile_llm = TinyLlama(
    model="tinyllama-1.1b",  # 1GB 미만!
    quantization="4bit",      # 극도로 압축
    device="mobile"
)

# 오프라인에서도 작동
offline_qa = create_offline_qa_system(
    llm=mobile_llm,
    vectorstore=lightweight_store,
    cache_size="100MB"  # 제한된 메모리
)

6. 자동화된 파인튜닝 🔧

사용자가 쉽게 자신의 데이터로 모델을 커스터마이징할 수 있게:

# 자동 파인튜닝 (개념적 예시)
from langchain.finetuning import AutoFineTuner

# 간단한 설정만으로 파인튜닝
tuner = AutoFineTuner(
    base_model="llama2",
    training_data="./my_documents",
    task="question-answering",
    auto_optimize=True  # 자동으로 최적 설정 찾기
)

# 학습 시작
custom_model = tuner.train(
    epochs=3,
    batch_size="auto",
    learning_rate="auto"
)

# 바로 사용 가능!
qa_chain = create_qa_chain(llm=custom_model)

마지막으로 실전에서 정말 유용한 팁들을 정리해줄게! 이건 경험에서 나온 진짜 노하우야. 😎

1. 문서 전처리가 핵심이야! 📝

# 문서 전처리 예시
def preprocess_document(text):
    """문서 전처리 함수"""
    # 1. 공백 정리
    text = re.sub(r'\s+', ' ', text)
    
    # 2. 특수문자 정리
    text = re.sub(r'[^\w\s가-힣.,!?-]', '', text)
    
    # 3. 페이지 번호 제거
    text = re.sub(r'페이지\s*\d+', '', text)
    
    # 4. 중복 줄바꿈 제거
    text = re.sub(r'\n{3,}', '\n\n', text)
    
    return text.strip()

# 메타데이터 추가
def add_metadata(doc, source, category, date):
    """문서에 메타데이터 추가"""
    doc.metadata = {
        'source': source,
        'category': category,
        'date': date,
        'processed_at': datetime.now().isoformat()
    }
    return doc

2. 프롬프트 엔지니어링 마스터하기 🎯

좋은 프롬프트가 좋은 답변을 만들어:

# 나쁜 프롬프트 ❌
bad_prompt = "질문에 답해줘: {question}"

# 좋은 프롬프트 ✅
good_prompt = """당신은 전문적이고 친절한 AI 어시스턴트입니다.

역할: {role}
목표: 사용자의 질문에 정확하고 도움이 되는 답변 제공

답변 가이드라인:
1. 제공된 컨텍스트를 우선적으로 참고하세요
2. 확실하지 않으면 추측하지 말고 모른다고 하세요
3. 답변은 {style} 스타일로 작성하세요
4. 필요하면 예시를 들어 설명하세요
5. 추가 질문이 있는지 물어보세요

컨텍스트:
{context}

사용자 질문:
{question}

답변:"""

# 동적 프롬프트 생성
def create_dynamic_prompt(role, style, context, question):
    return good_prompt.format(
        role=role,
        style=style,
        context=context,
        question=question
    )

3. 테스트와 평가를 자동화하자 🧪

# 자동 평가 시스템
class QAEvaluator:
    def __init__(self, test_questions):
        self.test_questions = test_questions
        self.results = []
    
    def evaluate(self, qa_chain):
        """Q&A 시스템 평가"""
        print("🧪 평가를 시작합니다...\n")
        
        for i, test in enumerate(self.test_questions, 1):
            question = test['question']
            expected = test.get('expected_keywords', [])
            
            print(f"테스트 {i}/{len(self.test_questions)}: {question}")
            
            # 답변 생성
            start_time = time.time()
            result = qa_chain({"query": question})
            elapsed = time.time() - start_time
            
            answer = result['result']
            
            # 평가 지표
            score = self.calculate_score(answer, expected)
            
            self.results.append({
                'question': question,
                'answer': answer,
                'score': score,
                'time': elapsed,
                'sources': len(result.get('source_documents', []))
            })
            
            print(f"  점수: {score:.2f}/10")
            print(f"  시간: {elapsed:.2f}초\n")
        
        self.print_summary()
    
    def calculate_score(self, answer, expected_keywords):
        """답변 점수 계산"""
        score = 5.0  # 기본 점수
        
        # 키워드 포함 여부
        for keyword in expected_keywords:
            if keyword in answer:
                score += 1.0
        
        # 답변 길이 (너무 짧거나 길면 감점)
        if len(answer) < 50:
            score -= 2.0
        elif len(answer) > 1000:
            score -= 1.0
        
        return min(10.0, max(0.0, score))
    
    def print_summary(self):
        """평가 결과 요약"""
        avg_score = sum(r['score'] for r in self.results) / len(self.results)
        avg_time = sum(r['time'] for r in self.results) / len(self.results)
        
        print("\n" + "="*50)
        print("📊 평가 결과 요약")
        print("="*50)
        print(f"평균 점수: {avg_score:.2f}/10")
        print(f"평균 응답 시간: {avg_time:.2f}초")
        print(f"총 테스트: {len(self.results)}개")
        print("="*50)

# 사용 예시
test_questions = [
    {
        'question': 'Python에서 리스트를 정렬하는 방법은?',
        'expected_keywords': ['sort', 'sorted', '정렬']
    },
    {
        'question': '재능넷에서 제공하는 서비스는?',
        'expected_keywords': ['재능', '거래', '플랫폼']
    }
]

evaluator = QAEvaluator(test_questions)
evaluator.evaluate(qa_chain)

4. 버전 관리와 롤백 전략 🔄

# 모델 버전 관리
class ModelVersionManager:
    def __init__(self, base_path="./models"):
        self.base_path = base_path
        self.versions = {}
    
    def save_version(self, name, qa_chain, metadata):
        """새 버전 저장"""
        version_id = datetime.now().strftime("%Y%m%d_%H%M%S")
        version_path = f"{self.base_path}/{name}/{version_id}"
        
        os.makedirs(version_path, exist_ok=True)
        
        # 설정 저장
        config = {
            'version_id': version_id,
            'timestamp': datetime.now().isoformat(),
            'metadata': metadata
        }
        
        with open(f"{version_path}/config.json", 'w') as f:
            json.dump(config, f, indent=2)
        
        # 벡터 저장소 저장
        qa_chain.vectorstore.persist_to(version_path)
        
        print(f"✅ 버전 {version_id} 저장 완료!")
        
        return version_id
    
    def load_version(self, name, version_id):
        """특정 버전 불러오기"""
        version_path = f"{self.base_path}/{name}/{version_id}"
        
        if not os.path.exists(version_path):
            raise ValueError(f"버전 {version_id}를 찾을 수 없습니다.")
        
        # 설정 로드
        with open(f"{version_path}/config.json", 'r') as f:
            config = json.load(f)
        
        print(f"📂 버전 {version_id} 로드 중...")
        
        # 벡터 저장소 로드
        vectorstore = Chroma(
            persist_directory=version_path,
            embedding_function=embeddings
        )
        
        return vectorstore, config
    
    def rollback(self, name, steps=1):
        """이전 버전으로 롤백"""
        versions = self.list_versions(name)
        if len(versions) < steps + 1:
            raise ValueError("롤백할 버전이 없습니다.")
        
        target_version = versions[-(steps+1)]
        print(f"🔄 버전 {target_version}로 롤백합니다...")
        
        return self.load_version(name, target_version)

5. 모니터링과 로깅 📊

# 상세 로깅 시스템
import logging
from logging.handlers import RotatingFileHandler

def setup_logging():
    """로깅 설정"""
    # 로거 생성
    logger = logging.getLogger('LocalQA')
    logger.setLevel(logging.DEBUG)
    
    # 파일 핸들러 (자동 로테이션)
    file_handler = RotatingFileHandler(
        'qa_system.log',
        maxBytes=10*1024*1024,  # 10MB
        backupCount=5
    )
    file_handler.setLevel(logging.DEBUG)
    
    # 콘솔 핸들러
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)
    
    # 포맷 설정
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    return logger

logger = setup_logging()

# 사용 예시
def logged_ask_question(question):
    """로깅이 포함된 질문 처리"""
    logger.info(f"질문 수신: {question}")
    
    try:
        start_time = time.time()
        result = qa_chain({"query": question})
        elapsed = time.time() - start_time
        
        logger.info(f"답변 생성 완료 (소요시간: {elapsed:.2f}초)")
        logger.debug(f"답변 내용: {result['result'][:100]}...")
        logger.debug(f"참조 문서 수: {len(result['source_documents'])}")
        
        return result['result']
        
    except Exception as e:
        logger.error(f"에러 발생: {str(e)}", exc_info=True)
        raise

와! 여기까지 정말 긴 여정이었어. 😅 Ollama와 LangChain을 활용한 로컬 Q&A 시스템 구축에 대해 정말 많은 걸 다뤘지?

우리가 배운 내용을 정리해보자면:

✅ 기초 개념
• 로컬 LLM의 필요성과 장점
• Ollama와 LangChain의 역할
• RAG(검색 증강 생성) 방식의 이해

✅ 실전 구현
• 환경 설정과 설치
• 문서 로드 및 전처리
• 벡터 저장소 구축
• Q&A 체인 구성

✅ 고급 기능
• 대화 기록 유지
• 다양한 문서 형식 지원
• 웹 인터페이스 구축
• 성능 최적화

✅ 실전 활용
• 회사 내부 문서 Q&A
• 고객 지원 챗봇
• 학습 도우미
• 코드 문서화

✅ 베스트 프랙티스
• 문서 전처리 기법
• 프롬프트 엔지니어링
• 테스트와 평가
• 모니터링과 로깅

이제 당신도 할 수 있어! 🚀

처음에는 복잡해 보일 수 있지만, 하나씩 따라하다 보면 생각보다 어렵지 않아. 중요한 건 직접 해보는 거야!

작은 프로젝트부터 시작해봐. 예를 들어:
• 개인 노트나 메모를 학습시켜서 나만의 지식 베이스 만들기
• 좋아하는 책이나 강의 자료로 학습 도우미 만들기
• 회사나 동아리의 문서를 정리해서 팀 Q&A 시스템 구축하기

그리고 재능넷 같은 플랫폼에서 이런 기술을 활용한 서비스를 제공할 수도 있어. AI 개발 재능을 공유하거나, 맞춤형 Q&A 시스템 구축 서비스를 제공하는 거지! 💼

앞으로의 학습 방향 📚

더 깊이 공부하고 싶다면:
• LangChain 공식 문서 정독
• Hugging Face에서 다양한 모델 실험
• 오픈소스 프로젝트에 기여
• 커뮤니티에서 다른 개발자들과 교류

마지막 조언 💬

AI 기술은 정말 빠르게 발전하고 있어. 오늘 배운 내용도 몇 달 후면 더 나은 방법이 나올 수 있어. 그래서 계속 학습하고 실험하는 자세가 중요해!

하지만 기본 원리는 변하지 않아. 문서를 벡터로 변환하고, 유사도를 계산하고, LLM으로 답변을 생성하는 이 흐름은 앞으로도 핵심이 될 거야.

자, 이제 당신 차례야! 직접 만들어보고, 실험해보고, 실패도 해보면서 배워나가. 그 과정에서 정말 멋진 것들을 만들어낼 수 있을 거야! 🌟

질문이나 어려운 점이 있으면 커뮤니티에 물어보는 것도 잊지 마. 우리 모두 함께 성장하는 거니까! 😊

행운을 빌어! 화이팅! 🎉