Instructions to use Tohirju/Saidzoda-Tajik-LFM-2.6B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Tohirju/Saidzoda-Tajik-LFM-2.6B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Tohirju/Saidzoda-Tajik-LFM-2.6B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Tohirju/Saidzoda-Tajik-LFM-2.6B")
model = AutoModelForCausalLM.from_pretrained("Tohirju/Saidzoda-Tajik-LFM-2.6B", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Tohirju/Saidzoda-Tajik-LFM-2.6B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Tohirju/Saidzoda-Tajik-LFM-2.6B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Tohirju/Saidzoda-Tajik-LFM-2.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Tohirju/Saidzoda-Tajik-LFM-2.6B

SGLang

How to use Tohirju/Saidzoda-Tajik-LFM-2.6B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Tohirju/Saidzoda-Tajik-LFM-2.6B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Tohirju/Saidzoda-Tajik-LFM-2.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Tohirju/Saidzoda-Tajik-LFM-2.6B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Tohirju/Saidzoda-Tajik-LFM-2.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Tohirju/Saidzoda-Tajik-LFM-2.6B with Docker Model Runner:
```
docker model run hf.co/Tohirju/Saidzoda-Tajik-LFM-2.6B
```

You need to agree to share your Hugging Face information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

To get access, please fill in the short form at https://saidzoda.com/access. We approve requests after we receive the form.

Saidzoda-Tajik-LFM-2.6B

A 2.6B-parameter model for tool calling in Tajik, adapted from Liquid AI's LFM2.5-2.6B-Base by Saidzoda AI Lab. Given a request in Tajik (or English) and a list of tools, it answers with a call to the right tool and fills in its arguments. It is small enough to run on modest hardware.

Authors: Tohir Saidzoda, Nekruz Maxudov, Bedil Karimov, Abubakr Abdullozoda, Amin Jalilov, Jonibek Kishvarov, Rahmonali Sharipov, Mariyamkhon Shodyeva (Saidzoda AI Lab, Saidzoda Engineering Company, Dushanbe).

Technical report: Saidzoda-Tajik-LFM-2.6B: Adapting a 2.6B Hybrid Model to Tajik Tool Calling, and What Continued Pretraining Takes Away (arXiv link to be added).

What it is good for, and what it is not

Use it to turn Tajik requests into calls to tools that you define, in a system where a person or an automatic check reviews each call before it runs.

Do not use it:

as a general Tajik chat assistant. Its general Tajik knowledge is limited (see below);
where a wrong call can cause harm without review;
to decline requests by itself. It almost always calls a tool, even when none fits.

Results

Tool calling, on 174 test items per language built from BFCL v3 (Tajik requests machine-translated, tools and answers unchanged). "Full call" means the right function with every argument right. Greedy decoding.

Model	Full call, English	Full call, Tajik	Declines when no tool fits, Tajik
LFM2.5-2.6B-Base	76.55	20.69	31.0
Saidzoda-Tajik-LFM-2.6B	77.24	64.14	6.9

Tajik improves by 43.45 points (95% interval +35.2 to +51.7). English shows no detectable change.
The model picks the right function for 87.98% of Tajik calls; most remaining errors are argument values.
It declines correctly on only 6.9% of Tajik requests that no tool fits (31.0% in English). The base model's Tajik figure (31.0%) uses a parser that also reads its own call formats.
Multi-turn calls are weak: 17.24% in Tajik, 27.59% in English.

General ability (multiple choice, four options, guessing scores 25):

Model	Belebele Tajik	Tajik Curated benchmark	MMLU (English)
LFM2.5-2.6B-Base	37.6	28.0	60.8
Saidzoda-Tajik-LFM-2.6B	40.0	35.0	52.5

Tajik knowledge improves, reading comprehension shows no significant change, and some English knowledge was lost during training on Tajik text.

How to use

The repository holds merged weights in bfloat16 (about 5 GB), the tokenizer and the chat template.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "Tohirju/Saidzoda-Tajik-LFM-2.6B"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype=torch.bfloat16, device_map="auto")

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string", "description": "City name"}},
            "required": ["city"],
        },
    },
}]
messages = [{"role": "user", "content": "Ҳавои Душанбе имрӯз чӣ гуна аст?"}]

inputs = tok.apply_chat_template(messages, tools=tools, add_generation_prompt=True,
                                 return_tensors="pt", return_dict=True).to(model.device)
out = model.generate(**inputs, max_new_tokens=256, do_sample=False)
print(tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=False))

The model answers in the native LFM2.5 format, a Python-style call list between two special tags:

<|tool_call_start|>[get_weather(city='Dushanbe')]<|tool_call_end|>

Your code parses this and runs the tool. We evaluated greedy decoding only.

Training

Two stages, both LoRA with rank-stabilised scaling, trained with axolotl on NVIDIA H100 GPUs:

Continued pretraining on 1,485,319 cleaned Tajik web documents for 3 epochs. This taught the model Tajik but erased its tool-calling format: every checkpoint after this stage scores zero on tool calling.
Supervised fine-tuning, one epoch, on Tajik tool calls (machine-translated from public English tool-calling data), English tool calls kept as replay, and Tajik instructions. This brought tool calling back and lifted Tajik far above the base.

The full recipe, data sources, settings and every evaluation are in the technical report. The eval_results folder holds our original evaluation files, made on an earlier 190-item version of the test set that still contained 16 untranslated requests; the report and this card use the cleaned 174-item set.

Limitations

The Tajik test requests are machine-translated by the same system that translated the training data, and no native speaker has checked them; scores on real user Tajik may be lower.
The model almost never declines when no tool fits. Our data preparation removed every training conversation where the right answer was not to call a tool.
Weak at multi-turn tool use.
General Tajik ability is limited, and English general knowledge dropped during training.
About 3.6 to 5.8% of the continued-pretraining documents were mis-decoded text. We did not measure the effect.
The web text was not filtered for personal data, toxicity or bias, and the model was not evaluated for these.

Licence

This model is a derivative of LiquidAI/LFM2.5-2.6B-Base and is distributed under the LFM Open License v1.0 (see LICENSE). We modified the model weights by continued pretraining and fine-tuning as described above; the tokenizer and chat template are unchanged from the base model. Commercial use is limited by the licence's revenue threshold. "LFM" and "Liquid" are trademarks of Liquid AI and are used here only to describe the origin of the model.

Acknowledgements

We thank NVIDIA for access to the NVIDIA Inception programme, through which the training compute was provided. AI assistants (Anthropic Claude) helped write scripts and draft text; the authors checked every number and are responsible for the content.

Citation

@misc{saidzoda2026tajiklfm,
  title  = {Saidzoda-Tajik-LFM-2.6B: Adapting a 2.6B Hybrid Model to Tajik Tool Calling, and What Continued Pretraining Takes Away},
  author = {Saidzoda, Tohir and Maxudov, Nekruz and Karimov, Bedil and Abdullozoda, Abubakr and Jalilov, Amin and Kishvarov, Jonibek and Sharipov, Rahmonali and Shodyeva, Mariyamkhon},
  year   = {2026},
  note   = {Technical report, Saidzoda AI Lab}
}

Downloads last month: -

Safetensors

Model size

3B params

Tensor type

BF16

Model tree for Tohirju/Saidzoda-Tajik-LFM-2.6B

Base model

LiquidAI/LFM2.5-2.6B-Base

Finetuned

(19)

this model