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_stock_price",
  "description": "Get current stock price for a ticker",
  "parameters": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": [
      "ticker"
    ]
  }
}
</schema>

<|im_start|>user
What's Tesla stock trading at?<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_stock_price", "arguments": {"ticker": "TSLA"}}

rejected: I'll check the current stock price for TSLA. Let me get that information 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": "get_stock_price",
  "description": "Get current stock price for a ticker",
  "parameters": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": [
      "ticker"
    ]
  }
}
</schema>

<|im_start|>user
Check the price of Bitcoin<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_stock_price", "arguments": {"ticker": "BTC-USD"}}

rejected: I'll check the current stock price for BTC-USD. Let me get that information 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": "get_stock_price",
  "description": "Get current stock price for a ticker",
  "parameters": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": [
      "ticker"
    ]
  }
}
</schema>

<|im_start|>user
What's Apple's current price?<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_stock_price", "arguments": {"ticker": "AAPL"}}

rejected: I'll check the current stock price for AAPL. Let me get that information 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": "get_stock_price",
  "description": "Get current stock price for a ticker",
  "parameters": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": [
      "ticker"
    ]
  }
}
</schema>

<|im_start|>user
How much is Microsoft worth?<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_stock_price", "arguments": {"ticker": "MSFT"}}

rejected: I'll check the current stock price for MSFT. Let me get that information 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": "get_stock_price",
  "description": "Get current stock price for a ticker",
  "parameters": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": [
      "ticker"
    ]
  }
}
</schema>

<|im_start|>user
Get Netflix stock price<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_stock_price", "arguments": {"ticker": "NFLX"}}

rejected: I'll check the current stock price for NFLX. Let me get that information 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": "transfer_money",
  "description": "Transfer money between accounts",
  "parameters": {
    "type": "object",
    "properties": {
      "from_account": {
        "type": "string"
      },
      "to_account": {
        "type": "string"
      },
      "amount": {
        "type": "number"
      },
      "currency": {
        "type": "string"
      }
    },
    "required": [
      "from_account",
      "to_account",
      "amount"
    ]
  }
}
</schema>

<|im_start|>user
Send $500 from my checking to savings<|im_end|>
<|im_start|>assistant

chosen: {"name": "transfer_money", "arguments": {"from_account": "checking", "to_account": "savings", "amount": 500}}

rejected: I'll help you transfer $500 from checking to savings. Let me process that transaction.


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": "transfer_money",
  "description": "Transfer money between accounts",
  "parameters": {
    "type": "object",
    "properties": {
      "from_account": {
        "type": "string"
      },
      "to_account": {
        "type": "string"
      },
      "amount": {
        "type": "number"
      },
      "currency": {
        "type": "string"
      }
    },
    "required": [
      "from_account",
      "to_account",
      "amount"
    ]
  }
}
</schema>

<|im_start|>user
Transfer 1000 euros from account A to account B<|im_end|>
<|im_start|>assistant

chosen: {"name": "transfer_money", "arguments": {"from_account": "A", "to_account": "B", "amount": 1000}}

rejected: I'll help you transfer $1000 from A to B. Let me process that transaction.


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": "transfer_money",
  "description": "Transfer money between accounts",
  "parameters": {
    "type": "object",
    "properties": {
      "from_account": {
        "type": "string"
      },
      "to_account": {
        "type": "string"
      },
      "amount": {
        "type": "number"
      },
      "currency": {
        "type": "string"
      }
    },
    "required": [
      "from_account",
      "to_account",
      "amount"
    ]
  }
}
</schema>

<|im_start|>user
Move $250 from wallet to investment account<|im_end|>
<|im_start|>assistant

chosen: {"name": "transfer_money", "arguments": {"from_account": "wallet", "to_account": "investment", "amount": 250}}

rejected: I'll help you transfer $250 from wallet to investment. Let me process that transaction.


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_email",
  "description": "Send an email message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      },
      "cc": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Email John about the project deadline<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_email", "arguments": {"to": "john@company.com", "subject": "Project Deadline", "body": "Hi John, wanted to discuss the upcoming project deadline."}}

rejected: I'll send an email to john@company.com with the subject 'Project Deadline'. Let me compose that message 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_email",
  "description": "Send an email message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      },
      "cc": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Send Sarah the meeting notes<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_email", "arguments": {"to": "sarah@team.com", "subject": "Meeting Notes", "body": "Hi Sarah, here are the notes from today's meeting."}}

rejected: I'll send an email to sarah@team.com with the subject 'Meeting Notes'. Let me compose that message 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_email",
  "description": "Send an email message",
  "parameters": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string"
      },
      "subject": {
        "type": "string"
      },
      "body": {
        "type": "string"
      },
      "cc": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "to",
      "subject",
      "body"
    ]
  }
}
</schema>

<|im_start|>user
Message the team about tomorrow's standup<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_email", "arguments": {"to": "team@company.com", "subject": "Standup Tomorrow", "body": "Reminder: standup meeting tomorrow at 9am."}}

rejected: I'll send an email to team@company.com with the subject 'Standup Tomorrow'. Let me compose that message 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_sms",
  "description": "Send SMS text message",
  "parameters": {
    "type": "object",
    "properties": {
      "phone": {
        "type": "string"
      },
      "message": {
        "type": "string"
      }
    },
    "required": [
      "phone",
      "message"
    ]
  }
}
</schema>

<|im_start|>user
Text mom that I'll be late<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_sms", "arguments": {"phone": "+1234567890", "message": "Running late, will be there in 20 minutes"}}

rejected: I'll send a text message to +1234567890. Let me send that SMS 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_sms",
  "description": "Send SMS text message",
  "parameters": {
    "type": "object",
    "properties": {
      "phone": {
        "type": "string"
      },
      "message": {
        "type": "string"
      }
    },
    "required": [
      "phone",
      "message"
    ]
  }
}
</schema>

<|im_start|>user
Send SMS to 555-0123 saying meeting is cancelled<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_sms", "arguments": {"phone": "555-0123", "message": "Meeting cancelled"}}

rejected: I'll send a text message to 555-0123. Let me send that SMS 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_sms",
  "description": "Send SMS text message",
  "parameters": {
    "type": "object",
    "properties": {
      "phone": {
        "type": "string"
      },
      "message": {
        "type": "string"
      }
    },
    "required": [
      "phone",
      "message"
    ]
  }
}
</schema>

<|im_start|>user
Message Bob at +1987654321 about dinner plans<|im_end|>
<|im_start|>assistant

chosen: {"name": "send_sms", "arguments": {"phone": "+1987654321", "message": "Are we still on for dinner tonight?"}}

rejected: I'll send a text message to +1987654321. Let me send that SMS 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": "query_database",
  "description": "Execute SQL query on database",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      },
      "limit": {
        "type": "integer"
      }
    },
    "required": [
      "query"
    ]
  }
}
</schema>

<|im_start|>user
Find all users who signed up last week<|im_end|>
<|im_start|>assistant

chosen: {"name": "query_database", "arguments": {"query": "SELECT * FROM users WHERE created_at >= DATE_SUB(NOW(), INTERVAL 1 WEEK)"}}

rejected: I'll run a database query to find all users who signed up last week. Let me execute that SQL 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": "query_database",
  "description": "Execute SQL query on database",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      },
      "limit": {
        "type": "integer"
      }
    },
    "required": [
      "query"
    ]
  }
}
</schema>

<|im_start|>user
Get top 10 selling products<|im_end|>
<|im_start|>assistant

chosen: {"name": "query_database", "arguments": {"query": "SELECT product_name, SUM(quantity) as total_sales FROM orders GROUP BY product_name ORDER BY total_sales DESC LIMIT 10"}}

rejected: I'll run a database query to get top 10 selling products. Let me execute that SQL 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": "query_database",
  "description": "Execute SQL query on database",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "database": {
        "type": "string"
      },
      "limit": {
        "type": "integer"
      }
    },
    "required": [
      "query"
    ]
  }
}
</schema>

<|im_start|>user
Show revenue by month this year<|im_end|>
<|im_start|>assistant

chosen: {"name": "query_database", "arguments": {"query": "SELECT MONTH(order_date) as month, SUM(total) as revenue FROM orders WHERE YEAR(order_date) = YEAR(NOW()) GROUP BY MONTH(order_date)"}}

rejected: I'll run a database query to show revenue by month this year. Let me execute that SQL 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": "create_file",
  "description": "Create a new file with content",
  "parameters": {
    "type": "object",
    "properties": {
      "filename": {
        "type": "string"
      },
      "content": {
        "type": "string"
      },
      "encoding": {
        "type": "string"
      }
    },
    "required": [
      "filename",
      "content"
    ]
  }
}
</schema>

<|im_start|>user
Create a file called report.txt with the quarterly results<|im_end|>
<|im_start|>assistant

chosen:
{"name": "create_file", "arguments": {"filename": "report.txt", "content": "Q3 2024 Quarterly Results

Revenue: $2.5M
Growth: 15%"}}

rejected: I'll create the file report.txt with your content. Let me write that file 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": "create_file",
  "description": "Create a new file with content",
  "parameters": {
    "type": "object",
    "properties": {
      "filename": {
        "type": "string"
      },
      "content": {
        "type": "string"
      },
      "encoding": {
        "type": "string"
      }
    },
    "required": [
      "filename",
      "content"
    ]
  }
}
</schema>

<|im_start|>user
Make a new file notes.md with meeting summary<|im_end|>
<|im_start|>assistant

chosen:
{"name": "create_file", "arguments": {"filename": "notes.md", "content": "# Meeting Summary

- Discussed project timeline
- Reviewed budget
- Next steps assigned"}}

rejected: I'll create the file notes.md with your content. Let me write that file 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": "create_file",
  "description": "Create a new file with content",
  "parameters": {
    "type": "object",
    "properties": {
      "filename": {
        "type": "string"
      },
      "content": {
        "type": "string"
      },
      "encoding": {
        "type": "string"
      }
    },
    "required": [
      "filename",
      "content"
    ]
  }
}
</schema>

<|im_start|>user
Create config.json with default settings<|im_end|>
<|im_start|>assistant

chosen: {"name": "create_file", "arguments": {"filename": "config.json", "content": "{"debug": false, "port": 8080, "host": "localhost"}"}}

rejected: I'll create the file config.json with your content. Let me write that file 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": "get_weather",
  "description": "Get weather information for location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "units": {
        "type": "string",
        "enum": [
          "celsius",
          "fahrenheit"
        ]
      },
      "forecast_days": {
        "type": "integer"
      }
    },
    "required": [
      "location"
    ]
  }
}
</schema>

<|im_start|>user
What's the weather in San Francisco?<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_weather", "arguments": {"location": "San Francisco"}}

rejected: I'll check the current weather conditions in San Francisco 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": "get_weather",
  "description": "Get weather information for location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "units": {
        "type": "string",
        "enum": [
          "celsius",
          "fahrenheit"
        ]
      },
      "forecast_days": {
        "type": "integer"
      }
    },
    "required": [
      "location"
    ]
  }
}
</schema>

<|im_start|>user
Check weather for Tokyo in celsius<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_weather", "arguments": {"location": "Tokyo"}}

rejected: I'll check the current weather conditions in Tokyo 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": "get_weather",
  "description": "Get weather information for location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      },
      "units": {
        "type": "string",
        "enum": [
          "celsius",
          "fahrenheit"
        ]
      },
      "forecast_days": {
        "type": "integer"
      }
    },
    "required": [
      "location"
    ]
  }
}
</schema>

<|im_start|>user
How's the weather in London today?<|im_end|>
<|im_start|>assistant

chosen: {"name": "get_weather", "arguments": {"location": "London"}}

rejected: I'll check the current weather conditions in London 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": "calculate_tip",
  "description": "Calculate tip amount for bill",
  "parameters": {
    "type": "object",
    "properties": {
      "bill_amount": {
        "type": "number"
      },
      "tip_percentage": {
        "type": "number"
      },
      "split_ways": {
        "type": "integer"
      }
    },
    "required": [
      "bill_amount",
      "tip_percentage"
    ]
  }
}
</schema>

<|im_start|>user
What's 20% tip on $85?<|im_end|>
<|im_start|>assistant

chosen: {"name": "calculate_tip", "arguments": {"bill_amount": 85, "tip_percentage": 20}}

rejected: I'll calculate the 20% tip on $85 for you. Let me do that math.


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": "calculate_tip",
  "description": "Calculate tip amount for bill",
  "parameters": {
    "type": "object",
    "properties": {
      "bill_amount": {
        "type": "number"
      },
      "tip_percentage": {
        "type": "number"
      },
      "split_ways": {
        "type": "integer"
      }
    },
    "required": [
      "bill_amount",
      "tip_percentage"
    ]
  }
}
</schema>

<|im_start|>user
Calculate 15% tip for a $42 bill<|im_end|>
<|im_start|>assistant

chosen: {"name": "calculate_tip", "arguments": {"bill_amount": 42, "tip_percentage": 15}}

rejected: I'll calculate the 15% tip on $42 for you. Let me do that math.


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": "calculate_tip",
  "description": "Calculate tip amount for bill",
  "parameters": {
    "type": "object",
    "properties": {
      "bill_amount": {
        "type": "number"
      },
      "tip_percentage": {
        "type": "number"
      },
      "split_ways": {
        "type": "integer"
      }
    },
    "required": [
      "bill_amount",
      "tip_percentage"
    ]
  }
}
</schema>

<|im_start|>user
How much tip for $156 at 18%?<|im_end|>
<|im_start|>assistant

chosen: {"name": "calculate_tip", "arguments": {"bill_amount": 156, "tip_percentage": 18}}

rejected: I'll calculate the 18% tip on $156 for you. Let me do that math.


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": "create_reminder",
  "description": "Create a reminder for specific time",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string"
      },
      "datetime": {
        "type": "string"
      },
      "priority": {
        "type": "string",
        "enum": [
          "low",
          "medium",
          "high"
        ]
      }
    },
    "required": [
      "title",
      "datetime"
    ]
  }
}
</schema>

<|im_start|>user
Remind me to call mom tomorrow at 6pm<|im_end|>
<|im_start|>assistant

chosen: {"name": "create_reminder", "arguments": {"title": "Call mom", "datetime": "tomorrow 6pm"}}

rejected: I'll set up a reminder for Call mom at tomorrow 6pm.


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": "create_reminder",
  "description": "Create a reminder for specific time",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string"
      },
      "datetime": {
        "type": "string"
      },
      "priority": {
        "type": "string",
        "enum": [
          "low",
          "medium",
          "high"
        ]
      }
    },
    "required": [
      "title",
      "datetime"
    ]
  }
}
</schema>

<|im_start|>user
Set reminder for dentist appointment Friday 2pm<|im_end|>
<|im_start|>assistant

chosen: {"name": "create_reminder", "arguments": {"title": "Dentist appointment", "datetime": "Friday 2pm"}}

rejected: I'll set up a reminder for Dentist appointment at Friday 2pm.


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": "create_reminder",
  "description": "Create a reminder for specific time",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string"
      },
      "datetime": {
        "type": "string"
      },
      "priority": {
        "type": "string",
        "enum": [
          "low",
          "medium",
          "high"
        ]
      }
    },
    "required": [
      "title",
      "datetime"
    ]
  }
}
</schema>

<|im_start|>user
Remind me about the meeting on Monday 9am<|im_end|>
<|im_start|>assistant

chosen: {"name": "create_reminder", "arguments": {"title": "Team meeting", "datetime": "Monday 9am"}}

rejected: I'll set up a reminder for Team meeting at Monday 9am.