Agents &
Tools Integration

from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.tools import Tool
from langchain.prompts import PromptTemplate
from langchain_google_genai import ChatGoogleGenerativeAI
import os
import math
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize the LLM
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    temperature=0  # Lower temperature for more consistent tool usage
)

# Create a simple calculator tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression"""
    try:
        # Use Python's eval for calculations
        # Only allow safe math operations
        allowed_names = {
            k: v for k, v in math.__dict__.items() if not k.startswith("__")
        }
        # Add power operator
        allowed_names['__builtins__'] = {'pow': pow}
        
        # Basic safety check
        if any(word in expression for word in ['import', 'exec', 'eval', 'open', 'file']):
            return "Invalid expression - contains restricted keywords"
        
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return str(result)
    except Exception as e:
        return f"Error calculating: {str(e)}"

# Create tool
calculator_tool = Tool(
    name="Calculator",
    func=calculate,
    description="Useful for mathematical calculations. Input should be a valid Python mathematical expression."
)

# Create the ReAct prompt
react_prompt = PromptTemplate.from_template("""Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: {agent_scratchpad}""")

# Create the agent
agent = create_react_agent(
    llm=llm,
    tools=[calculator_tool],
    prompt=react_prompt
)

# Create agent executor
agent_executor = AgentExecutor(
    agent=agent,
    tools=[calculator_tool],
    verbose=True,
    max_iterations=3,
    handle_parsing_errors=True
)

# Test the agent with math problems
test_queries = [
    "What is 15% of 2847?",
    "If I invest $10,000 at 7% annual interest, how much will I have after 5 years with compound interest?",
    "A pizza has 8 slices. If 3 people each eat 2.5 slices, how many slices are left?"
]

for query in test_queries:
    print(f"\n{'='*50}")
    print(f"Query: {query}")
    print(f"{'='*50}")
    
    try:
        result = agent_executor.invoke({"input": query})
        print(f"\nFinal Answer: {result['output']}")
    except Exception as e:
        print(f"Error: {e}")

# Example of agent reasoning output:
print(f"\n{'='*50}")
print("What you'll see in verbose mode:")
print(f"{'='*50}")
print("""
> Entering new AgentExecutor chain...
I need to calculate 15% of 2847.

Action: Calculator
Action Input: 2847 * 0.15

Observation: 427.05
Thought: I now know the final answer.
Final Answer: 15% of 2847 is 427.05
""")

from langchain.tools import tool
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import PromptTemplate
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Custom tool example - Weather information
@tool
def get_weather(city: str) -> str:
    """
    Get current weather information for a specified city.
    Useful when you need to find weather conditions, temperature, or forecast.
    
    Args:
        city: The name of the city to get weather for
        
    Returns:
        Weather information as a string
    """
    # Mock implementation - Replace with real weather API (OpenWeatherMap, etc.)
    mock_weather_data = {
        "tokyo": "Sunny, 22°C, humidity 65%, light breeze",
        "london": "Cloudy, 15°C, humidity 80%, chance of rain",
        "new york": "Partly cloudy, 18°C, humidity 60%, windy",
    }
    
    city_lower = city.lower()
    if city_lower in mock_weather_data:
        return f"Weather in {city}: {mock_weather_data[city_lower]}"
    
    return f"Weather data not available for {city}"

# Initialize LLM
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    temperature=0
)

# Create ReAct prompt (same as before)
react_prompt = PromptTemplate.from_template("""Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: {agent_scratchpad}""")

# Create agent with custom tool
agent = create_react_agent(
    llm=llm,
    tools=[get_weather],
    prompt=react_prompt
)

# Create agent executor
agent_executor = AgentExecutor(
    agent=agent,
    tools=[get_weather],
    verbose=True,
    handle_parsing_errors=True
)

# Test the custom tool
query = "What's the weather like in Tokyo?"
print(f"Query: {query}")
print("-" * 50)

try:
    result = agent_executor.invoke({"input": query})
    print(f"\nAnswer: {result['output']}")
except Exception as e:
    print(f"Error: {e}")