# .env 파일
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
LANGCHAIN_API_KEY=ls-...  # 선택사항: LangSmith 추적

# Python에서 로드
from dotenv import load_dotenv
load_dotenv()

from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

# Claude 사용
llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")

# GPT-4o 사용
llm = ChatOpenAI(model="gpt-4o")

# 간단한 호출
response = llm.invoke("양자 컴퓨팅이 뭔가요?")
print(response.content)

# 시스템 프롬프트 포함
messages = [
    SystemMessage(content="당신은 Python 전문가입니다. 간결하게 답변하세요."),
    HumanMessage(content="리스트와 튜플의 차이점이 뭔가요?")
]
response = llm.invoke(messages)

from langchain_core.prompts import ChatPromptTemplate

# 재사용 가능한 템플릿 생성
prompt = ChatPromptTemplate.from_messages([
    ("system", "당신은 {company_name}의 도움이 되는 어시스턴트입니다."),
    ("human", "{question}")
])

# LLM과 체이닝
chain = prompt | llm

# 변수와 함께 호출
response = chain.invoke({
    "company_name": "테크코퍼레이션",
    "question": "영업 시간이 어떻게 되나요?"
})

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel
from typing import List

# 구조화된 출력 파싱
class 제품리뷰(BaseModel):
    평점: int
    장점: List[str]
    단점: List[str]
    요약: str

parser = JsonOutputParser(pydantic_object=제품리뷰)

prompt = ChatPromptTemplate.from_template(
    "이 제품 리뷰를 분석하세요: {review}\n\n{format_instructions}"
)

chain = prompt | llm | parser

result = chain.invoke({
    "review": "훌륭한 노트북입니다! 빠른 성능, 좋은 배터리. 키보드가 약간 딱딱함.",
    "format_instructions": parser.get_format_instructions()
})

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA

# 1단계: 문서 로드
loader = PyPDFLoader("회사_핸드북.pdf")
documents = loader.load()

# 2단계: 청크로 분할
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)

# 3단계: 임베딩 및 벡터 스토어 생성
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4단계: 검색 체인 생성
llm = ChatOpenAI(model="gpt-4o")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4})
)

# 5단계: 문서에 대한 질문
response = qa_chain.invoke({"query": "연차 정책이 어떻게 되나요?"})
print(response["result"])

from langgraph.prebuilt import create_react_agent
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool
import requests

# 커스텀 도구 정의
@tool
def 날씨_조회(도시: str) -> str:
    """도시의 현재 날씨를 조회합니다."""
    response = requests.get(f"https://api.weather.com/v1/{도시}")
    return response.json()["description"]

@tool  
def 계산기(수식: str) -> str:
    """수학 수식을 안전하게 계산합니다."""
    try:
        result = eval(수식, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"오류: {e}"

# 내장 도구
검색 = DuckDuckGoSearchRun()

# 도구와 함께 에이전트 생성
tools = [검색, 날씨_조회, 계산기]

agent = create_react_agent(
    model=ChatAnthropic(model="claude-3-5-sonnet-20241022"),
    tools=tools
)

# 에이전트 실행
result = agent.invoke({
    "messages": [{
        "role": "user", 
        "content": "서울 날씨는 어때? 그리고 그 온도의 화씨 값에서 15%는 얼마야?"
    }]
})

from langchain.memory import ConversationBufferWindowMemory
from langchain_core.prompts import MessagesPlaceholder

# 대화 기록을 위한 메모리
memory = ConversationBufferWindowMemory(
    k=10,  # 마지막 10번의 교환 기억
    memory_key="history",
    return_messages=True
)

# 지원 봇 프롬프트
prompt = ChatPromptTemplate.from_messages([
    ("system", """당신은 AcmeSoft의 친절한 고객 지원 담당자입니다.
    
제품 정보:
- AcmeSoft Pro: 월 99달러, 무제한 사용자, 클라우드 기반
- AcmeSoft Starter: 월 29달러, 최대 5명 사용자
- 무료 체험: 14일, 신용카드 불필요

항상 정중하고 공감하며 필요한 경우 인간 지원으로 에스컬레이션을 제안하세요."""),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

chain = prompt | llm | StrOutputParser()

class 지원봇:
    def __init__(self):
        self.memory = ConversationBufferWindowMemory(
            k=10, memory_key="history", return_messages=True
        )
    
    def 채팅(self, 사용자_입력: str) -> str:
        history = self.memory.load_memory_variables({})
        response = chain.invoke({
            "input": 사용자_입력,
            "history": history.get("history", [])
        })
        self.memory.save_context(
            {"input": 사용자_입력}, 
            {"output": response}
        )
        return response

# 사용
bot = 지원봇()
print(bot.채팅("Pro와 Starter의 차이가 뭔가요?"))
print(bot.채팅("구매 전에 체험해볼 수 있나요?"))
print(bot.채팅("구독을 취소하려면 어떻게 하나요?"))

import asyncio

async def 배치_처리(질문들: list[str]):
    tasks = [chain.ainvoke({"question": q}) for q in 질문들]
    return await asyncio.gather(*tasks)

# 100개의 질문을 동시에 처리
results = asyncio.run(배치_처리(질문들))

# 기본: Claude, 폴백: GPT-4o
chain_with_fallback = (
    prompt | claude_llm | parser
).with_fallbacks([prompt | gpt4_llm | parser])

from langchain.globals import set_llm_cache
from langchain.cache import SQLiteCache

set_llm_cache(SQLiteCache(database_path=".langchain.db"))
# 동일한 프롬프트는 이제 캐시된 응답 사용