# Install LangChain and dependencies
pip install langchain langchain-openai langchain-community
pip install langchain-experimental langchainhub
pip install chromadb tiktoken

# For LangGraph (advanced agents)
pip install langgraph

# Environment setup
import os
os.environ["OPENAI_API_KEY"] = "your-api-key"
os.environ["LANGCHAIN_TRACING_V2"] = "true"  # Enable tracing
os.environ["LANGCHAIN_API_KEY"] = "your-langsmith-key"
                

from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import Tool, tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.tools.retriever import create_retriever_tool
import requests

# Initialize LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Define custom tools
@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    try:
        result = eval(expression)
        return f"The result is: {result}"
    except:
        return "Invalid expression"

@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    # In production, use a real weather API
    return f"The weather in {city} is sunny, 22°C"

# Web search tool
search = DuckDuckGoSearchRun()
search_tool = Tool(
    name="web_search",
    func=search.run,
    description="Search the web for current information"
)

# Create agent
tools = [calculate, get_weather, search_tool]

# Agent prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a helpful AI assistant with access to various tools.
    Use them to answer questions accurately. Think step-by-step."""),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# Create the agent
agent = create_openai_functions_agent(llm, tools, prompt)

# Create executor
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    return_intermediate_steps=True,
    max_iterations=5,
    early_stopping_method="generate"
)

# Use the agent
result = agent_executor.invoke({
    "input": "What's the weather in Tokyo and calculate 25% of 480"
})

print(result["output"])
                

from langchain.agents import create_react_agent
from langchain import hub

# Pull ReAct prompt from hub
react_prompt = hub.pull("hwchase17/react")

# Create ReAct agent
react_agent = create_react_agent(
    llm=llm,
    tools=tools,
    prompt=react_prompt
)

react_executor = AgentExecutor(
    agent=react_agent,
    tools=tools,
    verbose=True,
    handle_parsing_errors=True
)

# ReAct pattern: Thought → Action → Observation → loop
result = react_executor.invoke({
    "input": "Find the latest AI news and summarize the top 3 stories"
})
                

from langchain.agents import create_self_ask_with_search_agent

# This agent decomposes questions into sub-questions
self_ask_agent = create_self_ask_with_search_agent(
    llm=llm,
    search_tool=search_tool,
    prompt=hub.pull("hwchase17/self-ask-with-search")
)

# Example: Complex multi-hop question
result = AgentExecutor(
    agent=self_ask_agent,
    tools=[search_tool],
    verbose=True
).invoke({
    "input": "What is the population of the capital of the country where Tesla's largest factory outside the US is located?"
})
                

from langchain_experimental.plan_and_execute import (
    PlanAndExecute,
    load_agent_executor,
    load_chat_planner
)

# Create planner and executor
planner = load_chat_planner(llm)
executor = load_agent_executor(llm, tools, verbose=True)

# Create plan-and-execute agent
plan_agent = PlanAndExecute(
    planner=planner,
    executor=executor,
    verbose=True
)

# Complex task requiring planning
result = plan_agent.run(
    "Create a comprehensive market analysis report for electric vehicles: "
    "1) Current market size, 2) Top 5 manufacturers, 3) Growth projections, "
    "4) Key challenges, 5) Investment opportunities"
)
                

from langchain.agents import AgentExecutor
from tenacity import retry, stop_after_attempt, wait_exponential

class RobustAgent:
    def __init__(self):
        self.primary_llm = ChatOpenAI(model="gpt-4")
        self.fallback_llm = ChatOpenAI(model="gpt-3.5-turbo")
        
    @retry(
        stop=stop_after_attempt(3),
        wait=wait_exponential(multiplier=1, min=4, max=10)
    )
    def execute_with_retry(self, query):
        try:
            # Try with primary LLM
            return self.run_agent(self.primary_llm, query)
        except Exception as e:
            print(f"Primary failed: {e}, using fallback")
            return self.run_agent(self.fallback_llm, query)
    
    def run_agent(self, llm, query):
        agent_executor = AgentExecutor(
            agent=create_openai_functions_agent(llm, tools, prompt),
            tools=tools,
            handle_parsing_errors=True,
            max_iterations=3,
            early_stopping_method="generate"
        )
        
        return agent_executor.invoke({"input": query})
                

# LangSmith Integration
import langsmith

client = langsmith.Client()

# Custom callbacks for monitoring
from langchain.callbacks.base import BaseCallbackHandler

class MonitoringCallback(BaseCallbackHandler):
    def __init__(self):
        self.token_count = 0
        self.tool_calls = []
        
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM Start: {prompts}")
        
    def on_llm_end(self, response, **kwargs):
        # Track token usage
        if hasattr(response, 'llm_output'):
            tokens = response.llm_output.get('token_usage', {})
            self.token_count += tokens.get('total_tokens', 0)
    
    def on_tool_start(self, serialized, input_str, **kwargs):
        self.tool_calls.append({
            'tool': serialized.get('name'),
            'input': input_str,
            'timestamp': datetime.now()
        })
    
    def get_metrics(self):
        return {
            'total_tokens': self.token_count,
            'tool_calls': len(self.tool_calls),
            'tools_used': list(set(t['tool'] for t in self.tool_calls))
        }

# Use in agent
monitor = MonitoringCallback()
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    callbacks=[monitor],
    verbose=True
)

result = agent_executor.invoke({"input": "Complex task"})
print(monitor.get_metrics())