# Generative Custom Operators
> \[!IMPORTANT]
>
> Generative Custom Operators are currently available as a Public Beta product and information contained in this document is subject to change. This means that some of the features aren't yet implemented and others may be changed before the product is declared as Generally Available. Public Beta products aren't covered by a Twilio Service Level Agreement. Learn more about Twilio's beta product support [here](https://help.twilio.com/articles/115002413087-Twilio-Beta-Product-Support).
**Generative Custom Operators** allow you to use freeform instructions to analyze conversation transcripts in Conversational Intelligence. Because these Language Operators are Large Language Model (LLM) backed, they are capable of handling a wide range of sophisticated natural language understanding tasks with high degrees of accuracy.
https://www.youtube.com/watch?v=9XruSxDmqI8
With Generative Custom Operators, simply describe the meaning you would like to extract from transcripts. Conversational Intelligence will send your prompt along with the transcript to the LLM, and return the results of the analysis as an [Operator Result](/docs/conversational-intelligence/api/transcript-operator-results-subresource) for you to consume in downstream systems.
Examples of valuable use cases for Generative Custom Operators include:
* **Intent Recognition**: Identify and categorize the intent of the customer during the interaction.
* **Conversation Scoring**: Assign an overall score based on agent performance against specified criteria.
* **Entity Extraction**: Pull out a value of interest from a conversation based on the context.
* **Tailored Summaries**: Structure conversation summaries in a format that is best suited for your business.
* **Script Adherence**: Determine whether an agent 'stuck to the script' in a comprehensive way, not just individual phrases or sections.
* **Lead Qualification**: Use buying signals to classify leads into categories like 'Hot', 'Warm', or 'Cold'.
Generative Custom Operators currently use OpenAI GPT-4o-mini as the underlying LLM. For more information on the model and how the data is handled, please refer to our [AI Nutrition Fact Label for OpenAI](/docs/conversational-intelligence/ai-nutrition-fact-labels#openai-gpt-4o-mini).
For workflows subject to HIPAA using Conversational Intelligence for Voice as a HIPAA Eligible Service, Generative Custom Operators currently use Azure OpenAI as the underlying LLM. For more information on the model and how the data is handled, please refer to our [AI Nutrition Label for Azure OpenAI](/docs/conversational-intelligence/ai-nutrition-fact-labels#azure-openai).
## Prerequisites
Generative Custom Operators apply LLM-backed language analysis to Conversational Intelligence Transcripts. This guide assumes that you have already:
1. [Created a **Intelligence Service**](/docs/conversational-intelligence/onboarding#create-an-intelligence-service).
2. [Set up **Transcription** of Voice Calls](/docs/conversational-intelligence/onboarding#create-an-intelligence-service) either through auto-transcribe or by using the REST API.
3. \[Optional] [Have one or more **completed transcripts**](/docs/conversational-intelligence/onboarding#view-completed-transcriptions) in your Intelligence Service.
Completing Step 3 is strongly recommended as it will allow you to use the [**preview results**](#preview-results) feature of Generative Custom Operators – testing your draft prompt with previous transcripts before saving your new Language Operator.
## Create Generative Custom Operator in Console
The simplest way to create a Generative Custom Operator is using the Twilio Console:
* Navigate to the [Conversational Intelligence product](https://console.twilio.com/us1/develop/conversational-intelligence/overview)
* Click **Services** in the sidebar
* Select an existing **Intelligence Service**, or create a new one
* *Note*: The Service you select should be the same service containing the transcripts you'd like the Generative Custom Operator to analyze
* Click the **Create Custom Operator** button
* Select **Generative** as your operator type
This will launch the Generative Custom Operator creation wizard in Console, guiding you through the creation process.
### Write prompt
The prompt for your Generative Custom Operator provides instructions for the LLM to analyze incoming transcripts. In the textbox, explain what you would like to achieve, being specific and including key requirements for how you'd like the LLM to behave.
Please see the sections on:
* [**Best Practices**](#prompting-best-practices) for prompt writing
* [**Example Use Cases**](#example-use-cases) for more inspiration on the types of prompts you can write.
*Important notes on prompting*:
* The maximum allowable prompt length is **4,000 characters**, or roughly 600-1000 words
* Generative Custom Operators can be used to analyze transcripts in [all languages supported by Conversational Intelligence](/docs/conversational-intelligence/onboarding#supported-languages)
* In addition, **your prompt can be written in a different language than the transcripts it will analyze**. For example, while the transcripts might be in Spanish, you can write the prompt in English
### Preview results
The Console wizard for Generative Custom Operators provides the ability to preview operator results before it is finalized. This is a useful way to test the prompt you've written, ensuring that it yields the intended results.
To preview your Generative Custom Operator, find the *preview operator results* pane on the right side of the Console wizard. Click the **choose test transcript button** and choose a previously transcribed conversation to use to test your prompt. Be sure to choose a transcript that is as close as possible to the type of interaction you would expect to happen in production, once the Operator has been created. This will give the most realistic preview of "real-world" operator results.
Once a desired test transcript is selected, click the **preview operator results** button to run your Operator. Once complete, you will see the results returned by the LLM.
If the results weren't what you expected:
1. **Iterate on your prompt**: Revise your prompt, being sure to take into consideration our [prompting best practices](#prompting-best-practices).
2. **Try a different transcript**: It may be the underlying conversation data itself that is yielding a particular operator result. A different transcript may produce different results.
3. **Use Advanced Settings**: [Advanced Settings](#advanced-settings) provide additional options for customizing operator results, including output formatting controls and providing training examples to the LLM.
> \[!NOTE]
>
> * Previewing Generative Custom Operator results is **currently available only in the Console**.
> * Transcripts **must already be created in your Intelligence Service** to use them for preview.
> * If you don't have any transcripts, you can first use the [transcribe recent recordings](https://console.twilio.com/us1/develop/conversational-intelligence/transcripts?transcribeRecent=true) feature or [create Transcript API](/docs/conversational-intelligence/api/transcript-resource#create-a-new-transcript) to generate a transcript to test with, then return to create your Operator.
Once you're content with your prompt, click **Next** and review the summary of your Generative Custom Operator. If everything looks good, click **Submit** to save your new Operator.
### Adding to a Service
The final step is to add your new Generative Custom Operator to an Intelligence Service. This will allow you to use the Operator to analyze transcripts in that Service.
Upon successful creation of your Generative Custom Operator, you will be redirected to the Operator list page for your service.
To add your new Operator to a Service:
* Find your recently created Operator in the list. It will be labeled with type equal to **Generative operator**
* Click **+Add** to apply it to your Service
Great! Your new Generative Custom Operator will now execute with each new Transcript uploaded to this Intelligence Service.
## Create Generative Custom Operator with the REST API
The Intelligence REST API can be used to create Generative Custom Operators in addition to the Console. There are a few key parameters to include when creating a Generative Custom Operator:
`POST https://intelligence.twilio.com/v2/Operators/Custom`
Encoding type: `application/x-www-form-urlencoded`
**Request Parameters:**
| Parameter | Type | Definition |
| --------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `FriendlyName` | `string` | A human-readable name of this Operator, up to 64 characters. |
| `OperatorType` | `string` | For Generative Custom Operators, this should be set to `Generative` or `GenerativeJSON` based on your desired output format of the Operator results.
Use `Generative` for plain text output
Use `GenerativeJSON` for JSON-formatted output.
|
| `Config` | `object` | The configuration object for the Operator. |
| `Config.prompt` | `string` | The instructions for the LLM to analyze the transcripts. |
| `Config.json_result_schema` | `object` | For `GenerativeJSON` Operators only. This is the JSON schema object that the LLM will use to format the results. For more details on how to construct this object, please see the section on [JSON output format](#json-output-format). |
| `Config.examples` | `array` | Optional array of training examples to provide context and specificity to the LLM. For more details on how to construct this object, please see the section on [training examples](#training-examples). |
### Example request
Below is a simple example of a request to create a basic Generative Custom Operator using the API:
Create a Generative Custom Operator with Text Output
```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);
async function createCustomOperator() {
const customOperator = await client.intelligence.v2.customOperators.create({
config: {
prompt:
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
},
friendlyName: "LeadGeneration",
operatorType: "Generative",
});
console.log(customOperator.accountSid);
}
createCustomOperator();
```
```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
auth_token = os.environ["TWILIO_AUTH_TOKEN"]
client = Client(account_sid, auth_token)
custom_operator = client.intelligence.v2.custom_operators.create(
friendly_name="LeadGeneration",
operator_type="Generative",
config={
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n"
},
)
print(custom_operator.account_sid)
```
```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install
using System;
using Twilio;
using Twilio.Rest.Intelligence.V2;
using System.Threading.Tasks;
using System.Collections.Generic;
class Program {
public static async Task Main(string[] args) {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
var customOperator = await CustomOperatorResource.CreateAsync(
friendlyName: "LeadGeneration",
operatorType: "Generative",
config: new Dictionary() {
{ "prompt",
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n" }
});
Console.WriteLine(customOperator.AccountSid);
}
}
```
```java
// Install the Java helper library from twilio.com/docs/java/install
import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.intelligence.v2.CustomOperator;
public class Example {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");
public static void main(String[] args) {
Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
CustomOperator customOperator =
CustomOperator
.creator("LeadGeneration",
"Generative",
new HashMap() {
{
put("prompt",
"You are labeling the conversations between a customer and a virtual agent. Your job "
+ "is to label the transcript below with one of these labels based on the "
+ "description\nLabels\nWARM - A customer who has shown interest in our products and "
+ "offerings. They may not be open to schedule an appointment at this point or commit "
+ "to more specifics.\nHOT - A qualified lead is someone who understands what we can "
+ "offer and are willing to commit. They are more likely to result in a sale. A "
+ "customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold "
+ "lead is the one that is not interested or has lost interest in the product and "
+ "offering.\n");
}
})
.create();
System.out.println(customOperator.getAccountSid());
}
}
```
```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main
import (
"fmt"
"github.com/twilio/twilio-go"
intelligence "github.com/twilio/twilio-go/rest/intelligence/v2"
"os"
)
func main() {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
// Make sure TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN exists in your environment
client := twilio.NewRestClient()
params := &intelligence.CreateCustomOperatorParams{}
params.SetFriendlyName("LeadGeneration")
params.SetOperatorType("Generative")
params.SetConfig(map[string]interface{}{
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
})
resp, err := client.IntelligenceV2.CreateCustomOperator(params)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
} else {
if resp.AccountSid != nil {
fmt.Println(*resp.AccountSid)
} else {
fmt.Println(resp.AccountSid)
}
}
}
```
```php
intelligence->v2->customOperators->create(
"LeadGeneration", // FriendlyName
"Generative", // OperatorType
[
"prompt" =>
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
] // Config
);
print $custom_operator->accountSid;
```
```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'
# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = ENV['TWILIO_ACCOUNT_SID']
auth_token = ENV['TWILIO_AUTH_TOKEN']
@client = Twilio::REST::Client.new(account_sid, auth_token)
custom_operator = @client
.intelligence
.v2
.custom_operators
.create(
friendly_name: 'LeadGeneration',
operator_type: 'Generative',
config: {
'prompt' => 'You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description
Labels
WARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.
HOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.
COLD - A cold lead is the one that is not interested or has lost interest in the product and offering.
'
}
)
puts custom_operator.account_sid
```
```bash
# Install the twilio-cli from https://twil.io/cli
twilio api:intelligence:v2:operators:custom:create \
--friendly-name LeadGeneration \
--operator-type Generative \
--config "{\"prompt\":\"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\\nLabels\\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\\n\"}"
```
```bash
CONFIG_OBJ=$(cat << EOF
{
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n"
}
EOF
)
curl -X POST "https://intelligence.twilio.com/v2/Operators/Custom" \
--data-urlencode "FriendlyName=LeadGeneration" \
--data-urlencode "OperatorType=Generative" \
--data-urlencode "Config=$CONFIG_OBJ" \
-u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN
```
```json
{
"account_sid": "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"sid": "LYaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"friendly_name": "LeadGeneration",
"description": "New Operator",
"author": "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"operator_type": "Generative",
"version": 1,
"availability": "public",
"config": {
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n"
},
"date_created": "2010-08-31T20:36:28Z",
"date_updated": "2010-08-31T20:36:28Z",
"url": "https://intelligence.twilio.com/v2/Operators/Custom/LYaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
}
```
### Adding to a Service
Once the Generative Custom Operator has been created via the API, **it must also be added to an Intelligence Service** to be used for analyzing transcripts.
Please see the [Operator Attachment API docs](/docs/conversational-intelligence/api/operator-attachment-subresource#create-an-operator-attachment) for instructions on how to do this.
You will need the `OperatorSid` of the newly created Operator to attach it to a Service. This can be found in the response to the Operator creation API request above.
## Advanced settings
Advanced settings provide increased configurability for Generative Custom Operators. Two advanced settings are available: **JSON Output Format** and **Training Examples**.
### JSON output format
Generative Custom Operators allow you to specify the output format that best suits your needs. By default, the LLM will return an unstructured text response. However, you can **optionally choose to structure the Operator Result output by providing a [JSON schema](https://json-schema.org/docs) that the LLM will use to format the results**. JSON schema is a powerful standard for defining the structure of the data you expect to receive from the LLM. It allows you to specify the property names and data types for each property, as well as any constraints or requirements for the properties.
When using JSON output format, the LLM will return results that adhere to the schema you provide. This can be useful for ensuring that the output is structured in a way that is easy to consume by downstream systems or for more complex analysis.
#### Structuring your JSON schema
A JSON Schema for Generative Custom Operator results is passed as an object. At minimum, a valid JSON results schema object will include the following keywords:
* `type` : Must be set to `"object"`
* `properties` : An object containing the property names and their data types you would like the LLM to return
Here's a simple example of a valid JSON object used for a tailored summarization use case that can be passed as `json_result_schema` parameter when creating the `GenerativeJSON` operator:
```json {title="Sample JSON result schema for tailored summary use case"}
{
"type": "object",
"properties": {
"budget": { "type": "string" },
"authority": { "type": "string" },
"need": { "type": "string" },
"timeline": { "type": "string" }
}
}
```
> \[!NOTE]
>
> * For additional JSON result schema examples, please see the section on [example use cases](#example-use-cases).
> * We also suggest using this [JSON Schema Generator](https://transform.tools/json-to-json-schema) to help create your schema from a desired JSON object result.
> * To review all available JSON Schema syntax, visit the [reference docs](https://json-schema.org/understanding-json-schema/reference)
Additional notes on JSON output formatting:
* The root level `type` of a JSON schema **must** be set to `object`
* The following property data types are supported : `string`, `number`, `boolean`, `integer`, `object`, `array`, `enum`, `anyOf`
* Max **100 object properties** and **5 levels of nesting** are supported
* Max **500 enum values** across all enum properties are supported
* Notable JSON Schema keywords not supported include:
* **For strings**: `minLength`, `maxLength`, `pattern`, `format`
* **For numbers**: `minimum`, `maximum`, `multipleOf`
* **For objects**: `patternProperties`, `unevaluatedProperties`, `propertyNames`, `minProperties`, `maxProperties`
* **For arrays**: `unevaluatedItems`, `contains`, `minContains`, `maxContains`, `minItems`, `maxItems`, `uniqueItems`
* Structured Operator Results will be returned in the same order as the ordering of keys in the schema
* In the event an Operator execution request is refused for safety reasons the Operator Result API response will include a new field called `refusal` to indicate that the LLM refused to fulfill the request
* Twilio will automatically set `additionalProperties` to `false` and specify all provided fields as `required` (constraints of Structured Outputs). You don't need to pass these fields as part of your JSON schema. Twilio will automatically overwrite any user-provided values for these fields.
#### Use the Console to create a Generative Custom Operator with JSON output
You can include a custom JSON output format when you create your Operator in the Console. From the **Create your prompt** page, click **Advanced Settings**. Under **Output format**, select **JSON schema** which allows you to provide a JSON schema:
#### Use the API to create a Generative Custom Operator with JSON output
You can use the API to create an Operator that produces a structured JSON output format.
To use the REST API to create a Generative Custom Operator with JSON output, in addition to the standard fields, you must:
* Set `OperatorType` to `GenerativeJSON`.
* Set `Config.json_result_schema` parameter to the JSON schema you'd like the LLM to adhere to.
An example request can be found below:
Create a Generative Custom Operator with JSON output
```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);
async function createCustomOperator() {
const customOperator = await client.intelligence.v2.customOperators.create({
config: {
prompt:
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
json_result_schema: {
type: "object",
properties: {
label: {
type: "string",
},
},
},
},
friendlyName: "SalesLeadClassification",
operatorType: "GenerativeJSON",
});
console.log(customOperator.accountSid);
}
createCustomOperator();
```
```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
auth_token = os.environ["TWILIO_AUTH_TOKEN"]
client = Client(account_sid, auth_token)
custom_operator = client.intelligence.v2.custom_operators.create(
friendly_name="SalesLeadClassification",
operator_type="GenerativeJSON",
config={
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
"json_result_schema": {
"type": "object",
"properties": {"label": {"type": "string"}},
},
},
)
print(custom_operator.account_sid)
```
```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install
using System;
using Twilio;
using Twilio.Rest.Intelligence.V2;
using System.Threading.Tasks;
using System.Collections.Generic;
class Program {
public static async Task Main(string[] args) {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
var customOperator = await CustomOperatorResource.CreateAsync(
friendlyName: "SalesLeadClassification",
operatorType: "GenerativeJSON",
config: new Dictionary() {
{ "prompt",
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n" },
{ "json_result_schema",
new Dictionary() {
{ "type", "object" },
{ "properties",
new Dictionary() {
{ "label", new Dictionary() { { "type", "string" } } }
} }
} }
});
Console.WriteLine(customOperator.AccountSid);
}
}
```
```java
// Install the Java helper library from twilio.com/docs/java/install
import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.intelligence.v2.CustomOperator;
public class Example {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");
public static void main(String[] args) {
Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
CustomOperator customOperator =
CustomOperator
.creator("SalesLeadClassification",
"GenerativeJSON",
new HashMap() {
{
put("prompt",
"You are labeling the conversations between a customer and a virtual agent. Your job "
+ "is to label the transcript below with one of these labels based on the "
+ "description\nLabels\nWARM - A customer who has shown interest in our products and "
+ "offerings. They may not be open to schedule an appointment at this point or commit "
+ "to more specifics.\nHOT - A qualified lead is someone who understands what we can "
+ "offer and are willing to commit. They are more likely to result in a sale. A "
+ "customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold "
+ "lead is the one that is not interested or has lost interest in the product and "
+ "offering.\n");
put("json_result_schema", new HashMap() {
{
put("type", "object");
put("properties", new HashMap() {
{
put("label", new HashMap() {
{
put("type", "string");
}
});
}
});
}
});
}
})
.create();
System.out.println(customOperator.getAccountSid());
}
}
```
```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main
import (
"fmt"
"github.com/twilio/twilio-go"
intelligence "github.com/twilio/twilio-go/rest/intelligence/v2"
"os"
)
func main() {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
// Make sure TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN exists in your environment
client := twilio.NewRestClient()
params := &intelligence.CreateCustomOperatorParams{}
params.SetFriendlyName("SalesLeadClassification")
params.SetOperatorType("GenerativeJSON")
params.SetConfig(map[string]interface{}{
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
"json_result_schema": map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"label": map[string]interface{}{
"type": "string",
},
},
},
})
resp, err := client.IntelligenceV2.CreateCustomOperator(params)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
} else {
if resp.AccountSid != nil {
fmt.Println(*resp.AccountSid)
} else {
fmt.Println(resp.AccountSid)
}
}
}
```
```php
intelligence->v2->customOperators->create(
"SalesLeadClassification", // FriendlyName
"GenerativeJSON", // OperatorType
[
"prompt" =>
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
"json_result_schema" => [
"type" => "object",
"properties" => [
"label" => [
"type" => "string",
],
],
],
] // Config
);
print $custom_operator->accountSid;
```
```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'
# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = ENV['TWILIO_ACCOUNT_SID']
auth_token = ENV['TWILIO_AUTH_TOKEN']
@client = Twilio::REST::Client.new(account_sid, auth_token)
custom_operator = @client
.intelligence
.v2
.custom_operators
.create(
friendly_name: 'SalesLeadClassification',
operator_type: 'GenerativeJSON',
config: {
'prompt' => 'You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description
Labels
WARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.
HOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.
COLD - A cold lead is the one that is not interested or has lost interest in the product and offering.
',
'json_result_schema' => {
'type' => 'object',
'properties' => {
'label' => {
'type' => 'string'
}
}
}
}
)
puts custom_operator.account_sid
```
```bash
# Install the twilio-cli from https://twil.io/cli
twilio api:intelligence:v2:operators:custom:create \
--friendly-name SalesLeadClassification \
--operator-type GenerativeJSON \
--config "{\"prompt\":\"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\\nLabels\\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\\n\",\"json_result_schema\":{\"type\":\"object\",\"properties\":{\"label\":{\"type\":\"string\"}}}}"
```
```bash
CONFIG_OBJ=$(cat << EOF
{
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
"json_result_schema": {
"type": "object",
"properties": {
"label": {
"type": "string"
}
}
}
}
EOF
)
curl -X POST "https://intelligence.twilio.com/v2/Operators/Custom" \
--data-urlencode "FriendlyName=SalesLeadClassification" \
--data-urlencode "OperatorType=GenerativeJSON" \
--data-urlencode "Config=$CONFIG_OBJ" \
-u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN
```
### Training examples
In addition to specifying the output format, you can also provide training examples. Examples can help improve Operator results by contextualizing and clarifying as well as signaling intent and adding specificity to your request. These examples should consist of a sample input and the corresponding expected output. The LLM will use these examples to better understand the task you are asking it to perform.
#### Use the Console to Create a Generative Custom Operator with training examples
You can add training examples when you create your Operator in the Console. From the **Create your prompt** page, click **Advanced Settings**. Under **Training examples**, provide one or more sample conversation inputs and outputs to feed to the LLM:
#### Use the API to Create a Generative Custom Operator with training examples
Training examples can be passed in the `Config` object of either `Generative` or `GenerativeJSON` Custom Operators. The `examples` parameter should be an array of objects, each containing an `input` and `output` key:
* `input`: Provide a transcript snippet for the LLM to use as an example conversation
* `output`: Provide what you would expect the LLM to output for the given transcript snippet
Below is an example of a simple `examples` array:
```json
"examples": [
{
"input": "This is an example sentence which qualifies the lead as HOT.",
"output": "HOT"
}
]
```
An example full request to the API can be found below:
Create a Generative Custom Operator
```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);
async function createCustomOperator() {
const customOperator = await client.intelligence.v2.customOperators.create({
config: {
prompt:
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
examples: [
{
input: "This is an example sentence which qualifies the lead as HOT.",
output: "HOT",
},
],
},
friendlyName: "LeadGeneration",
operatorType: "Generative",
});
console.log(customOperator.accountSid);
}
createCustomOperator();
```
```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
auth_token = os.environ["TWILIO_AUTH_TOKEN"]
client = Client(account_sid, auth_token)
custom_operator = client.intelligence.v2.custom_operators.create(
friendly_name="LeadGeneration",
operator_type="Generative",
config={
"prompt": "You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n",
"examples": [
{
"input": "This is an example sentence which qualifies the lead as HOT.",
"output": "HOT",
}
],
},
)
print(custom_operator.account_sid)
```
```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install
using System;
using Twilio;
using Twilio.Rest.Intelligence.V2;
using System.Threading.Tasks;
using System.Collections.Generic;
class Program {
public static async Task Main(string[] args) {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
var customOperator = await CustomOperatorResource.CreateAsync(
friendlyName: "LeadGeneration",
operatorType: "Generative",
config: new Dictionary() {
{ "prompt",
"You are labeling the conversations between a customer and a virtual agent. Your job is to label the transcript below with one of these labels based on the description\nLabels\nWARM - A customer who has shown interest in our products and offerings. They may not be open to schedule an appointment at this point or commit to more specifics.\nHOT - A qualified lead is someone who understands what we can offer and are willing to commit. They are more likely to result in a sale. A customer who schedules an appointment is also considered HOT lead.\nCOLD - A cold lead is the one that is not interested or has lost interest in the product and offering.\n" },
{ "examples",
new List