Exploring Function Calling in GPT-4 and GPT-3.5

The Role of Function Calling in LLM-Based Applications

Function calling is crucial for developing LLM-based chatbots or agents that require context retrieval or external tool interactions through API calls. This feature allows developers to create applications such as conversational agents, data extraction tools, and systems for knowledge retrieval.

Practical Use Cases for Function Calling

One use case involves creating conversational agents that efficiently use external tools to answer queries. For example, the question "What is the weather like in Belize?" can be transformed into a function call such as get_current_weather(location: string, unit: 'celsius' | 'fahrenheit').

Additionally, function calling can be employed to develop LLM-powered solutions for tasks like extracting and tagging data, converting natural language into API calls or database queries, and interacting with knowledge bases for conversational knowledge retrieval.

Using Function Calling with GPT-4

Consider a scenario where a user requests the model to check the weather in a specific location. The LLM, on its own, cannot respond as its training data has a cutoff point. To address this, the LLM can be combined with an external tool. The model identifies the appropriate external function to call, along with its arguments, and returns a JSON object with the necessary information to fulfill the request.

Below is a basic example of how this can be implemented using OpenAI's APIs:

1. Define the Function

   Begin by defining a function like get_current_weather that retrieves the current weather for a specified location:

   tools = [
       {
           "type": "function",
           "function": {
               "name": "get_current_weather",
               "description": "Get the current weather in a given location",
               "parameters": {
                   "type": "object",
                   "properties": {
                       "location": {
                           "type": "string",
                           "description": "The city and state, e.g. San Francisco, CA",
                       },
                       "unit": {
                           "type": "string", 
                           "enum": ["celsius", "fahrenheit"]
                       },
                   },
                   "required": ["location"],
               },
           },
       }
   ]

2. Formulate the User Query

   Next, include the user's query as part of the messages object:

   messages = [
       {
           "role": "user",
           "content": "What is the weather like in London?"
       }
   ]

3. Execute the Completion Function

   Finally, execute the completion function with the defined tools and messages:

   response = get_completion(messages, tools=tools)

   The response object will include the arguments the model has extracted to fulfill the request.

Conclusion

Function calling broadens the capabilities of LLMs like GPT-4 and GPT-3.5, allowing them to interact with external tools and APIs. This feature empowers developers to create sophisticated applications, from chatbots to data extraction tools, that can provide more accurate responses by leveraging external resources.