# Create virtual environment
python -m venv ai-agent-env
source ai-agent-env/bin/activate  # On Windows: ai-agent-env\Scripts\activate

# Install core packages
pip install openai==1.12.0
pip install langchain==0.2.0
pip install python-dotenv

# Set your API key
export OPENAI_API_KEY="your-api-key-here"

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool

# Initialize the LLM
llm = ChatOpenAI(
    model="gpt-4-turbo-2026",
    temperature=0.7,
    max_tokens=1000
)

# Create a simple search tool
def search_web(query: str) -> str:
    """Simulated web search function"""
    return f"Search results for '{query}': [Result 1, Result 2, Result 3]"

# Define available tools
tools = [
    Tool(
        name="WebSearch",
        func=search_web,
        description="Search the web for current information"
    )
]

# Create the agent
prompt = """You are a helpful AI assistant. 
Use available tools when needed to answer questions.

Available tools: {tools}

Question: {input}

{agent_scratchpad}"""

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run the agent
result = agent_executor.invoke({
    "input": "What are the latest developments in AI for 2026?"
})
print(result["output"])

import datetime
import requests

def get_current_time():
    """Get current date and time"""
    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def calculator(expression: str) -> str:
    """Evaluate mathematical expressions"""
    try:
        # Simple calculator - use eval carefully in production!
        result = eval(expression)
        return f"{expression} = {result}"
    except:
        return "Error: Invalid expression"

def get_weather(city: str) -> str:
    """Get weather for a city (simulated)"""
    # In production, connect to a real weather API
    weather_data = {
        "New York": "72°F, Sunny",
        "London": "55°F, Cloudy", 
        "Tokyo": "68°F, Rainy"
    }
    return weather_data.get(city, "Weather data not available")

# Add tools to your agent
advanced_tools = [
    Tool(name="Time", func=get_current_time, description="Get current date and time"),
    Tool(name="Calculator", func=calculator, description="Calculate mathematical expressions"),
    Tool(name="Weather", func=get_weather, description="Get weather for a city"),
    Tool(name="WebSearch", func=search_web, description="Search the web")
]

from langchain.memory import ConversationBufferMemory

# Create memory for the agent
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True,
    max_token_limit=1000
)

# Create agent with memory
agent_with_memory = create_react_agent(llm, advanced_tools, prompt)
agent_executor_with_memory = AgentExecutor(
    agent=agent_with_memory,
    tools=advanced_tools,
    memory=memory,
    verbose=True,
    max_iterations=3
)

# Example conversation
conversation = [
    "What's the weather in New York?",
    "What time is it there?",
    "Can you calculate 25 * 4 + 100 for me?"
]

for question in conversation:
    result = agent_executor_with_memory.invoke({"input": question})
    print(f"Q: {question}")
    print(f"A: {result['output']}\n")

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="AI Agent API")

class AgentRequest(BaseModel):
    question: str

@app.post("/ask")
async def ask_agent(request: AgentRequest):
    """Endpoint to ask questions to your AI agent"""
    result = agent_executor_with_memory.invoke({
        "input": request.question
    })
    return {
        "question": request.question,
        "answer": result["output"],
        "success": True
    }

@app.get("/health")
async def health_check():
    return {"status": "healthy", "version": "2026.1.0"}

# Run with: uvicorn api_server:app --reload