Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "simple_function",
  "description": "Simple function with one parameter",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Call with hello world<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "simple_function", "arguments": {"text": "hello world"}}

Rejected response: I'll call the function with hello world


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "two_param_function",
  "description": "Function with two parameters",
  "parameters": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string"
      },
      "age": {
        "type": "integer"
      }
    },
    "required": [
      "name",
      "age"
    ]
  }
}
</schema>

<|im_start|>user
Call with name John and age 25<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "two_param_function", "arguments": {"name": "John", "age": 25}}

Rejected response: {"name": "two_param_function", "arguments": {"name": "John" "age": 25}}


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_text",
  "description": "Analyze text content",
  "parameters": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    },
    "required": [
      "content",
      "type"
    ]
  }
}
</schema>

<|im_start|>user
Analyze this text: The CEO said we have made tremendous progress this quarter<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_text", "arguments": {"content": "The CEO said we have made tremendous progress this quarter", "type": "analysis"}}

Rejected response: I will analyze that text for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "send_message",
  "description": "Send a message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send email to john@company.com with subject Meeting Update and body The meeting has been rescheduled to tomorrow at 2 PM<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "send_message", "arguments": {"to": "john@company.com", "subject": "Meeting Update", "body": "The meeting has been rescheduled to tomorrow at 2 PM"}}

Rejected response: I will send that email for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_query",
  "description": "Process database query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      }
    },
    "required": [
      "query",
      "database"
    ]
  }
}
</schema>

<|im_start|>user
Run query SELECT name FROM users WHERE created_at > 2023-01-01 on the main database<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_query", "arguments": {"query": "SELECT name FROM users WHERE created_at > 2023-01-01", "database": "main"}}

Rejected response: I will run that database query for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "configure_system",
  "description": "Configure system settings",
  "parameters": {
    "type": "object",
    "properties": {
      "timeout": {
        "type": "integer"
      },
      "enabled": {
        "type": "boolean"
      },
      "level": {
        "type": "string"
      }
    },
    "required": [
      "timeout",
      "enabled"
    ]
  }
}
</schema>

<|im_start|>user
Set timeout to 30 seconds, enable the system, and set level to debug<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "configure_system", "arguments": {"timeout": 30, "enabled": true, "level": "debug"}}

Rejected response: I will configure the system with those settings


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "process_files",
  "description": "Process multiple files",
  "parameters": {
    "type": "object",
    "properties": {
      "files": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "operation": {
        "type": "string"
      }
    },
    "required": [
      "files",
      "operation"
    ]
  }
}
</schema>

<|im_start|>user
Process files data.csv, results.json, and report.pdf with merge operation<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "process_files", "arguments": {"files": ["data.csv", "results.json", "report.pdf"], "operation": "merge"}}

Rejected response: I will process those files for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "summarize_document",
  "description": "Summarize document content",
  "parameters": {
    "type": "object",
    "properties": {
      "document_url": {
        "type": "string"
      },
      "summary_length": {
        "type": "string"
      },
      "target_audience": {
        "type": "string"
      }
    },
    "required": [
      "document_url"
    ]
  }
}
</schema>

<|im_start|>user
Summarize the document at https://example.com/report.pdf for executives with brief length<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "summarize_document", "arguments": {"document_url": "https://example.com/report.pdf", "summary_length": "brief", "target_audience": "executive"}}

Rejected response: I will summarize that document for executives


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "analyze_sentiment",
  "description": "Analyze text sentiment",
  "parameters": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "language": {
        "type": "string"
      },
      "include_emotions": {
        "type": "boolean"
      }
    },
    "required": [
      "text"
    ]
  }
}
</schema>

<|im_start|>user
Analyze sentiment of this text: The product was excellent and delivery was fast with emotion details in English<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "analyze_sentiment", "arguments": {"text": "The product was excellent and delivery was fast", "language": "en", "include_emotions": true}}

Rejected response: I will analyze the sentiment of that text


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "get_weather_forecast",
  "description": "Get weather forecast",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "days": {
        "type": "integer"
      },
      "units": {
        "type": "string"
      },
      "include_hourly": {
        "type": "boolean"
      }
    },
    "required": [
      "location",
      "days"
    ]
  }
}
</schema>

<|im_start|>user
Get 3-day weather forecast for New York in metric units with hourly details<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "get_weather_forecast", "arguments": {"location": "New York", "days": 3, "units": "metric", "include_hourly": true}}

Rejected response: I will get the weather forecast for New York


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "convert_currency",
  "description": "Convert currency amounts",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number"
      },
      "from_currency": {
        "type": "string"
      },
      "to_currency": {
        "type": "string"
      },
      "include_fees": {
        "type": "boolean"
      }
    },
    "required": [
      "amount",
      "from_currency",
      "to_currency"
    ]
  }
}
</schema>

<|im_start|>user
Convert 100 US dollars to Euros with fees included<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "convert_currency", "arguments": {"amount": 100, "from_currency": "USD", "to_currency": "EUR", "include_fees": true}}

Rejected response: I will convert that currency amount for you


Prompt:
<|im_start|>system
You are a helpful assistant that calls functions by responding with valid JSON when given a schema. Always respond with JSON function calls only, never prose.<|im_end|>

<schema>
{
  "name": "optimize_database_query",
  "description": "Optimize database query",
  "parameters": {
    "type": "object",
    "properties": {
      "sql_query": {
        "type": "string"
      },
      "database_type": {
        "type": "string"
      },
      "performance_target": {
        "type": "string"
      }
    },
    "required": [
      "sql_query",
      "database_type"
    ]
  }
}
</schema>

<|im_start|>user
Optimize this MySQL query for speed: SELECT id, name FROM users WHERE active = 1<|im_end|>
<|im_start|>assistant

Chosen response: {"name": "optimize_database_query", "arguments": {"sql_query": "SELECT id, name FROM users WHERE active = 1", "database_type": "mysql", "performance_target": "speed"}}

Rejected response: I will optimize that database query for you