Marul-SFT-TR

English | Türkçe

Marul-SFT-TR is a Turkish supervised fine-tuning dataset with 99,847 conversations. It was built to teach language models how to be genuinely useful assistants in Turkish: to hold natural multi-turn conversations, follow system prompts, think briefly before answering, call tools when a tool is actually needed and stay honest when they do not know something.

Every conversation is written in Turkish and every assistant turn comes with a short reasoning trace. The data is ready for training as it is. It is not tokenized, so you can use it with any model and any chat template.

At a glance

Conversations	99,847
Messages	662,640 (6.6 per conversation on average)
Multi-turn conversations (2+ user turns)	85,552 (85.7%)
Conversations with a system prompt	78,307 (78.4%), using 55,208 distinct system prompts
Assistant turns with a reasoning trace	291,291 of 291,291 (100%)
Conversations with tool definitions	16,724 (16.7%)
Tool calls	24,510 across 12,778 conversations
Distinct tool names	9,571
Categories	18
Task types	244
Language	Turkish
License	Apache 2.0, attribution required

Why this dataset

Good Turkish instruction data is still scarce. Most of what exists is either translated from English, single-turn, or narrow in scope. Marul-SFT-TR was designed from the ground up for Turkish, with Turkish culture, everyday situations, institutions and ways of speaking in mind. Users in the dataset write the way real people write: some use formal language, some type without Turkish characters, some make spelling mistakes, some use slang or emojis. The assistant learns to understand all of them and to answer in clear, correct Turkish.

How it was built

The conversations were produced with a synthetic data generation pipeline. Each example starts from a detailed recipe: one of 244 task types, a category, a system prompt, a user persona and writing style, a target length, a number of turns and, for tool tasks, a set of tool definitions designed for that scenario. This makes every conversation different in purpose, tone and structure.

Each candidate conversation then went through several layers of quality control:

• Automatic checks. Format, length, language purity, leaked instructions, broken tool calls, robotic or template-like phrasing and other common problems were checked by code.
• Duplicate filtering. Near-duplicate conversations were removed with MinHash similarity during generation, and the final file contains no two identical conversations.
• Judge model review. An independent judge model reviewed every conversation. It looked for factual errors and invented details and redid every calculation. It also checked whether the system prompt and the user's constraints were followed, whether tools were chosen and used correctly, whether tool results were reported faithfully, whether the conversation stayed consistent across turns, whether the reasoning was useful and whether the Turkish was correct and natural. Unnecessary refusals and robotic phrasing lowered the score. Only conversations that scored at least 8 out of 10 with no critical issue were kept. The average score of the kept conversations is 8.58 (8: 44.4%, 9: 52.7%, 10: 2.8%).

Out of 231,718 generation attempts, 100,014 passed every check, an acceptance rate of about 43%. A final audit of the published file removed 167 more conversations with small defects, which leaves 99,847.

Data format

The dataset is a single JSON Lines file, marul_sft_tr.jsonl. Each line is one conversation with two fields:

• messages: the conversation as a list of messages. Every message has the same four keys:
  • role: system, user, assistant or tool
  • content: the text of the message (an assistant message that only calls a tool may have empty content)
  • reasoning_content: the assistant's short reasoning before its answer (only for assistant messages, otherwise null)
  • tool_calls: the tool calls made by the assistant in the OpenAI format, where arguments is a JSON string (only for assistant messages that call a tool, otherwise null)
• tools: the tool definitions available in that conversation, as a JSON string containing a list of tools in the OpenAI function format ({"type": "function", "function": {"name", "description", "parameters"}}), or null when the conversation has no tools. Each conversation defines its own tools, so the list is stored as a string. This keeps the schema identical for every row and makes the dataset fast to load.

Tool results are given in tool messages that follow the assistant's call, in the same order as the calls.

Here is a complete example. The user asks about a property tax debt. The assistant picks the right one of two tools, reads the result and explains it:

{
  "messages": [
    {
      "role": "user",
      "content": "ben vergi borcu kontrol etmek istiyorum emlak vergisi ne kadar çıktı bi bakar mısın",
      "reasoning_content": null,
      "tool_calls": null
    },
    {
      "role": "assistant",
      "content": "",
      "reasoning_content": "Kullanıcı emlak vergisi borcunu soruyor; vergi türü belli, bu yüzden check_tax_debt uygun. trafikCezasi plaka istiyor, burada alakasız. tax_type enum'dan \"emlak\" seçilmeli, zorunlu parametre bu.",
      "tool_calls": [
        {"type": "function", "function": {"name": "check_tax_debt", "arguments": "{\"tax_type\": \"emlak\"}"}}
      ]
    },
    {
      "role": "tool",
      "content": "{\"borclar\":[{\"tur\":\"Emlak\",\"donem\":\"2026/1. taksit\",\"tutar\":1850.0,\"son_odeme\":\"2026-01-31\",\"gecikme_zammi\":0.0}],\"toplam\":1850.0}",
      "reasoning_content": null,
      "tool_calls": null
    },
    {
      "role": "assistant",
      "content": "Emlak vergisinde şu an görünen borç 1.850 TL. Bu 2026 1. taksit ve son ödeme tarihi 31 Ocak 2026. Henüz vadesi geçmediği için gecikme zammı yok, ödemeyi son güne kadar yaparsan ekstra bir ücret çıkmaz.",
      "reasoning_content": "Sonuçta tek bir emlak vergisi kaydı var: 2026/1. taksit, 1850 TL, son ödeme 31 Ocak 2026, gecikme zammı yok. Toplam da 1850 TL. Bunu sade biçimde aktarmalıyım.",
      "tool_calls": null
    }
  ],
  "tools": "[{\"type\": \"function\", \"function\": {\"name\": \"check_tax_debt\", \"description\": \"Kullanıcının vadesi gelmiş vergi borçlarını getirir.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"tax_type\": {\"type\": \"string\", \"description\": \"Vergi türü\", \"enum\": [\"mtv\", \"emlak\", \"gelir\", \"hepsi\"]}}, \"required\": [\"tax_type\"]}}}, {\"type\": \"function\", \"function\": {\"name\": \"trafikCezasi\", \"description\": \"Araç plakasıyla trafik cezası sorgulaması yapar.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"plaka\": {\"type\": \"string\", \"description\": \"Araç plakası, ör. 34 ABC 123\"}}, \"required\": [\"plaka\"]}}}]"
}

What is inside

Categories

The conversations cover 18 categories and 244 task types.

Category	Conversations	Share	Task types	What it covers
Tool use	13,404	13.4%	16	Choosing the right tool from its description, filling arguments from what the user said, sequential and parallel calls, asking for missing information, handling errors and empty results, asking for confirmation before actions, ignoring instructions hidden in tool results, and answering without a tool when none is needed
Language and text processing	8,728	8.7%	19	Summarizing, spelling and punctuation correction, tone rewriting, information extraction, idioms and proverbs, word meanings, grammar, sentiment analysis, restoring Turkish characters, text classification
Knowledge and explanation	8,615	8.6%	15	Science, Turkish and world history, geography, economics, technology, literature, philosophy, art, sports and explaining the same topic at different levels
Everyday conversation and personality	7,716	7.7%	14	Small talk, empathy and emotional support, celebrations and condolences, Turkish culture, jokes and riddles, conversation games, calm answers to rude users
Instruction and system prompt following	6,718	6.7%	14	Customer service assistants bound to a policy, strict format and length rules, topic-limited assistants, conflicts between system and user, role play, rules that change during the conversation
Math	6,278	6.3%	17	Everyday calculations, percentages, arithmetic, classic word problems, geometry, fractions, equations, dates and times, unit conversion, finding mistakes in a user's solution
Creative writing	5,950	6.0%	18	Short stories, story continuation, fairy tales, poems, scripts and dialogue, letters, celebration messages, names and slogans, writing together over several turns
Questions about a provided text	5,122	5.1%	12	Answering only from a pasted document, calculations on tables and JSON, summarizing, interpreting contracts and regulations, saying "this is not in the text" when it is not
Structured output and markdown	4,736	4.7%	15	Markdown tables, JSON that follows a schema, CSV, format conversion, checklists, plans, step by step guides, strict output formats
Practical advice	4,440	4.4%	16	Recipes, general health information, nutrition and exercise, careers and interviews, exams, general legal information, personal finance, travel, official procedures
Honesty and avoiding hallucination	4,365	4.4%	10	Not inventing people, books or sources, correcting false premises, admitting uncertainty, standing by correct answers under pressure, confidence when the answer is known
Logic and multiple choice	4,233	4.2%	12	Multiple choice questions, ordering puzzles, number sequences, syllogisms, analogies, estimation questions, reading comprehension, trick questions
Code and technical	4,228	4.2%	12	Python, SQL, JavaScript, HTML and CSS, Excel formulas, regex, terminal commands, Git, debugging and explaining code
Functional and business writing	4,120	4.1%	16	Emails, petitions in the Turkish official format, social media posts, meeting notes and reports, announcements, customer replies, CVs and cover letters, product descriptions, invitations
Translation	3,353	3.4%	14	English to Turkish and Turkish to English translation of idioms, phrasal verbs, false friends, interface text, marketing copy and news, with cultural adaptation
Web search	3,320	3.3%	8	Searching only when current information is needed, reading pages, handling conflicting sources, citing only the URLs that appear in the results
Identity and capabilities	2,437	2.4%	9	Who the assistant is, what it can and cannot do, questions about other AI models, attempts to change its identity
Safety with balanced refusals	2,084	2.1%	7	Helping fully with harmless questions that only look risky, short and non-judgmental refusals for genuinely harmful requests, privacy, crisis situations, jailbreak attempts

Multi-turn structure

User turns	Conversations	Share
1	14,295	14.3%
2	32,415	32.5%
3	28,893	28.9%
4	19,693	19.7%
5 or more	4,551	4.6%

Later turns build on earlier ones: users ask follow-up questions, change their minds, add constraints or come back to something they said before, and the assistant has to keep track of all of it. Reasoning traces from earlier assistant turns are kept in the conversation, so the model also learns to stay consistent with what it thought before.

System prompts

78.4% of the conversations start with a system prompt, and there are 55,208 different ones. No single system prompt appears more than 471 times.

• 30.0% use general assistant prompts written in different styles.
• 27.2% use a system prompt written specifically for that conversation: a customer assistant for a business with its own prices and policies, a teacher speaking to a child, a formal bank or insurance assistant, a persona with its own rules, an assistant that only helps with one subject, and many more. Some of these include the current date, the user's name or location, which the assistant is expected to use naturally.
• 21.2% use prompts drawn from a large library of role descriptions.
• 21.6% have no system prompt at all, so the model also learns to behave well without one.

User writing styles

Users in the dataset write in 17 different styles so that a trained model understands real Turkish input:

Style	Share	Style	Share
Casual everyday Turkish	32.4%	Phonetic spelling	3.2%
Formal, addressing with "siz"	9.1%	Short and hurried	3.2%
Without Turkish characters	7.9%	Technical expert	2.8%
Long and detailed	7.7%	Shy and apologetic	2.4%
With spelling mistakes	7.3%	Scattered, changing the subject	2.2%
Lowercase without punctuation	5.9%	Elderly and very polite	1.9%
Playful and humorous	3.5%	Angry and impatient	1.9%
Youth slang	3.4%	Mixed with English words	1.9%
With emojis	3.3%

Reasoning

Every assistant message has a reasoning_content field: a short, focused note in Turkish about what the user wants and how to answer (28.7 words on average). It is meant to teach planning without long chains of thought. For tool tasks it explains why one tool fits better than the others based on their descriptions and parameters, not their names. If you do not want reasoning in your model, simply leave this field out.

Tool use

16,724 conversations come with tool definitions, written in the standard JSON Schema format. Tool names and parameters vary a lot (9,571 distinct tool names, 2.9 tools per conversation on average), including Turkish, English and mixed names, so a model has to read the descriptions instead of memorizing names.

• 12,778 conversations contain at least one tool call, 24,510 calls in total.
• 7,138 conversations have calls in more than one assistant turn, for example using the result of one call as the input of the next.
• 1,281 conversations have parallel calls, several independent calls in a single assistant turn.
• 3,946 conversations have tools available but the right answer is not to call any of them, for example small talk, general knowledge or a request no tool can handle.

All tools and tool results are fictional and simulated. They do not refer to real services.

Length and style

A conversation has about 444 words on average (median 409), counting reasoning. Assistant replies with text are 84 words on average (median 68) and their length depends on the task: 6.7% of the conversations are short, 38.6% medium, 39.0% long and 15.6% very long. Conversations are compact: each one fits within roughly 2,000 tokens with a Turkish optimized tokenizer. With two widely used multilingual tokenizers and their chat templates we measured about 900 to 1,100 tokens per conversation on average and at most about 3,500, so a context length of 4,096 tokens covers every conversation. 63.4% of the conversations use markdown formatting where it helps, and 16.8% have emojis in the assistant's replies.

How to use

Loading

from datasets import load_dataset

ds = load_dataset("MarulAI/Marul-SFT-TR", split="train")
print(ds)
print(ds[0]["messages"])

Turning conversations into training text

The easiest way is to render each conversation with the chat template of the model you want to train. The tools field is a JSON string, so parse it first. null fields can simply be dropped.

import json
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("your-base-model")

def clean_messages(messages, keep_reasoning=True):
    out = []
    for m in messages:
        m = {k: v for k, v in m.items() if v is not None}
        if not keep_reasoning:
            m.pop("reasoning_content", None)
        if "tool_calls" in m:
            m["tool_calls"] = [
                {"type": "function", "function": {
                    "name": c["function"]["name"],
                    "arguments": json.loads(c["function"]["arguments"]),
                }}
                for c in m["tool_calls"]
            ]
        out.append(m)
    return out

def render(example):
    messages = clean_messages(example["messages"])
    tools = json.loads(example["tools"]) if example["tools"] else None
    text = tokenizer.apply_chat_template(messages, tools=tools, tokenize=False)
    return {"text": text}

train = ds.map(render, remove_columns=ds.column_names)

Some chat templates read reasoning_content directly. If yours does not, you can put the reasoning inside the assistant message yourself, for example between <think> and </think> tags:

def merge_reasoning(messages):
    for m in messages:
        if m["role"] == "assistant" and m.get("reasoning_content"):
            m["content"] = "<think>\n" + m.pop("reasoning_content") + "\n</think>\n\n" + m.get("content", "")
    return messages

Many reasoning chat templates keep only the reasoning of the turns after the last user message and drop it from earlier turns. To train on every reasoning trace, use a template that keeps past reasoning, or split each conversation into one training sample per assistant turn.

Chat templates differ in what they support. Some accept only one tool call per assistant turn and some do not accept a system message. If yours has such a limit, you can leave out the 1,281 conversations with parallel calls, or move the system prompt into the first user message:

single_call = ds.filter(lambda x: all(len(m["tool_calls"] or []) <= 1 for m in x["messages"]))

For the best results, compute the loss only on the assistant turns and not on the system, user and tool messages. Most training libraries support this through an "assistant only" or "completion only" option.

Filtering

Since every conversation is self-contained, you can filter freely. For example, to keep only conversations with tool calls:

tool_convs = ds.filter(lambda x: any(m["tool_calls"] for m in x["messages"]))

A note on the assistant's identity

The dataset was originally prepared for Yedikule, a Turkish language model developed by Marul AI. Because of that, many system prompts introduce the assistant as Yedikule, and the identity conversations (about 2.4% of the dataset) teach the assistant to say that it is Yedikule, developed by Marul AI. In total, 54,243 conversations mention Yedikule or Marul AI in the system prompt, and 2,250 conversations mention them in an assistant reply or reasoning trace. Users also address the assistant by name in some conversations ("Selam Yedikule").

If you are training a model with a different name, you can leave out the conversations where the assistant talks about its own identity and replace the name everywhere else, in system prompts, user messages and reasoning:

import re

IDENTITY = re.compile(r"Yedikule|Marul AI", re.IGNORECASE)

def no_identity_replies(x):
    return not any(
        m["role"] == "assistant"
        and (IDENTITY.search(m["content"] or "") or IDENTITY.search(m["reasoning_content"] or ""))
        for m in x["messages"]
    )

def rename(x, name="Asistan", org="Şirketim"):
    for m in x["messages"]:
        for key in ("content", "reasoning_content"):
            if m[key]:
                m[key] = m[key].replace("Marul AI", org).replace("Yedikule", name)
    return x

ds_generic = ds.filter(no_identity_replies).map(rename)

Keep in mind that Turkish adds suffixes to names ("Yedikule'nin", "Yedikule'yim"), so check that the suffixes still fit your new name after replacing it.

Intended use

• Supervised fine-tuning of Turkish chat assistants, from small models trained from scratch to large multilingual models that need better Turkish.
• Teaching tool calling, system prompt following and short reasoning in Turkish.
• Research on Turkish instruction following, honesty and conversational behavior.

Limitations

• The conversations are synthetic. They were checked automatically and by a judge model, but not every one was read by a person, so some factual mistakes may remain.
• The knowledge in the conversations reflects the world up to 2026. Dates mentioned in system prompts are part of the scenarios, not real timestamps.
• Health, legal and financial conversations give general information and encourage professional help where needed. They are not professional advice.
• The dataset is focused on Turkish. English appears in translation tasks and in the style of some users.

License

Marul-SFT-TR is released under the Apache License 2.0. Attribution is required:

• If you share the dataset, a part of it or a modified version of it, keep the LICENSE and NOTICE files with it and mark the files you changed.
• If you train or fine-tune a model with it, please credit "Marul-SFT-TR by Ahmet Karakuş (Marul AI)" with a link to this page in your model card, paper or documentation.

Citation

When you use this dataset, please include the following attribution:

This work is based on the Marul-SFT-TR dataset.
Marul-SFT-TR, a Turkish multi-turn SFT dataset with 99,847 conversations.
Ahmet Karakuş, Marul AI, 2026.
https://huggingface.co/datasets/MarulAI/Marul-SFT-TR

For academic work you can use this BibTeX entry:

@misc{karakus2026marulsfttr,
  title        = {{Marul-SFT-TR}: A {Turkish} Multi-Turn Instruction Dataset with Reasoning and Tool Use},
  author       = {Karakuş, Ahmet},
  note         = {Marul AI},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/MarulAI/Marul-SFT-TR}}
}