# .env file
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
LANGCHAIN_API_KEY=ls-...  # Optional: LangSmith tracing
LANGCHAIN_TRACING_V2=true

# Load in 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

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

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

# Simple call
response = llm.invoke("What is quantum computing?")
print(response.content)

# With system prompt
messages = [
    SystemMessage(content="You are a Python expert. Be concise."),
    HumanMessage(content="What's the difference between list and tuple?")
]
response = llm.invoke(messages)

from langchain_core.prompts import ChatPromptTemplate

# Create a reusable template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant for {company_name}."),
    ("human", "{question}")
])

# Chain it with an LLM
chain = prompt | llm

# Invoke with variables
response = chain.invoke({
    "company_name": "TechCorp",
    "question": "What are your office hours?"
})

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

# Parse structured output
class ProductReview(BaseModel):
    rating: int
    pros: List[str]
    cons: List[str]
    summary: str

parser = JsonOutputParser(pydantic_object=ProductReview)

prompt = ChatPromptTemplate.from_template(
    "Analyze this product review: {review}\n\n{format_instructions}"
)

chain = prompt | llm | parser

result = chain.invoke({
    "review": "Great laptop! Fast performance, good battery. Keyboard is a bit stiff.",
    "format_instructions": parser.get_format_instructions()
})
# Returns: ProductReview(rating=4, pros=['Fast', 'Good battery'], 
#                        cons=['Stiff keyboard'], summary='...')

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

# Step 1: Load documents
loader = PyPDFLoader("company_handbook.pdf")
documents = loader.load()

# Also works with URLs:
# loader = WebBaseLoader("https://docs.yourcompany.com")

# Step 2: Split into chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)

# Step 3: Create embeddings and vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# Step 4: Create retrieval chain
llm = ChatOpenAI(model="gpt-4o")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4})
)

# Step 5: Ask questions about your documents
response = qa_chain.invoke({"query": "What is the vacation policy?"})
print(response["result"])

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import create_react_agent
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool
import requests

# Define custom tools
@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    # Call weather API
    response = requests.get(f"https://api.weather.com/v1/{city}")
    return response.json()["description"]

@tool  
def calculate(expression: str) -> str:
    """Safely evaluate a mathematical expression."""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"Error: {e}"

# Built-in tools
search = DuckDuckGoSearchRun()

# Create agent with tools
tools = [search, get_weather, calculate]

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

# Run the agent
result = agent.invoke({
    "messages": [{
        "role": "user", 
        "content": "What's the weather in Seoul, and what's 15% of the temperature in Fahrenheit?"
    }]
})

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

# Memory for conversation history
memory = ConversationBufferWindowMemory(
    k=10,  # Remember last 10 exchanges
    memory_key="history",
    return_messages=True
)

# Support bot prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a helpful customer support agent for AcmeSoft.
    
Context about our products:
- AcmeSoft Pro: $99/month, unlimited users, cloud-based
- AcmeSoft Starter: $29/month, up to 5 users
- Free trial: 14 days, no credit card required

Always be polite, empathetic, and offer to escalate to human support if needed."""),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# Create chain with memory
chain = prompt | llm | StrOutputParser()

class SupportBot:
    def __init__(self):
        self.memory = ConversationBufferWindowMemory(
            k=10, memory_key="history", return_messages=True
        )
    
    def chat(self, user_input: str) -> str:
        history = self.memory.load_memory_variables({})
        response = chain.invoke({
            "input": user_input,
            "history": history.get("history", [])
        })
        self.memory.save_context(
            {"input": user_input}, 
            {"output": response}
        )
        return response

# Use it
bot = SupportBot()
print(bot.chat("What's the difference between Pro and Starter?"))
print(bot.chat("Can I try before buying?"))
print(bot.chat("How do I cancel my subscription?"))

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = "my-ai-app"

# Now ALL LangChain calls are automatically traced
# View them at: smith.langchain.com

# Run evaluation on your chain
from langsmith import Client
from langchain.smith import RunEvalConfig

client = Client()

eval_config = RunEvalConfig(
    evaluators=["qa", "conciseness", "harmfulness"],
    input_key="question",
    eval_llm=ChatOpenAI(model="gpt-4o")
)

# This runs your chain on test cases and scores it
results = client.run_on_dataset(
    dataset_name="my-test-questions",
    llm_or_chain_factory=lambda: qa_chain,
    evaluation=eval_config
)

import asyncio

async def process_batch(questions: list[str]):
    tasks = [chain.ainvoke({"question": q}) for q in questions]
    return await asyncio.gather(*tasks)

# Process 100 questions concurrently
results = asyncio.run(process_batch(questions))

from langchain_core.runnables import RunnableWithFallbacks

# Primary: Claude, Fallback: 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"))
# Now identical prompts use cached responses