How can my AI Agent fetch real-time weather data using HTTP requests and ChatGPT?

Below is a consolidated approach for integrating real-time data retrieval into your agent system:

1. Use a Dedicated Function for Data Retrieval

Instead of relying on ChatGPT to fetch weather data directly, encapsulate your HTTP call inside a custom function. For example, you can create a function like get_weather that makes an HTTP request to your weather API and returns structured data.

PYTHONCopied
import requests

def get_weather(api_key: str, city: str) -> dict:
    url = f'http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}'
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception("Error retrieving weather data")

2. Leverage Function Calling in ChatGPT

Recent enhancements to the OpenAI API allow you to define functions that the model can call when certain queries (like weather inquiries) are made. You can define a function schema and pass it to the model along with your user message. When the function is necessary, the API will return a tool call that your system can execute at runtime.

For example, you might set up a function calling configuration like this:

PYTHONCopied
from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "strict": True,
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "api_key": {"type": "string"}
                },
                "required": ["city", "api_key"],
                "additionalProperties": False,
            },
        },
    },
]

messages = [{"role": "user", "content": "What's the weather like in Boston today?"}]
completion = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools
)

print(completion)

When the model detects a weather request, it may return a tool call with the proper arguments. You then extract these arguments and call your get_weather function to retrieve real data.

3. Integrate With Your Telegram Bot

In your Telegram handler, once you detect a trigger (for example, a command or a certain keyword), you can call your weather function asynchronously. Here’s a conceptual snippet:

PYTHONCopied
from telegram.ext import Application, CommandHandler
import asyncio

async def weather_command(update, context):
    # Extract parameters - you might pass city from user command
    api_key = "your_api_key"
    city = "Boston"  # or extract from command arguments
    try:
        weather_data = await asyncio.to_thread(get_weather, api_key, city)
        # Format the data as needed before sending back to the user
        response_msg = f"The current weather in {city} is {weather_data.get('weather')[0]['description']}."
    except Exception as e:
        response_msg = str(e)
    
    await update.message.reply_text(response_msg)

# Set up your bot application
application = Application.builder().token("YOUR_TELEGRAM_BOT_TOKEN").build()
application.add_handler(CommandHandler("weather", weather_command))
application.run_polling()

4. Best Practices & Additional Tips

• Error Handling and Logging: Make sure that weather retrieval includes robust error handling (for example, handling timeouts or invalid data) and logs errors appropriately.
• Caching: If your weather data needs to be refreshed only every so often, consider caching the results to reduce API calls.
• Async Requests: Depending on your scale and latency requirements, use asynchronous HTTP libraries (like HTTPX) to prevent blocking your event loop.

By separating the concern of retrieving real-time data into its own function and then using function calling or explicit trigger commands in Telegram, you enable your agent to provide up-to-date information reliably.

This approach should give you a more robust integration of real-time data into your AI agent system. Happy coding!