Function Calling

Function calling allows users to connect our latest models to external tools, streamlining agentic use cases, and allowing users to integrate our models much more deeply into their workflows. Some examples of tools that users could pass to our model are:

• Calculator: Connect our models to a calculator to eliminate all hallucinations, especially if working with complex computations.
• Internal Databases Connect our models to your internal tools/databases to allow customers to ask questions about inventory and product availability.
• REST APIs: Connect our models to any REST API, allowing our models to access to the particular real-time information that you need to drive your application-specific use case.

Models That Support Function Calling

Currently, only Reka Flash supports function calling. We are working hard to quickly enable support for our other classes of models.

Step By Step Example of How to Leverage Function Calling

In this section, we will go through step by step how to use Reka’s function calling capabilities with a concrete example. For this example, we will define two functions: get_product_availability, and get_similar_products. Both take in a product id, and get_similar_products additionally takes in the maximum number of results to return, allowing customers to ask questions about various products.

Step 1: Define The Tools

First, we must create a specification for each function. We pass these specs to the model to connect them to the tools.

1
[
2
    {
3
        "type": "function",
4
        "function": {
5
            "name": "get_product_availability",
6
            "description": "Determine whether or not a product is currently in stock given a product id.",
7
            "parameters": {
8
                "type": "object",
9
                "properties": {
10
                    "product_id": {
11
                        "type": "string",
12
                        "description": "The unique product id to retrieve availability information for"
13
                    }
14
                },
15
                "required": ["product_id"]
16
            }
17
        }
18
    },
19
    {
20
        "type": "function",
21
        "function": {
22
            "name": "get_similar_products",
23
            "description": "Get a list of similar products to a given product id.",
24
            "parameters": {
25
                "type": "object",
26
                "properties": {
27
                    "product_id": {
28
                        "type": "string",
29
                        "description": "The unique product id to retrieve similar products for"
30
                    },
31
                    "max_results": {
32
                        "type": "int",
33
                        "description": "The maximum number of similar products to return",
34
                        "default": 3
35
                    }
36
                },
37
                "required": ["product_id"]
38
            }
39
        }
40
    }
41
]

Step 2: Pass the Tools Along With a User Query to the Model

Now that we have defined the tools our model has access to, we can query the model by passing in these tools along with a user query:

1
from openai import OpenAI
2
3
client = OpenAI(
4
    base_url="https://api.reka.ai/v1",
5
    api_key="YOUR_API_KEY",
6
)
7
8
messages = [
9
    {
10
        "content": "Is product a-12345 in stock right now?",
11
        "role": "user",
12
    },
13
]
14
15
tools = [
16
    {
17
        "type": "function",
18
        "function": {
19
            "name": "get_product_availability",
20
            "description": "Determine whether or not a product is currently in stock given a product id.",
21
            "parameters": {
22
                "type": "object",
23
                "properties": {
24
                    "product_id": {
25
                        "type": "string",
26
                        "description": "The unique product id to retrieve availability information for"
27
                    }
28
                },
29
                "required": ["product_id"]
30
            }
31
        }
32
    },
33
    {
34
        "type": "function",
35
        "function": {
36
            "name": "get_similar_products",
37
            "description": "Get a list of similar products to a given product id.",
38
            "parameters": {
39
                "type": "object",
40
                "properties": {
41
                    "product_id": {
42
                        "type": "string",
43
                        "description": "The unique product id to retrieve similar products for"
44
                    },
45
                    "max_results": {
46
                        "type": "int",
47
                        "description": "The maximum number of similar products to return",
48
                        "default": 3
49
                    }
50
                },
51
                "required": ["product_id"]
52
            }
53
        }
54
    }
55
]
56
57
response = client.chat.completions.create(
58
    model="reka-flash",
59
    messages=messages,
60
    tool_choice="auto",
61
    tools=tools,
62
)
63
tool_call = response.choices[0].message.tool_calls[0]
64
print(tool_call)

The response will contain a tool call like:

1
{
2
    "id": "c25b10ed-22b6-4dee-8c22-48844d60d5e8",
3
    "type": "function",
4
    "function": {
5
        "name": "get_product_availability",
6
        "arguments": "{\"product_id\": \"a-12345\"}"
7
    }
8
}

Tool Choice

The tool_choice parameter controls how the model uses the tools you pass. There are three available options:

• auto lets the model decide whether or not to invoke a tool. This is the recommended way to do function calling with our models
• none disables tool calling. In this case, even if you pass tools to the model, the model will not invoke any tools
• tool forces the model to invoke one or more of the tools it has been passed

Model Response Type

Note that if tool_choice is set to auto, the model will decide whether or not to invoke a function. If the model chooses to invoke a function, the response message will contain tool_calls and content will be null/None. If the model refrains from making a function call, the converse will be true: tool_calls will be null/None and content will contain the model’s natural language response.

Step 3: Execute the Function

In the case the model decides to invoke a tool, the next step is to execute the function to obtain the output from the function invocation.

1
import json
2
3
def get_product_availability(product_id: str):
4
    """This function will actually check the availability of the product
5
    (by querying a database, for instance)"""
6
7
    return "AVAILABLE" # Mock response for the purposes of this example
8
9
args = json.loads(tool_call.function.arguments)
10
product_id = args.get("product_id")
11
tool_output = get_product_availability(product_id)

Step 4: Pass the Result Back to the Model

Finally, we can pass the result back to the model in order to receive a natural language response based on the result of the function execution. The message history must include the original user message, the assistant’s tool call, and the tool output:

1
import json
2
3
messages.extend([
4
    {
5
        "role": "assistant",
6
        "tool_calls": [{
7
            "id": tool_call.id,
8
            "type": "function",
9
            "function": {
10
                "name": tool_call.function.name,
11
                "arguments": tool_call.function.arguments,
12
            }
13
        }]
14
    },
15
    {
16
        "role": "tool",
17
        "tool_call_id": tool_call.id,
18
        "content": json.dumps({"status": tool_output})
19
    },
20
])
21
22
response = client.chat.completions.create(
23
    model="reka-flash",
24
    messages=messages,
25
)
26
27
print(response.choices[0].message.content)

This will return a response like:

Yes, product a-12345 is currently available.