Example function get_weather

[metricsiro]

I hope this message finds you well. I wanted to inquire if it would be possible for you to provide a small example demonstrating how to implement a function like get_weather within the application. The goal is to understand the integration of such a function with a conversational model, including how the function is defined, how the model calls it, and how the function's response is handled.

A simple example, even if brief, would be incredibly helpful to clarify this process and allow for easier implementation of similar functionalities.

Thank you for your time and assistance!

[gaborvar]

does this help?
https://platform.openai.com/docs/guides/function-calling
The methods and sample code discussed in this article should work unchanged in Azure OpenAI.
I can share how I use the tool (function) calls in the context of this Azure sample. The scenario is saving data collected by the model from the user in a conversation.
https://github.com/gaborvar/sample-app-aoai-chatGPT/blame/main/backend/utils.py

[metricsiro]

Thank you so much for the tip! I’ve made some progress; I managed to get the function recognized, and the value is being passed to my get_weather method, which now returns the JSON response on the webpage.

However, I'm still unclear on how to send the weather data back to OpenAI so that I can receive a user-friendly message that will appear on the web interface. Could you please help me with that?

`def get_weather(location):

api_url = f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid=APIKEY&units=metric"
response = requests.get(api_url)
if response.status_code == 200:
    weather_data = response.json()
    temperature = weather_data["main"]["temp"]
    print(f"+++++++++++++++++++++++++++     WETTER: {temperature} ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
    return {"location": location, "temp": temperature}
else:
    return {"error": "Entschuldigung, ich konnte die Wetterinformationen nicht abrufen."}

tool_call_accumulator = ""
tool_name = ""
tool_id = ""

def format_stream_response(chatCompletionChunk, history_metadata, apim_request_id):
global tool_call_accumulator # Zugriff auf die globale Variable
global tool_name
global tool_id

response_obj = {
    "id": chatCompletionChunk.id,
    "model": chatCompletionChunk.model,
    "created": chatCompletionChunk.created,
    "object": chatCompletionChunk.object,
    "choices": [{"messages": []}],
    "history_metadata": history_metadata,
    "apim-request-id": apim_request_id,
}



if len(chatCompletionChunk.choices) > 0:
    delta = chatCompletionChunk.choices[0].delta
    print(f"-------------DELTA: {delta}")
    
    if delta:
        if hasattr(delta, "context"):
            messageObj = {"role": "tool", "content": json.dumps(delta.context)}
            response_obj["choices"][0]["messages"].append(messageObj)
            return response_obj
        if delta.role == "assistant" and hasattr(delta, "context"):
            messageObj = {
                "role": "assistant",
                "context": delta.context,
            }
            response_obj["choices"][0]["messages"].append(messageObj)
            return response_obj
        if delta.content:
            messageObj = {
                "role": "assistant",
                "content": delta.content,
            }
            response_obj["choices"][0]["messages"].append(messageObj)
            return response_obj
        if hasattr(delta, "tool_calls") and delta.tool_calls:
            print(f"------------------------------------------------DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD")
            for tool_call in delta.tool_calls:
                if tool_call.function.name:
                    tool_name = tool_call.function.name
                    tool_id = tool_call.id
                    print(f"tool_name: {tool_name}")
                    print(f"tool_id: {tool_id}")
                    
                if tool_call.function.arguments:
                    tool_call_accumulator += tool_call.function.arguments
                    print(f"tool_call_accumulator: {tool_call_accumulator}")
                    
                    if tool_name == "get_weather" and tool_call_accumulator.endswith('}'):
                        try:
                            arguments = json.loads(tool_call_accumulator)
                            location = arguments.get('location')
                            print(f"location: {location}")
                            if location:
                                weather_info = get_weather(location)
                                if 'error' in weather_info:
                                    return {"error": weather_info['error']}
                                else:
                                    weather_response = f"location: {weather_info['location']}, temp: {weather_info['temp']}"
                                    messageObj = {
                                        "role": "assistant",
                                        "content": weather_response,
                                    }
                                    response_obj["choices"][0]["messages"].append(messageObj)
                                    tool_call_accumulator = ""
                                    return response_obj
                        except json.JSONDecodeError as e:
                            print(f"JSONDecodeError: {e}")
                            continue

print(f"FINAL RESPONSE: {response_obj}")
return {}

`

[gaborvar]

The code in this repo is apparently not intended to support tool (function) calls.
According to OpenAI documentation (see link above), you have to log two messages in the message history for each tool call: the tool call request from the model (received in the return value of the chatcompletion.create call) and the response the API returns after your code actually calls the function. The latter should bear role="tool" instead of the usual "assistant" and "user". If you look at the backend code in this repo, it is not transparent for "tool" messages. It removes "tool" messages from the message log in send_chat_request() before passing it to the model in each call. I do not see the reason why "tool" is a persona non grata but there may be a reason in the frontend code - I did not investigate that far. Although the backend folds some Azure related constructs (in utils.py) into the "tool" pathway, this should not be a reason to prevent other tool related messages to travel the same path.
I use another sample code base which, although does not include support for "tool" messages either, it does not suppress them: https://github.com/Azure-Samples/azure-search-openai-demo

To your question, this is the snippet from OpenAI documentation:

Create a message containing the result of the function call

function_call_result_message = {
"role": "tool",
"content": json.dumps({
"order_id": order_id,
"delivery_date": delivery_date.strftime('%Y-%m-%d %H:%M:%S')
}),
"tool_call_id": response['choices'][0]['message']['tool_calls'][0]['id']
}

Prepare the chat completion call payload

completion_payload = {
"model": "gpt-4o",
"messages": [
{"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."},
{"role": "user", "content": "Hi, can you tell me the delivery date for my order?"},
{"role": "assistant", "content": "Hi there! I can help with that. Can you please provide your order ID?"},
{"role": "user", "content": "i think it is order_12345"},
response['choices'][0]['message'],
function_call_result_message
]
}

Call the OpenAI API's chat completions endpoint to send the tool call result back to the model

response = openai.chat.completions.create(
model=completion_payload["model"],
messages=completion_payload["messages"]
)

Tip: If you cannot find the required ID ['tool_calls'][0]['id'] while streaming, look at the first chunk.