How can I integrate web search functionality with GPT-4-Turbo's API using function calling?

Below is an explanation and example of how you can integrate web search functionality with GPT-4-Turbo using its function calling feature.

Overview

GPT-4-Turbo supports function calling, which lets you define a list of functions (with a description and parameters) that the model can call when it determines it would help answer the user's query. You can leverage this to integrate a web search API into your application. Essentially, you:

1. Define a function (and its schema) that performs the web search.
2. Provide that schema to the Chat Completion API along with your conversation messages.
3. When GPT-4-Turbo determines a web search can help, it automatically returns a function call with the necessary arguments.
4. Your application then executes the web search function and can relay the results back to the model if needed.

Example Code

Below is an example that shows how you might accomplish this:

PYTHONCopied
import openai
import requests
import json

# Step 1: Define the function for web search.
def web_search(query):
    # This is a simple example – in practice replace with your real web search API endpoint.
    response = requests.get(f'https://api.example.com/search?q={query}')
    return response.json()

# Step 2: Define the function schema for GPT-4-Turbo.
functions = [
    {
        "name": "web_search",
        "description": "Searches the web for the requested information.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query string"
                }
            },
            "required": ["query"]
        }
    }
]

# Step 3: Prepare a message that may trigger the function call.
messages = [
    {
        "role": "user",
        "content": "Find information on integrating GPT-4-Turbo with web search functionality."
    }
]

# Step 4: Call the Chat Completion API with the function definitions.
response = openai.ChatCompletion.create(
    model="gpt-4-turbo",
    messages=messages,
    functions=functions,
    function_call="auto"  # instructs the model to call functions when appropriate
)

# Step 5: Check if the model decided to call a function.
message = response.choices[0].message
if message.get("function_call"):
    # Extract the function name and arguments.
    function_call = message["function_call"]
    function_name = function_call["name"]
    arguments = json.loads(function_call["arguments"])

    if function_name == "web_search":
        # Execute the function and capture results.
        search_results = web_search(**arguments)
        print("Web Search Results:", search_results)
else:
    # No function call; use the message's content as the response.
    print("Model response:", message["content"])

Explanation

• Function Definition:
  In the functions list, we define a function called web_search along with a schema. This tells GPT-4-Turbo which function it can call and what parameters it requires.

• Message and API Call:
  We provide a user message that might benefit from a web search. The openai.ChatCompletion.create call includes both the conversation history and the function definitions.

• Handling the Function Call:
  If GPT-4-Turbo decides that invoking your web search function is useful, it returns a message with a function_call field. You then parse the arguments, execute your function (web_search), and handle the results.

Final Note

Using function calling in this way lets you offload the execution of non-language tasks (like calling an external web search API) to your application while still taking advantage of GPT-4-Turbo’s natural language understanding and reasoning. This enables you to build dynamic and interactive applications with GPT-4-Turbo integrated with web search functionality.