# 기본 LangChain 패키지
pip install langchain langchain-community langchain-openai

# 벡터 DB (로컬용 Chroma)
pip install chromadb

# 문서 로더들
pip install pypdf docx2txt beautifulsoup4 requests

# 임베딩 모델 (OpenAI 또는 로컬)
pip install openai tiktoken

# 환경변수 관리
pip install python-dotenv

# 선택: Pinecone (클라우드 벡터DB)
pip install pinecone-client

# .env 파일
OPENAI_API_KEY=sk-your-api-key-here
PINECONE_API_KEY=your-pinecone-key  # 선택사항
PINECONE_ENV=us-east-1              # 선택사항

from langchain_community.document_loaders import PyPDFLoader
from langchain_community.document_loaders import DirectoryLoader

# 단일 PDF 로드
loader = PyPDFLoader("knowledge/document.pdf")
documents = loader.load()

print(f"총 {len(documents)}페이지 로드됨")
print(documents[0].page_content[:200])  # 첫 페이지 미리보기

# 폴더 전체 PDF 자동 로드 (핵심!)
dir_loader = DirectoryLoader(
"knowledge/",
glob="**/*.pdf",
loader_cls=PyPDFLoader
)
all_docs = dir_loader.load()
print(f"총 {len(all_docs)}개 문서 로드 완료")

from langchain_community.document_loaders import WebBaseLoader
import bs4

# 단일 URL 로드
loader = WebBaseLoader(
web_paths=["https://example.com/article"],
bs_kwargs=dict(
parse_only=bs4.SoupStrainer(
class_=("post-content", "article-body")  # 필요한 부분만 추출
)
)
)
docs = loader.load()

# 여러 URL 한 번에 처리
urls = [
"https://example.com/page1",
"https://example.com/page2",
"https://example.com/page3"
]
multi_loader = WebBaseLoader(web_paths=urls)
all_web_docs = multi_loader.load()

from langchain_community.document_loaders import (
CSVLoader,           # CSV 파일
UnstructuredWordDocumentLoader,  # Word 문서
NotionDirectoryLoader,           # Notion 내보내기
SlackDirectoryLoader,            # Slack 메시지
GitLoader,                       # Git 저장소 코드
YoutubeLoader,                   # YouTube 자막
ArxivLoader,                     # 논문 (arXiv)
)

# 예시: YouTube 영상 자막 로드
yt_loader = YoutubeLoader.from_youtube_url(
"https://www.youtube.com/watch?v=example",
add_video_info=True
)
yt_docs = yt_loader.load()

from langchain.text_splitter import RecursiveCharacterTextSplitter

# 기본 설정
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,      # 청크 최대 크기 (문자 수)
chunk_overlap=200,    # 청크 간 겹치는 부분 (문맥 유지용)
length_function=len,
separators=["\n\n", "\n", ".", "!", "?", " ", ""]
)

# 문서 분할
chunks = text_splitter.split_documents(all_docs)
print(f"총 {len(chunks)}개 청크 생성")
print(f"첫 번째 청크: {chunks[0].page_content[:100]}...")

# 청크 크기 분포 확인
chunk_sizes = [len(c.page_content) for c in chunks]
print(f"평균 청크 크기: {sum(chunk_sizes)/len(chunk_sizes):.0f}자")

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from dotenv import load_dotenv
import os

load_dotenv()

# 임베딩 모델 초기화
embeddings = OpenAIEmbeddings(
model="text-embedding-3-small",  # 비용 효율적
# model="text-embedding-3-large"  # 더 높은 품질
)

# Chroma DB에 저장 (로컬 파일로 영구 저장)
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory="./chroma_db",  # 저장 경로
collection_name="knowledge_base"
)

print(f"벡터 DB 구축 완료! 총 {vectorstore._collection.count()}개 벡터 저장")

# 기존 DB 불러오기 (재시작 시)
vectorstore = Chroma(
persist_directory="./chroma_db",
embedding_function=embeddings,
collection_name="knowledge_base"
)

from langchain_community.vectorstores import Pinecone
from pinecone import Pinecone as PineconeClient, ServerlessSpec

# Pinecone 초기화
pc = PineconeClient(api_key=os.getenv("PINECONE_API_KEY"))

# 인덱스 생성 (최초 1회)
index_name = "knowledge-base"
if index_name not in pc.list_indexes().names():
pc.create_index(
name=index_name,
dimension=1536,  # text-embedding-3-small 차원
metric="cosine",
spec=ServerlessSpec(cloud="aws", region="us-east-1")
)

# LangChain과 연동
vectorstore = Pinecone.from_documents(
documents=chunks,
embedding=embeddings,
index_name=index_name
)

from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# LLM 초기화
llm = ChatOpenAI(
model="gpt-4o-mini",  # 비용 효율적
temperature=0,         # 일관된 답변을 위해 0으로 설정
max_tokens=1000
)

# 커스텀 프롬프트 템플릿
prompt_template = """
당신은 지식 관리 AI 어시스턴트입니다.
아래 제공된 컨텍스트를 기반으로 질문에 답변하세요.
컨텍스트에 없는 내용은 "해당 정보를 찾을 수 없습니다"라고 답하세요.

컨텍스트:
{context}

질문: {question}

답변:"""

PROMPT = PromptTemplate(
template=prompt_template,
input_variables=["context", "question"]
)

# Retriever 설정
retriever = vectorstore.as_retriever(
search_type="similarity",  # 유사도 검색
search_kwargs={"k": 5}     # 상위 5개 청크 검색
)

# RAG 체인 생성
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",  # 검색된 문서를 모두 컨텍스트에 넣음
retriever=retriever,
chain_type_kwargs={"prompt": PROMPT},
return_source_documents=True  # 출처 문서도 반환
)

# 질문하기!
result = qa_chain.invoke({"query": "머신러닝의 핵심 알고리즘은 무엇인가요?"})
print("답변:", result["result"])
print("\n출처 문서:")
for doc in result["source_documents"]:
print(f"  - {doc.metadata.get('source', '알 수 없음')}")

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# 프롬프트 템플릿
prompt = ChatPromptTemplate.from_template("""
다음 컨텍스트를 기반으로 질문에 답변하세요:

컨텍스트: {context}

질문: {question}
""")

# 문서 포맷팅 함수
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)

# LCEL 체인 구성 (파이프 연산자로 연결!)
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)

# 스트리밍 응답
for chunk in rag_chain.stream("LangChain의 주요 컴포넌트는?"):
print(chunk, end="", flush=True)

from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferWindowMemory

# 최근 N개 대화만 기억하는 메모리 (토큰 절약)
memory = ConversationBufferWindowMemory(
k=5,                          # 최근 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=True  # 디버깅용 로그 출력
)

# 대화 시뮬레이션
questions = [
"LangChain이 무엇인가요?",
"그것의 주요 컴포넌트를 설명해주세요",  # '그것'이 LangChain을 가리킴
"그 중에서 가장 중요한 게 뭔가요?"       # 이전 맥락 참조
]

for q in questions:
result = conv_chain.invoke({"question": q})
print(f"Q: {q}")
print(f"A: {result['answer']}\n")

import os
import time
from pathlib import Path
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from dotenv import load_dotenv

load_dotenv()

class KnowledgeManagementPlatform:
"""AI 지식관리 자동화 플랫폼 메인 클래스"""

def __init__(self, watch_dir: str = "./knowledge_docs"):
self.watch_dir = watch_dir
self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
self.llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
self.text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200
)

# 벡터 DB 초기화
self.vectorstore = Chroma(
persist_directory="./chroma_db",
embedding_function=self.embeddings,
collection_name="auto_knowledge"
)

# 감시 폴더 생성
Path(watch_dir).mkdir(exist_ok=True)
print(f"✅ 플랫폼 초기화 완료. '{watch_dir}' 폴더 감시 중...")

def process_document(self, file_path: str):
"""문서를 자동으로 처리해서 벡터 DB에 저장"""
try:
ext = Path(file_path).suffix.lower()

if ext == ".pdf":
loader = PyPDFLoader(file_path)
elif ext in [".txt", ".md"]:
loader = TextLoader(file_path, encoding="utf-8")
else:
print(f"⚠️ 지원하지 않는 형식: {ext}")
return

docs = loader.load()
chunks = self.text_splitter.split_documents(docs)
self.vectorstore.add_documents(chunks)

print(f"✅ '{Path(file_path).name}' 처리 완료 ({len(chunks)}개 청크)")

except Exception as e:
print(f"❌ 처리 실패 {file_path}: {e}")

def ask(self, question: str) -> dict:
"""질문에 답변 생성"""
retriever = self.vectorstore.as_retriever(
search_kwargs={"k": 5}
)
docs = retriever.get_relevant_documents(question)

if not docs:
return {"answer": "관련 정보를 찾을 수 없습니다.", "sources": []}

context = "\n\n".join([d.page_content for d in docs])
prompt = f"""컨텍스트:\n{context}\n\n질문: {question}\n\n답변:"""

answer = self.llm.invoke(prompt).content
sources = list(set([d.metadata.get("source", "알 수 없음") for d in docs]))

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

def get_stats(self) -> dict:
"""플랫폼 통계 반환"""
count = self.vectorstore._collection.count()
return {
"total_chunks": count,
"watch_directory": self.watch_dir,
"db_path": "./chroma_db"
}


# 파일 변경 감지 핸들러
class DocumentHandler(FileSystemEventHandler):
def __init__(self, platform: KnowledgeManagementPlatform):
self.platform = platform

def on_created(self, event):
if not event.is_directory:
print(f"📄 새 파일 감지: {event.src_path}")
time.sleep(1)  # 파일 쓰기 완료 대기
self.platform.process_document(event.src_path)


# 메인 실행
if __name__ == "__main__":
platform = KnowledgeManagementPlatform()

# 파일 감시 시작
observer = Observer()
observer.schedule(DocumentHandler(platform), platform.watch_dir, recursive=True)
observer.start()

print("🚀 AI 지식관리 플랫폼 가동 중!")
print("knowledge_docs 폴더에 파일을 넣으면 자동으로 처리됩니다.\n")

# 대화형 인터페이스
while True:
user_input = input("질문 (종료: q): ").strip()
if user_input.lower() == "q":
break
if user_input:
result = platform.ask(user_input)
print(f"\n💬 답변: {result['answer']}")
print(f"📚 출처: {', '.join(result['sources'])}\n")

observer.stop()
observer.join()

# 1. MMR (Maximal Marginal Relevance) - 다양성 확보
retriever = vectorstore.as_retriever(
search_type="mmr",
search_kwargs={
"k": 6,
"fetch_k": 20,    # 후보 20개 중에서
"lambda_mult": 0.5  # 유사도 vs 다양성 균형 (0~1)
}
)

# 2. 유사도 점수 임계값 설정
retriever = vectorstore.as_retriever(
search_type="similarity_score_threshold",
search_kwargs={"score_threshold": 0.7}  # 70% 이상 유사한 것만
)

# 3. 하이브리드 검색 (키워드 + 의미 검색)
from langchain_community.retrievers import BM25Retriever
from langchain.retrievers import EnsembleRetriever

bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 5

ensemble_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, vectorstore.as_retriever(search_kwargs={"k": 5})],
weights=[0.4, 0.6]  # BM25 40%, 벡터 검색 60%
)

# 캐싱으로 동일 질문 재처리 방지
from langchain.globals import set_llm_cache
from langchain_community.cache import SQLiteCache

set_llm_cache(SQLiteCache(database_path=".langchain.db"))

# 배치 처리로 임베딩 비용 절감
# 한 번에 여러 문서 임베딩 (API 호출 횟수 감소)
batch_size = 100
for i in range(0, len(chunks), batch_size):
batch = chunks[i:i+batch_size]
vectorstore.add_documents(batch)
print(f"배치 {i//batch_size + 1} 처리 완료")

# 문서 로드 시 메타데이터 추가
from langchain.schema import Document

doc_with_meta = Document(
page_content="내용...",
metadata={
"source": "technical_docs",
"category": "AI",
"date": "2024-01-15",
"author": "홍길동"
}
)

# 특정 카테고리만 검색
retriever = vectorstore.as_retriever(
search_kwargs={
"k": 5,
"filter": {"category": "AI"}  # AI 카테고리 문서만
}
)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
import uvicorn

app = FastAPI(title="AI 지식관리 플랫폼 API")

# 전역 플랫폼 인스턴스
platform = KnowledgeManagementPlatform()

class QuestionRequest(BaseModel):
question: str
max_results: int = 5

class UploadRequest(BaseModel):
content: str
title: str
category: str = "general"

@app.post("/ask")
async def ask_question(request: QuestionRequest):
"""지식 베이스에 질문하기"""
try:
result = platform.ask(request.question)
return {
"status": "success",
"answer": result["answer"],
"sources": result["sources"]
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.post("/upload")
async def upload_knowledge(request: UploadRequest):
"""새 지식 추가하기"""
from langchain.schema import Document
doc = Document(
page_content=request.content,
metadata={"title": request.title, "category": request.category}
)
chunks = platform.text_splitter.split_documents([doc])
platform.vectorstore.add_documents(chunks)
return {"status": "success", "chunks_added": len(chunks)}

@app.get("/stats")
async def get_stats():
"""플랫폼 통계"""
return platform.get_stats()

if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)