from langchain_openai import ChatOpenAI

# Define models to compare
models = ["gpt-4o", "claude-3-5-sonnet", "deepseek-v3"]

for model_name in models:
    llm = ChatOpenAI(model=model_name, temperature=0.7)
    response = llm.invoke("Explain quantum computing in one sentence.")
    print(f"{model_name}: {response.content}\n")

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Create a simple chain
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant that speaks {language}."),
    ("human", "{question}")
])

model = ChatOpenAI(model="gpt-4o")
output_parser = StrOutputParser()

chain = prompt | model | output_parser

# Invoke the chain
result = chain.invoke({
    "language": "Spanish",
    "question": "What is AI?"
})
print(result)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", streaming=True)

for chunk in llm.stream("Write a haiku about AI:"):
    print(chunk.content, end="", flush=True)

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.tools import tool
from langchain import hub

# Define a simple tool
@tool
def get_weather(city: str) -> str:
    """Get the weather for a city."""
    return f"The weather in {city} is sunny."

# Create the agent
llm = ChatOpenAI(model="gpt-4o")
tools = [get_weather]
agent = create_react_agent(llm, tools, hub.pull("hwchase17/react"))

# Run the agent
agent_executor = AgentExecutor(agent=agent, tools=tools)
result = agent_executor.invoke({
    "input": "What's the weather in San Francisco?"
})
print(result["output"])

from langchain_openai import ChatOpenAI

# AI Gateway can automatically route requests based on task complexity
# Simple tasks → Fast/cheap models
# Complex tasks → Powerful models

llm = ChatOpenAI(
    model="auto",  # AI Gateway handles routing automatically
    temperature=0.7,
)

# The model parameter "auto" tells AI Gateway to:
# - Analyze the request complexity
# - Select the optimal model
# - Balance cost and performance
response = llm.invoke("Write a complex Python decorator.")
print(response.content)