OpenAI Function Calling学习笔记01

1# 这将是模型可以调用的函数
2def get_delivery_date(order_id: str) -> datetime:
3    # 连接数据库
4    conn = sqlite3.connect('ecommerce.db')
5    cursor = conn.cursor()
6    # ...

 1{
 2    "name": "get_delivery_date",
 3    "description": "Get the delivery date for a customer's order. Call this whenever you need to know the delivery date, for example when a customer asks 'Where is my package'",
 4    "parameters": {
 5        "type": "object",
 6        "properties": {
 7            "order_id": {
 8                "type": "string",
 9                "description": "The customer's order ID.",
10            },
11        },
12        "required": ["order_id"],
13        "additionalProperties": false,
14    }
15}

 1tools = [
 2    {
 3        "type": "function",
 4        "function": {
 5            "name": "get_delivery_date",
 6            "description": "Get the delivery date for a customer's order. Call this whenever you need to know the delivery date, for example when a customer asks 'Where is my package'",
 7            "parameters": {
 8                "type": "object",
 9                "properties": {
10                    "order_id": {
11                        "type": "string",
12                        "description": "The customer's order ID.",
13                    },
14                },
15                "required": ["order_id"],
16                "additionalProperties": False,
17            },
18        }
19    }
20]
21
22messages = [
23    {"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."},
24    {"role": "user", "content": "Hi, can you tell me the delivery date for my order?"}
25]
26
27response = openai.chat.completions.create(
28    model="gpt-4o",
29    messages=messages,
30    tools=tools,
31)

1chat.completionsMessage(content='Hi there! I can help with that. Can you please provide your order ID?', role='assistant', function_call=None, tool_calls=None)

 1tools = [
 2    {
 3        "type": "function",
 4        "function": {
 5            "name": "get_delivery_date",
 6            "description": "Get the delivery date for a customer's order. Call this whenever you need to know the delivery date, for example when a customer asks 'Where is my package'",
 7            "parameters": {
 8                "type": "object",
 9                "properties": {
10                    "order_id": {
11                        "type": "string",
12                        "description": "The customer's order ID."
13                    }
14                },
15                "required": ["order_id"],
16                "additionalProperties": False
17            }
18        }
19    }
20]
21
22messages = []
23messages.append({"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."})
24messages.append({"role": "user", "content": "Hi, can you tell me the delivery date for my order?"})
25// highlight-start
26messages.append({"role": "assistant", "content": "Hi there! I can help with that. Can you please provide your order ID?"})
27messages.append({"role": "user", "content": "i think it is order_12345"})
28// highlight-end
29
30response = client.chat.completions.create(
31    model='gpt-4o',
32    messages=messages,
33    tools=tools
34)

 1Choice(
 2    finish_reason='tool_calls', 
 3    index=0, 
 4    logprobs=None, 
 5    message=chat.completionsMessage(
 6        content=None, 
 7        role='assistant', 
 8        function_call=None, 
 9        tool_calls=[
10            chat.completionsMessageToolCall(
11                id='call_62136354', 
12                function=Function(
13                    arguments='{"order_id":"order_12345"}', 
14                    name='get_delivery_date'), 
15                type='function')
16        ])
17)

1# Extract the arguments for get_delivery_date
2# Note this code assumes we have already determined that the model generated a function call. See below for a more production ready example that shows how to check if the model generated a function call
3tool_call = response.choices[0].message.tool_calls[0]
4arguments = json.loads(tool_call['function']['arguments'])
5
6order_id = arguments.get('order_id')
7
8# Call the get_delivery_date function with the extracted order_id
9delivery_date = get_delivery_date(order_id)

 1# Simulate the order_id and delivery_date
 2order_id = "order_12345"
 3delivery_date = datetime.now()
 4
 5# Simulate the tool call response
 6response = {
 7    "choices": [
 8        {
 9            "message": {
10                "tool_calls": [
11                    {"id": "tool_call_1"}
12                ]
13            }
14        }
15    ]
16}
17
18# Create a message containing the result of the function call
19function_call_result_message = {
20    "role": "tool",
21    "content": json.dumps({
22        "order_id": order_id,
23        "delivery_date": delivery_date.strftime('%Y-%m-%d %H:%M:%S')
24    }),
25    "tool_call_id": response['choices'][0]['message']['tool_calls'][0]['id']
26}
27
28# Prepare the chat completion call payload
29completion_payload = {
30    "model": "gpt-4o",
31    "messages": [
32        {"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."},
33        {"role": "user", "content": "Hi, can you tell me the delivery date for my order?"},
34        {"role": "assistant", "content": "Hi there! I can help with that. Can you please provide your order ID?"},
35        {"role": "user", "content": "i think it is order_12345"},
36        response['choices'][0]['message'],
37        function_call_result_message
38    ]
39}
40
41# Call the OpenAI API's chat completions endpoint to send the tool call result back to the model
42response = openai.chat.completions.create(
43    model=completion_payload["model"],
44    messages=completion_payload["messages"]
45)
46
47# Print the response from the API. In this case it will typically contain a message such as "The delivery date for your order #12345 is xyz. Is there anything else I can help you with?"
48print(response)

 1# Check if the conversation was too long for the context window
 2if response['choices'][0]['message']['finish_reason'] == "length":
 3    print("Error: The conversation was too long for the context window.")
 4    # Handle the error as needed, e.g., by truncating the conversation or asking for clarification
 5    handle_length_error(response)
 6    
 7# Check if the model's output included copyright material (or similar)
 8if response['choices'][0]['message']['finish_reason'] == "content_filter":
 9    print("Error: The content was filtered due to policy violations.")
10    # Handle the error as needed, e.g., by modifying the request or notifying the user
11    handle_content_filter_error(response)
12    
13# Check if the model has made a tool_call. This is the case either if the "finish_reason" is "tool_calls" or if the "finish_reason" is "stop" and our API request had forced a function call
14if (response['choices'][0]['message']['finish_reason'] == "tool_calls" or 
15    # This handles the edge case where if we forced the model to call one of our functions, the finish_reason will actually be "stop" instead of "tool_calls"
16    (our_api_request_forced_a_tool_call and response['choices'][0]['message']['finish_reason'] == "stop")):
17    # Handle tool call
18    print("Model made a tool call.")
19    # Your code to handle tool calls
20    handle_tool_call(response)
21    
22# Else finish_reason is "stop", in which case the model was just responding directly to the user
23elif response['choices'][0]['message']['finish_reason'] == "stop":
24    # Handle the normal stop case
25    print("Model responded directly to the user.")
26    # Your code to handle normal responses
27    handle_normal_response(response)
28    
29# Catch any other case, this is unexpected
30else:
31    print("Unexpected finish_reason:", response['choices'][0]['message']['finish_reason'])
32    # Handle unexpected cases as needed
33    handle_unexpected_case(response)

 1from enum import Enum
 2from typing import Union
 3from pydantic import BaseModel
 4import openai
 5from openai import OpenAI
 6
 7client = OpenAI()
 8
 9class GetDeliveryDate(BaseModel):
10    order_id: str
11
12tools = [openai.pydantic_function_tool(GetDeliveryDate)]
13
14messages = []
15messages.append({"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."})
16messages.append({"role": "user", "content": "Hi, can you tell me the delivery date for my order #12345?"}) 
17
18response = client.chat.completions.create(
19    model='gpt-4o-2024-08-06',
20    messages=messages,
21    tools=tools
22)
23
24print(response.choices[0].message.tool_calls[0].function)

 1response = Choice(
 2    finish_reason='tool_calls', 
 3    index=0, 
 4    logprobs=None, 
 5    message=chat.completionsMessage(
 6        content=None, 
 7        role='assistant', 
 8        function_call=None, 
 9        tool_calls=[
10            chat.completionsMessageToolCall(
11                id='call_62136355', 
12                function=Function(
13                    arguments='{"city":"New York"}', 
14                    name='check_weather'), 
15                type='function'),
16            chat.completionsMessageToolCall(
17                id='call_62136356', 
18                function=Function(
19                    arguments='{"city":"London"}', 
20                    name='check_weather'), 
21                type='function'),
22            chat.completionsMessageToolCall(
23                id='call_62136357', 
24                function=Function(
25                    arguments='{"city":"Tokyo"}', 
26                    name='check_weather'), 
27                type='function')
28        ])
29)
30
31# Iterate through tool calls to handle each weather check
32for tool_call in response.message.tool_calls:
33    arguments = json.loads(tool_call.function.arguments)
34    city = arguments['city']
35    weather_info = check_weather(city)
36    print(f"Weather in {city}: {weather_info}")

 1# Assume we have fetched the weather data from somewhere
 2weather_data = {
 3    "New York": {"temperature": "22°C", "condition": "Sunny"},
 4    "London": {"temperature": "15°C", "condition": "Cloudy"},
 5    "Tokyo": {"temperature": "25°C", "condition": "Rainy"}
 6}
 7    
 8# Prepare the chat completion call payload with inline function call result creation
 9completion_payload = {
10    "model": "gpt-4o",
11    "messages": [
12        {"role": "system", "content": "You are a helpful assistant providing weather updates."},
13        {"role": "user", "content": "Can you tell me the weather in New York, London, and Tokyo?"},
14        # Append the original function calls to the conversation
15        response['message'],
16        # Include the result of the function calls
17        {
18            "role": "tool",
19            "content": json.dumps({
20                "city": "New York",
21                "weather": weather_data["New York"]
22            }),
23            # Here we specify the tool_call_id that this result corresponds to
24            "tool_call_id": response['message']['tool_calls'][0]['id']
25        },
26        {
27            "role": "tool",
28            "content": json.dumps({
29                "city": "London",
30                "weather": weather_data["London"]
31            }),
32            "tool_call_id": response['message']['tool_calls'][1]['id']
33        },
34        {
35            "role": "tool",
36            "content": json.dumps({
37                "city": "Tokyo",
38                "weather": weather_data["Tokyo"]
39            }),
40            "tool_call_id": response['message']['tool_calls'][2]['id']
41        }
42    ]
43}
44    
45# Call the OpenAI API's chat completions endpoint to send the tool call result back to the model
46response = openai.chat.completions.create(
47    model=completion_payload["model"],
48    messages=completion_payload["messages"]
49)
50    
51# Print the response from the API, which will return something like "In New York the weather is..."
52print(response)

 1from openai import OpenAI
 2
 3client = OpenAI()
 4
 5tools = [
 6    {
 7        "type": "function",
 8        "function": {
 9            "name": "get_weather",
10            "strict": True,
11            "parameters": {
12                "type": "object",
13                "properties": {
14                    "location": {"type": "string"},
15                    "unit": {"type": "string", "enum": ["c", "f"]},
16                },
17                "required": ["location", "unit"],
18                "additionalProperties": False,
19            },
20        },
21    },
22    {
23        "type": "function",
24        "function": {
25            "name": "get_stock_price",
26            "strict": True,
27            "parameters": {
28                "type": "object",
29                "properties": {
30                    "symbol": {"type": "string"},
31                },
32                "required": ["symbol"],
33                "additionalProperties": False,
34            },
35        },
36    },
37]
38
39messages = [{"role": "user", "content": "What's the weather like in Boston today?"}]
40completion = client.chat.completions.create(
41    model="gpt-4o",
42    messages=messages,
43    tools=tools,
44    tool_choice="required"
45)
46
47print(completion)

 1{
 2    "name": "pick_tshirt_size",
 3    "description": "Call this if the user specifies which size t-shirt they want",
 4    "parameters": {
 5        "type": "object",
 6        "properties": {
 7            "size": {
 8                "type": "string",
 9                "enum": ["s", "m", "l"],
10                "description": "The size of the t-shirt that the user would like to order"
11            }
12        },
13        "required": ["size"],
14        "additionalProperties": false
15    }
16}