OpenAI releases a new function call guide to help developers expand their model capabilities! This guide integrates user feedback, reduces 50% shorter, has clearer content, and contains complete examples of best practices, in-document function generation, and use of the weather API. OpenAI is committed to simplifying AI tools to make them easier for developers to use, thereby making it more efficient to utilize function calling capabilities.

OpenAI releases a brand new guide to function calling!

We have made important improvements based on your feedback:

-- 50% shorter, making it clearer and easier to understand – New best practices (see below for details?) – Supports in-document function generation! – Provides a complete feature example of using the weather API

View the guide and share your thoughts... pic.twitter.com/Id89E9PEff

— ilan bigio (@ilanbigio) January 13, 2025

Catalog

• How does OpenAI function call work?
• Quick Example: Weather API
  • Step 1: Define the function
  • Step 2: Call the model using the defined function
  • Step 3: Execute the function
  • Step 4: Provide results to the model
  • Step 5: Get the final response
• Best Practice for Function Calls
• Summary

How does OpenAI function call work?

Function calls allow the OpenAI model to interact with developer-defined tools, enabling it to perform more tasks beyond text or audio generation. The following is a simplified process:

1. Define function: Create a function that the model can call (for example, get_weather).
2. Model determines calling functions: Based on system prompts and user input, the model determines when to call functions.
3. Execute function: Run the function code and return the result.
4. Integration Results: The model uses the output of the function to generate the final response.

This image shows the process of function calls between the developer and the AI ??model. Here are the step-by-step instructions:

• Tool Definition Message: The developer defines the tool (function) and sends a message. In this example, the get_weather(location) function is defined, and the user asks: "What is the weather in Paris?"
• Tool call: Model recognition requires the use of the parameter "paris" to call the get_weather function.
• Execute function code: The developer (or system) executes the actual get_weather("paris") function. The function returns the response, for example: {"temperature": 14}.
• Result: The result of the function ({"temperature": 14}) is returned to the model with all previous messages.
• Final response: The model uses the function results to generate a natural language response, for example: "The current temperature in Paris is 14°C."

Please read also: 6 top LLMs that support function calls

Quick Example: Weather API

Let's look at a practical example using the get_weather function. This function retrieves the current temperature of the given coordinates.

Step 1: Define the function

<code>import requests

def get_weather(latitude, longitude):
    response = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m")
    data = response.json()
    return data['current']['temperature_2m']</code>

Step 2: Call the model using the defined function

<code>from openai import OpenAI
import json

client = OpenAI(api_key="sk-api_key”)

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "獲取提供的坐標(biāo)（攝氏度）的當(dāng)前溫度。",
        "parameters": {
            "type": "object",
            "properties": {
                "latitude": {"type": "number"},
                "longitude": {"type": "number"}
            },
            "required": ["latitude", "longitude"],
            "additionalProperties": False
        },
        "strict": True
    }
}]

messages = [{"role": "user", "content": "今天巴黎的天氣怎么樣？"}]

completion = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
)</code>

Step 3: Execute the function

<code>tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

result = get_weather(args["latitude"], args["longitude"])</code>

Step 4: Provide results to the model

<code># 附加模型的工具調(diào)用消息
messages.append(completion.choices[0].message)

# 將結(jié)果消息作為字符串附加
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps({"temperature": result})  # 將結(jié)果轉(zhuǎn)換為JSON字符串
})

# 創(chuàng)建第二個(gè)聊天完成
completion_2 = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
)</code>

Step 5: Get the final response

<code>print(completion_2.choices[0].message.content)</code>

Output:

<code>巴黎目前的溫度是-2.8°C。</code>

Best Practice for Function Calls

To help you make the most of your function calls, here are some professional tips:

1. Writing a clear and detailed description
   • Clearly describe the purpose, parameters and output of the function.
   • Use the system prompts to guide the model when (and when not) to use functions.
2. Best Practice of Application Software Engineering
   • Make the function intuitive and easy to understand.
   • Use enumerations and object structures to prevent invalid states.
3. Reduce the burden on the model
   • Do not let the model fill in parameters you know.
   • Merge functions that are always called sequentially.
4. The number of functions is small
   • To improve accuracy, use up to less than 20 functions at a time.
5. Utilize OpenAI resources
   • Use Playground to generate and iterate function patterns.
   • Consider fine-tuning for complex tasks or large numbers of functions.

For more information, please visit OpenAI.

Summary

OpenAI's improved function call guide enables developers to seamlessly integrate custom tools to make AI easier to access and use. By simplifying processes, providing clear examples, and prioritizing user feedback, OpenAI enables developers to innovate and build solutions that leverage the full potential of AI, thereby driving real-world applications and creativity.

The above is the detailed content of Checkout the OpenAI Function Calling Guide. For more information, please follow other related articles on the PHP Chinese website!