annajuliaasf/tool-calling-traces-ptbr

Tool calling conversations in Portuguese

484 synthetic conversations that teach a model when to call a tool, which one to call and with which arguments, and also when to answer directly, with no tool at all.

Each line of the file is a complete conversation: the user's question, the tool call, the simulated return of that tool, and the final answer.

It was built because no dataset of tool calling in Portuguese with fictional tools existed. The 30 tools and the user questions were written by language models.

Synthetic data, fictional tools. None of the 30 tools corresponds to a real API, and no tool return is true: all of them were written by a model. Useful for studying format and behaviour, not as a source of information.

The format

A JSONL file, one conversation per line, in the messages format:

{"messages": [
  {"role": "system",    "content": "<instrucoes>...</instrucoes>\n\n<ferramentas>\nnome:...\n</ferramentas>"},
  {"role": "user",      "content": "Posso ter um orçamento para as minhas despesas?"},
  {"role": "assistant", "content": "<tool_call>\n{\"nome_tool\": \"create_budget\", \"argumentos\": {...}}\n</tool_call>"},
  {"role": "user",      "content": "<tool_result>\n{...}\n</tool_result>"},
  {"role": "assistant", "content": "<final_answer>\nCom base no seu orçamento...\n</final_answer>"}
]}

The tags and field names stay in Portuguese, because they are the literal strings the model reads and writes.

Conversations with no tool have only the first three messages, and the answer also goes inside <final_answer>.

That uniformity is the main point of the dataset: there is not a single assistant turn without a delimiter. Because of it, a program can look at the model's output and know, without ambiguity, whether to execute a tool or show the text to the user. Leaving the no-tool answers as bare text was tempting, and it would have created one more case for the code to handle.

Loading it

from datasets import load_dataset

ds = load_dataset("annajuliaasf/tool-calling-traces-ptbr")
print(ds)

exemplo = ds["test"][0]
for m in exemplo["messages"]:
    print(f"----- {m['role']}")
    print(m["content"][:300])

To tell the two kinds apart, use the length of the conversation: 5 messages is a tool case, 3 messages is a no-tool case.

The tool catalog and the question list

The conversations alone are not enough to reproduce every measurement, so two more files ship with them, each loadable as its own config:

tools   = load_dataset("annajuliaasf/tool-calling-traces-ptbr", "tools")["train"]
queries = load_dataset("annajuliaasf/tool-calling-traces-ptbr", "queries")["train"]

tools_catalogo.jsonl, 30 lines, one per tool: nome, tipo, descricao, parametros and dificuldade. Each parameter carries its own name, type and whether it is required.

This is the only place the parameter schemas live. Checking whether a model passed every required argument, and whether the types match, means comparing its call against this file. Without it those two checks cannot be reproduced.

queries_geradas.jsonl, 484 lines, one per question: texto_query, the target nome_tool, its tipo_tool and funcao_tool, and dificuldade_query.

This is where the easy, hard and no-tool classification lives. It is not carried inside the conversations, so this file is what lets you reproduce the split table above, or train on a subset of one difficulty.

The three splits

An 80/10/10 split, keeping the same proportion of the three question categories in each part. Without that care, the test set could end up with very few no-tool cases, which are exactly the hardest ones to get right.

split	total	easy	hard	no tool
train	386	172	112	102
validation	47	21	14	12
test	51	23	14	14
total	484	216	140	128

128 examples, 26.4% of the total, use no tool. Those are the ones that teach the model not to call. Without them it learns to always call, because it never saw a case where the right answer was to stay quiet. All 30 tools in the catalog appear.

How it was generated

All through Groq, with two models, each responsible for one part:

step	model	what it produced
1	llama-3.3-70b-versatile	the 30 tools and the user questions
2	qwen/qwen3.6-27b	the conversations of the tool cases
2	llama-3.3-70b-versatile	the answers of the no-tool cases

The tools. Each one has a name, a description and a list of parameters. Each parameter carries its name, its type and whether it is required. When the type is array or object, what goes inside is not described, so an evaluation can check which arguments were passed but not the keys inside them.

The questions. Classified as easy, hard or no-tool at the moment they were created. The 128 in the no-tool group all came out of a single call to the model, asking for 128 at once, and they repeat themselves a fair amount because of it: the 14 that landed in the test set use only 5 distinct sentence shapes.

Each example's catalog. The system message does not list all 30 tools, only a handful. Tool cases list 4: the correct one plus 3 wrong ones drawn at random, with the correct one always in the last position. No-tool cases list 3, all wrong. Which means the number of tools listed indicates whether that example calls for a tool.

The conversations. For each question, the model wrote the call, a simulated tool return and the final answer. It always had to produce a call, there was no option to say information was missing, so on vague questions it filled the arguments with plausible values it made up.

The tags. They were added afterwards, by code, concatenating the strings. No model ever wrote <tool_call> or <final_answer>, which guarantees they are always in the right shape.

Full pipeline: https://github.com/annaferreiras/ft-llm-tool-calling

What it is for

Training or evaluating small models on following the format of tool calling in Portuguese: emitting the right tag, producing valid JSON, stopping after the call, and resisting the urge to call a tool when the question does not ask for one.

A model trained on this data reached 51 out of 51 on the test set, against 27 out of 51 for the same model untrained, receiving the same prompt.

It is not for evaluating knowledge about the world, nor for training against real APIs.

Read the paper - MEDIUM

Licence

model	licence
llama-3.3-70b-versatile	Llama 3.3 Community License
qwen/qwen3.6-27b	Apache 2.0