Instructions to use burkimbia/tengsoaba-4b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use burkimbia/tengsoaba-4b with Transformers:

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

pipe = pipeline("text-generation", model="burkimbia/tengsoaba-4b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("burkimbia/tengsoaba-4b")
model = AutoModelForCausalLM.from_pretrained("burkimbia/tengsoaba-4b", 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=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use burkimbia/tengsoaba-4b with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/burkimbia/tengsoaba-4b

SGLang

How to use burkimbia/tengsoaba-4b 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 "burkimbia/tengsoaba-4b" \
    --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": "burkimbia/tengsoaba-4b",
		"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 "burkimbia/tengsoaba-4b" \
        --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": "burkimbia/tengsoaba-4b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use burkimbia/tengsoaba-4b with Docker Model Runner:
```
docker model run hf.co/burkimbia/tengsoaba-4b
```

You need to agree to share your contact information to access this model

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

Tengsoaba 4B

A 4.02B instruction-tuned model for French ↔ Mooré (mos), built by BurkimbIA. Same seven structured tasks as its 1.7B sibling tengsoaba-1.7b, trained by supervised fine-tuning on moore-instruct-v2.

The name refers to the tẽng-soaba, the master of the land: the custodian of the earth among the Nyonyonsé, the autochthonous people of the region who kept ritual authority over the land.

It translates. It does not converse. A question asked in Mooré that is not a translation request comes back as a restatement of the question. Use the <task> prompts below.

Tasks

Task	Input → Output
`translate_fr_to_moore`	French → Mooré translation
`translate_moore_to_fr`	Mooré → French translation
`correct_moore`	Noisy Mooré → corrected Mooré (spelling / OCR / ASR errors)
`quality_judgment`	A FR-Mooré pair → `correct` / `incorrect` / `a verifier` + short reason
`terminology`	French term → Mooré term (domain-adapted)
`standardize_moore`	Mooré → standard orthography

Prompt format

The model expects the prompts it was trained on. <alphabet> is emitted for translate_fr_to_moore only: the constraint applies when the output is Mooré.

<task>translate_fr_to_moore</task>
<instruction>Traduis le contenu en moore naturel et correct. Produis uniquement la traduction.</instruction>
<alphabet lang="mos">a, ã, b, d, e, ẽ, ɛ, f, g, h, i, ĩ, ɩ, k, l, m, n, o, õ, p, r, s, t, u, ũ, ʋ, v, w, y, z</alphabet>
<input lang="fr">Bonjour, comment allez-vous ?</input>

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "burkimbia/tengsoaba-4b"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype=torch.bfloat16, device_map="cuda")

prompt = (
    "<task>translate_fr_to_moore</task>\n"
    "<instruction>Traduis le contenu en moore naturel et correct. "
    "Produis uniquement la traduction.</instruction>\n"
    "<alphabet lang=\"mos\">a, ã, b, d, e, ẽ, ɛ, f, g, h, i, ĩ, ɩ, k, l, m, n, o, õ, "
    "p, r, s, t, u, ũ, ʋ, v, w, y, z</alphabet>\n"
    "<input lang=\"fr\">Bonjour, comment allez-vous ?</input>"
)

# apply_chat_template returns a dict on transformers >= 5, so tokenize separately.
text = tok.apply_chat_template(
    [{"role": "user", "content": prompt}],
    tokenize=False, add_generation_prompt=True, enable_thinking=False,
)
ids = tok(text, return_tensors="pt").to(model.device)
out = model.generate(**ids, max_new_tokens=192, num_beams=2, do_sample=False)
print(tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True).strip())

enable_thinking=False is required, not optional. Qwen3 thinking mode is on by default, produces its trace in Chinese, consumes the whole token budget, and degrades answers.

Do not use repetition_penalty on this model. Measured 2026-08-24 on 30 held-out pairs from the test split of burkimbia/fr_mos_annotated_split_v2, chrF:

Decoding	fr→mos	mos→fr	seconds
`num_beams=2`	39.6	33.9	2026
greedy	38.4	32.1	923
greedy, `repetition_penalty=1.05`	34.0	31.2	819
greedy, `repetition_penalty=1.15`	30.7	31.1	981

The penalty costs 4.4 chrF at 1.05 and 7.7 at 1.15. This is the opposite of the 1.7B sibling, where 1.05 helps slightly. Decoding settings do not transfer between checkpoints; measure per model.

num_beams=2 buys 1.2 chrF for 2.2x the time. Greedy is a reasonable default here, because a stronger model makes fewer search errors, so beam has less to recover.

How it compares to the 1.7B sibling

Same test set, same prompts, chrF:

	1.7B	4B	Δ
fr→mos, greedy	24.5	38.4	+13.9
mos→fr, greedy	31.4	32.1	+0.7

Capacity helps in one direction only. Generating into a low-resource language is the hard part and benefits from parameters; generating into French is already saturated at 1.7B. An averaged score across directions would have shown +7.3 and hidden this.

Cost of the gain: 8 GB of VRAM against 3.4, and roughly 40x the inference time on a GPU that leaves little headroom after the weights.

Limitations

Low-resource. Mooré has little digital text; the model can produce disfluent or wrong output, especially on long or out-of-domain sentences.
It invents word forms. Its 1.7B sibling was checked against the 129k-pair training corpus and produced words with zero occurrences in it. The outputs use only alphabet-valid characters, which makes invented forms hard to spot without a speaker. Not separately verified on this model; assume the same.
It translates, it does not converse. See the note at the top.
Tone is not written in the Mooré orthography, so homographs exist; the model can pick the wrong sense.
Time-of-day greetings are unreliable. "Bonsoir" and "Bonne nuit" can both come back as the morning greeting.
quality_judgment is a heuristic aid, not a definitive verdict.
Outputs should be reviewed by a Mooré speaker before any downstream use.

Training

Supervised fine-tuning on burkimbia/moore-instruct-v2 (466 250 train rows), 2 epochs. No replay of general-domain data was mixed in, and none was needed: the base capabilities measured intact after training.

Downloads last month: 8

Safetensors

Model size

4B params

Tensor type

BF16