# Function Calling (experimental)

{% hint style="warning" %}
Please note that this is a research preview of our function calling model 
{% endhint %}

## Overview

Fastino’s Function Calling model enables natural language execution of structured API calls based on user-defined schemas. This model interprets intent from freeform input and returns arguments for one or more functions in a machine-executable format. It supports multiple endpoints, nested parameters, and is ideal for building task-oriented virtual agents, workflow automation, or natural language interfaces over structured APIs.

## Example Use Cases

* Conversational agents for customer support, service scheduling, or e-commerce
* Executing booking or reservation flows via natural language
* Smart form filling from unstructured queries
* Multistep workflow triggering in enterprise systems
* Extracting function-ready arguments for backend automation

## Usage

{% code title="Example Body" %}

```json
{
  "model_id": "fastino-function-calling-••••••••••",
  "input": [
    {
      "text": "Schedule a car maintenance service at the Downtown Auto Center on 15/09 at 10 AM for a sedan",
      "parameters": [
        {
          "name": "roadside_assistance_request",
          "parameters": {
            "type": "dict",
            "properties": {
              "location": {
                "type": "str",
                "description": "The location of the car"
              },
              "issue_description": {
                "type": "str",
                "description": "The description of the issue"
              },
              "estimate_arrival_time": {
                "type": "str",
                "description": "The estimated arrival time of the roadside assistance"
              }
            }
          },
          "description": "Request roadside assistance for a car"
        },
        {
          "name": "car_maintenance_scheduling",
          "parameters": {
            "type": "dict",
            "properties": {
              "car_type": {
                "type": "str",
                "description": "The type of car"
              },
              "appointment_date": {
                "type": "str",
                "description": "The date of the appointment"
              },
              "appointment_time": {
                "type": "str",
                "description": "The time of the appointment"
              },
              "service_location": {
                "type": "str",
                "description": "The location of the car"
              }
            }
          },
          "description": "Schedule a car maintenance service"
        },
        {
          "name": "test_drive_booking",
          "parameters": {
            "type": "dict",
            "properties": {
              "time": {
                "type": "str",
                "description": "The time of the test drive"
              },
              "dealership": {
                "type": "str",
                "description": "The dealership of the car"
              },
              "desired_date": {
                "type": "str",
                "description": "The date of the test drive"
              },
              "model_of_interest": {
                "type": "str",
                "description": "The model of the car"
              }
            }
          },
          "description": "Book a test drive for a car"
        }
      ]
    }
  ]
}
```

{% endcode %}

{% code title="Example Response" %}

```json
[
  {
    "car_maintenance_scheduling": {
      "appointment_date": "15 / 09",
      "appointment_time": "10 am",
      "car_type": "sedan",
      "service_location": "downtown auto center"
    }
  }
]
```

{% endcode %}

### Notes

* Each entry in the parameters array corresponds to a callable function with a name, description, and typed schema.
* The model returns a list of invocations with populated parameters when a matching intent is detected.
* Function names must be unique.
* Ideal for integrating with JSON-RPC, OpenAPI, or LangChain tool call workflows.

<br>

Let me know if you’d like a matching Markdown version or landing page variant.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://fastino-1.gitbook.io/docs/models/function-calling-experimental.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.