Simple LangChain Tool Call with WeatherAPI

003-tutorial.py

import os
import sys
from dotenv import load_dotenv, set_key
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, PromptTemplate
from langchain_core.runnables import RunnableSequence
from langchain.tools import Tool
from langchain.agents import create_react_agent, AgentExecutor
from langchain.schema import HumanMessage
import getpass
import requests

# Load environment variables
load_dotenv()

# Check if the WeatherAPI token is set in the environment
WEATHER_API_KEY = os.getenv('WEATHER_API_KEY')

# Check if the OpenAI token is set in the environment
if not os.getenv('OPENAI_API_KEY'):
    # Prompt user for OpenAI token and save in .env file if not set
    openai_token = getpass.getpass(prompt="Enter your OpenAI token: ")
    set_key('.env', 'OPENAI_API_KEY', openai_token)
    load_dotenv()  # Reload to include the newly set token

# Initialize our language model
if not WEATHER_API_KEY:
    # Prompt user for WeatherAPI token and save in .env file if not set
    weather_api_token = getpass.getpass(prompt="Enter your WeatherAPI token: ")
    set_key('.env', 'WEATHER_API_KEY', weather_api_token)
    WEATHER_API_KEY = weather_api_token
    load_dotenv() # Reload to include the newly set token

llm = ChatOpenAI(model="gpt-4o-mini")

# Define a simple function to use as a tool
def get_current_weather(location):
    api_url = f"http://api.weatherapi.com/v1/current.json?key={WEATHER_API_KEY}&q={location}"
    response = requests.get(api_url)
    if response.status_code == 200:
        data = response.json()
        return f"The weather in {location} is {data['current']['condition']['text']} and {data['current']['temp_c']}\u00b0C.\n"
    else:
        return f"Failed to get weather for {location}.\n"

# Create a generic tool
tools = [
    Tool(
        name="Weather Checker",
        func=get_current_weather,
        description="Useful for getting the current weather in a specific location"
    )
]

# Function to load prompt from file
def load_prompt_template(file_path):
    with open(file_path, 'r') as file:
        return file.read()

# Load the React prompt template from file
react_prompt_template = load_prompt_template('tutorial.react-prompt.md')

# Create the PromptTemplate
react_prompt = PromptTemplate.from_template(react_prompt_template)

# Create the agent
agent = create_react_agent(llm, tools, react_prompt)

# Create an agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# Create a prompt template for the main query
prompt = ChatPromptTemplate.from_template(
    "Answer the following question: {question}"
)

# Print the prompt for debugging
print(f"Prompt: {prompt}")

def safe_invoke_agent(prompt_result):
    # Extract content from the model's output
    content = prompt_result.to_messages()[0].content

    # Validation: Check if the content is valid
    if not content or "invalid" in content.lower():
        raise ValueError("The model produced invalid content.")
    
    # Proceed with invoking the agent
    return agent_executor.invoke({
        "input": content,
        "tools": tools,
        "tool_names": ", ".join([tool.name for tool in tools]),
        "question": "What's the weather like in Tokyo?",
        "agent_scratchpad": ""
    })

# Create our RunnableSequence
sequence = RunnableSequence(
    prompt,
    safe_invoke_agent
)

# Print the sequence for debugging
print(f"Sequence: {sequence}")

def main():
    # Use the sequence
    print("Invoking sequence with question: What's the weather like in Tokyo?")
    result = sequence.invoke({
        "question": "What's the weather like in Tokyo?"
    })
    print(f"Sequence result: {result}")

    print("Answer:")
    print(result['output'])
 
if __name__ == "__main__":
    main()

tutorial.react-prompt.md

Answer the following question 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 2 times) Thought: I now know the final answer Final Answer: the final answer to the original input question

Question: {input} Thought: Let's approach this step-by-step: {agent_scratchpad}

webwright.log

bald-manatee@openai/gpt-4o-2024-05-13 ~\Code\langchain-labs $ use weatherapi.com to implement a new weather checker. try to read the token from env and if it's not set prompt and save it to env
Here is the plan to implement the new weather checker using weatherapi.com:

1. Update Environment Variables:
    - Check if the WeatherAPI token is set in the environment.
    - If the token is not set, prompt the user for the token and save it to the .env file.

2. Update `get_current_weather` Function:
    - Modify the get_current_weather function to use the WeatherAPI to fetch the current weather for a given location.

3. Apply the Changes to `reference_app.py`:
    - Make the necessary code modifications to incorporate the new weather checker functionality.

Shall I proceed with these steps?

bald-manatee@openai/gpt-4o-2024-05-13 ~\Code\langchain-labs $ y
Executing function: apply_code_diff_to_file
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1721761474.901083   27116 config.cc:230] gRPC experiments enabled: call_status_override_on_cancellation, event_engine_client, event_engine_dns, event_engine_listener, http2_stats_fix, monitoring_experiment, pick_first_new, trace_record_callops, work_serializer_clears_time_cache
Gemini API token verified successfully.
The changes have been successfully applied to reference_app.py. The file now includes the implementation for the new weather checker using weatherapi.com.

Would you like me to run the updated reference_app.py file to check the new weather checker functionality?

bald-manatee@openai/gpt-4o-2024-05-13 ~\Code\langchain-labs $ i don't see the update write it out to a new file similar name
Executing function: write_code_to_file_patch
I have successfully written the updated code to a new file named reference_app_updated.py.

Would you like me to run this updated script to verify its functionality?

bald-manatee@openai/gpt-4o-2024-05-13 ~\Code\langchain-labs $ yes
Executing function: run_python_file
Enter your WeatherAPI token: 
The updated script reference_app_updated.py executed successfully. Here is the output:

Prompt: input_variables=['question'] messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], template='Answer the following question: {question}'))]
Sequence: first=ChatPromptTemplate(input_variables=['question'], messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], template='Answer the following question: {question}'))]) last=RunnableLambda(safe_invoke_agent)
Invoking sequence with question: What's the weather like in Tokyo?



> Entering new AgentExecutor chain...
Thought: First, I need to check the current weather in Tokyo to provide an accurate answer.
Action: Weather Checker
Action Input: Tokyo
The weather in Tokyo is Clear and 29.3°C.
I now know the final answer.
Final Answer: The weather in Tokyo is clear with a temperature of 29.3°C.
> Finished chain.
Sequence result: {'input': "Answer the following question: What's the weather like in Tokyo?", 'tools': [Tool(name='Weather Checker', description='Useful for getting the current weather in a specific location', func=<function get_current_weather at 0x00000286A5817880>)], 'tool_names': 'Weather Checker', 'question': "What's the weather like in Tokyo?", 'agent_scratchpad': '', 'output': 'The weather in Tokyo is clear with a temperature of 29.3°C.'}
Answer:
The weather in Tokyo is clear with a temperature of 29.3°C.

The script successfully fetched and displayed the current weather in Tokyo using the weatherapi.com service.

Is there anything else you would like to do?

bald-manatee@openai/gpt-4o-2024-05-13 ~\Code\langchain-labs $