🇹🇭 Chinda Opensource Thai LLM 4B
Latest Model, Think in Thai, Answer in Thai, Built by Thai Startup

Chinda Opensource Thai LLM 4B is iApp Technology's cutting-edge Thai language model that brings advanced thinking capabilities to the Thai AI ecosystem. Built on the latest Qwen3-4B architecture, Chinda represents our commitment to developing sovereign AI solutions for Thailand.
🚀 Quick Links
- 🌐 Demo: https://chindax.iapp.co.th (Choose ChindaLLM 4b)
- 📦 Model Download: https://huggingface.co/iapp/chinda-qwen3-4b
- 🐋 Ollama: https://ollama.com/iapp/chinda-qwen3-4b
- 📄 License: Apache 2.0
✨ Key Features
🆓 0. Free and Opensource for Everyone
Chinda LLM 4B is completely free and open-source, enabling developers, researchers, and businesses to build Thai AI applications without restrictions.
🧠 1. Advanced Thinking Model
- Highest score among Thai LLMs in 4B category
- Seamless switching between thinking and non-thinking modes
- Superior reasoning capabilities for complex problems
- Can be turned off for efficient general-purpose dialogue
🇹🇭 2. Exceptional Thai Language Accuracy
- 98.4% accuracy in outputting Thai language
- Prevents unwanted Chinese and foreign language outputs
- Specifically fine-tuned for Thai linguistic patterns
🆕 3. Latest Architecture
- Based on the cutting-edge Qwen3-4B model
- Incorporates the latest advancements in language modeling
- Optimized for both performance and efficiency
📜 4. Apache 2.0 License
- Commercial use permitted
- Modification and distribution allowed
- No restrictions on private use
📊 Benchmark Results
Chinda LLM 4B demonstrates superior performance compared to other Thai language models in its category:
Benchmark | Language | Chinda LLM 4B | Alternative* |
---|---|---|---|
AIME24 | English | 0.533 | 0.100 |
Thai | 0.100 | 0.000 | |
LiveCodeBench | English | 0.665 | 0.209 |
Thai | 0.198 | 0.144 | |
MATH500 | English | 0.908 | 0.702 |
Thai | 0.612 | 0.566 | |
IFEVAL | English | 0.849 | 0.848 |
Thai | 0.683 | 0.740 | |
Language Accuracy | Thai | 0.984 | 0.992 |
OpenThaiEval | Thai | 0.651 | 0.544 |
AVERAGE | 0.569 | 0.414 |
- Alternative: scb10x_typhoon2.1-gemma3-4b
Tested by Skythought and Evalscope Benchmark Libraries by iApp Technology team. Results show Chinda LLM 4B achieving 37% better overall performance than the nearest alternative.
✅ Suitable For
🔍 1. RAG Applications (Sovereign AI)
Perfect for building Retrieval-Augmented Generation systems that keep data processing within Thai sovereignty.
📱 2. Mobile and Laptop Applications
Reliable Small Language Model optimized for edge computing and personal devices.
🧮 3. Math Calculation
Excellent performance in mathematical reasoning and problem-solving.
💻 4. Code Assistant
Strong capabilities in code generation and programming assistance.
⚡ 5. Resource Efficiency
Very fast inference with minimal GPU memory consumption, ideal for production deployments.
❌ Not Suitable For
📚 Factual Questions Without Context
As a 4B parameter model, it may hallucinate when asked for specific facts without provided context. Always use with RAG or provide relevant context for factual queries.
🛠️ Quick Start
Installation
pip install transformers torch
Basic Usage
from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "iapp/chinda-qwen3-4b"
# Load the tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype="auto",
device_map="auto"
)
# Prepare the model input
prompt = "อธิบายเกี่ยวกับปัญญาประดิษฐ์ให้ฟังหน่อย"
messages = [
{"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True # Enable thinking mode for better reasoning
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
# Generate response
generated_ids = model.generate(
**model_inputs,
max_new_tokens=1024,
temperature=0.6,
top_p=0.95,
top_k=20,
do_sample=True
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
# Parse thinking content (if enabled)
try:
# Find </think> token (151668)
index = len(output_ids) - output_ids[::-1].index(151668)
except ValueError:
index = 0
thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
print("🧠 Thinking:", thinking_content)
print("💬 Response:", content)
Switching Between Thinking and Non-Thinking Mode
Enable Thinking Mode (Default)
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True # Enable detailed reasoning
)
Disable Thinking Mode (For Efficiency)
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=False # Fast response mode
)
API Deployment
Using vLLM
pip install vllm>=0.8.5
vllm serve iapp/chinda-qwen3-4b --enable-reasoning --reasoning-parser deepseek_r1
Using SGLang
pip install sglang>=0.4.6.post1
python -m sglang.launch_server --model-path iapp/chinda-qwen3-4b --reasoning-parser qwen3
Using Ollama (Easy Local Setup)
Installation:
# Install Ollama (if not already installed)
curl -fsSL https://ollama.com/install.sh | sh
# Pull Chinda LLM 4B model
ollama pull iapp/chinda-qwen3-4b
Basic Usage:
# Start chatting with Chinda LLM
ollama run iapp/chinda-qwen3-4b
# Example conversation
ollama run iapp/chinda-qwen3-4b "อธิบายเกี่ยวกับปัญญาประดิษฐ์ให้ฟังหน่อย"
API Server:
# Start Ollama API server
ollama serve
# Use with curl
curl http://localhost:11434/api/generate -d '{
"model": "iapp/chinda-qwen3-4b",
"prompt": "สวัสดีครับ",
"stream": false
}'
Model Specifications:
- Size: 2.5GB (quantized)
- Context Window: 40K tokens
- Architecture: Optimized for local deployment
- Performance: Fast inference on consumer hardware
🔧 Advanced Configuration
Processing Long Texts
Chinda LLM 4B natively supports up to 32,768 tokens. For longer contexts, enable YaRN scaling:
{
"rope_scaling": {
"rope_type": "yarn",
"factor": 4.0,
"original_max_position_embeddings": 32768
}
}
Recommended Parameters
For Thinking Mode:
- Temperature: 0.6
- Top-P: 0.95
- Top-K: 20
- Min-P: 0
For Non-Thinking Mode:
- Temperature: 0.7
- Top-P: 0.8
- Top-K: 20
- Min-P: 0
📝 Context Length & Template Format
Context Length Support
- Native Context Length: 32,768 tokens
- Extended Context Length: Up to 131,072 tokens (with YaRN scaling)
- Input + Output: Total conversation length supported
- Recommended Usage: Keep conversations under 32K tokens for optimal performance
Chat Template Format
Chinda LLM 4B uses a standardized chat template format for consistent interactions:
# Basic template structure
messages = [
{"role": "system", "content": "You are a helpful Thai AI assistant."},
{"role": "user", "content": "สวัสดีครับ"},
{"role": "assistant", "content": "สวัสดีค่ะ! มีอะไรให้ช่วยเหลือบ้างคะ"},
{"role": "user", "content": "ช่วยอธิบายเรื่อง AI ให้ฟังหน่อย"}
]
# Apply template with thinking mode
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True
)
Template Structure
The template follows the standard conversational format:
<|im_start|>system
You are a helpful Thai AI assistant.<|im_end|>
<|im_start|>user
สวัสดีครับ<|im_end|>
<|im_start|>assistant
สวัสดีค่ะ! มีอะไรให้ช่วยเหลือบ้างคะ<|im_end|>
<|im_start|>user
ช่วยอธิบายเรื่อง AI ให้ฟังหน่อย<|im_end|>
<|im_start|>assistant
Advanced Template Usage
# Multi-turn conversation with thinking control
def create_conversation(messages, enable_thinking=True):
# Add system message if not present
if not messages or messages[0]["role"] != "system":
system_msg = {
"role": "system",
"content": "คุณเป็น AI ผู้ช่วยที่ฉลาดและเป็นประโยชน์ พูดภาษาไทยได้อย่างเป็นธรรมชาติ"
}
messages = [system_msg] + messages
# Apply chat template
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=enable_thinking
)
return text
# Example usage
conversation = [
{"role": "user", "content": "คำนวณ 15 × 23 = ?"},
]
prompt = create_conversation(conversation, enable_thinking=True)
Dynamic Mode Switching
You can control thinking mode within conversations using special commands:
# Enable thinking for complex problems
messages = [
{"role": "user", "content": "/think แก้สมการ: x² + 5x - 14 = 0"}
]
# Disable thinking for quick responses
messages = [
{"role": "user", "content": "/no_think สวัสดี"}
]
Context Management Best Practices
- Monitor Token Count: Keep track of total tokens (input + output)
- Truncate Old Messages: Remove oldest messages when approaching limits
- Use YaRN for Long Contexts: Enable rope scaling for documents > 32K tokens
- Batch Processing: For very long texts, consider chunking and processing in batches
def manage_context(messages, max_tokens=30000):
"""Simple context management function"""
total_tokens = sum(len(tokenizer.encode(msg["content"])) for msg in messages)
while total_tokens > max_tokens and len(messages) > 2:
# Keep system message and remove oldest user/assistant pair
if messages[1]["role"] == "user":
messages.pop(1) # Remove user message
if len(messages) > 1 and messages[1]["role"] == "assistant":
messages.pop(1) # Remove corresponding assistant message
total_tokens = sum(len(tokenizer.encode(msg["content"])) for msg in messages)
return messages
🏢 Enterprise Support
For enterprise deployments, custom training, or commercial support, contact us at:
- Email: sale@iapp.co.th
- Website: iapp.co.th
❓ Frequently Asked Questions
🏷️ Why is it named "Chinda"?
The name "Chinda" (จินดา) comes from "จินดามณี" (Chindamani), which is considered the first book of Thailand written by Phra Horathibodi (Sri Dharmasokaraja) in the Sukhothai period. Just as จินดามณี was a foundational text for Thai literature and learning, Chinda LLM represents our foundation for Thai sovereign AI - a model that truly understands and thinks in Thai, preserving and advancing Thai language capabilities in the digital age.
⚖️ Can I use Chinda LLM 4B for commercial purposes?
Yes! Chinda LLM 4B is released under the Apache 2.0 License, which allows:
- ✅ Commercial use - Use in commercial products and services
- ✅ Research use - Academic and research applications
- ✅ Modification - Adapt and modify the model
- ✅ Distribution - Share and redistribute the model
- ✅ Private use - Use for internal company projects
No restrictions on commercial applications - build and deploy freely!
🧠 What's the difference between thinking and non-thinking mode?
Thinking Mode (enable_thinking=True
):
- Model shows its reasoning process in
<think>...</think>
blocks - Better for complex problems, math, coding, logical reasoning
- Slower but more accurate responses
- Recommended for tasks requiring deep analysis
Non-Thinking Mode (enable_thinking=False
):
- Direct answers without showing reasoning
- Faster responses for general conversations
- Better for simple queries and chat applications
- More efficient resource usage
You can switch between modes or let users control it dynamically using /think
and /no_think
commands.
📊 How does Chinda LLM 4B compare to other Thai language models?
Chinda LLM 4B achieves 37% better overall performance compared to the nearest alternative:
- Overall Average: 0.569 vs 0.414 (alternative)
- Math (MATH500): 0.908 vs 0.702 (English), 0.612 vs 0.566 (Thai)
- Code (LiveCodeBench): 0.665 vs 0.209 (English), 0.198 vs 0.144 (Thai)
- Thai Language Accuracy: 98.4% (prevents Chinese/foreign text output)
- OpenThaiEval: 0.651 vs 0.544
It's currently the highest-scoring Thai LLM in the 4B parameter category.
💻 What are the system requirements to run Chinda LLM 4B?
Minimum Requirements:
- GPU: 8GB VRAM (RTX 3070/4060 Ti or better)
- RAM: 16GB system memory
- Storage: 8GB free space for model download
- Python: 3.8+ with PyTorch
Recommended for Production:
- GPU: 16GB+ VRAM (RTX 4080/A4000 or better)
- RAM: 32GB+ system memory
- Storage: SSD for faster loading
CPU-Only Mode: Possible but significantly slower (not recommended for production)
🔧 Can I fine-tune Chinda LLM 4B for my specific use case?
Yes! As an open-source model under Apache 2.0 license, you can:
- Fine-tune on your domain-specific data
- Customize for specific tasks or industries
- Modify the architecture if needed
- Create derivatives for specialized applications
Popular fine-tuning frameworks that work with Chinda:
- Unsloth - Fast and memory-efficient
- LoRA/QLoRA - Parameter-efficient fine-tuning
- Hugging Face Transformers - Full fine-tuning
- Axolotl - Advanced training configurations
Need help with fine-tuning? Contact our team at sale@iapp.co.th
🌍 What languages does Chinda LLM 4B support?
Primary Languages:
- Thai - Native-level understanding and generation (98.4% accuracy)
- English - Strong performance across all benchmarks
Additional Languages:
- 100+ languages supported (inherited from Qwen3-4B base)
- Focus optimized for Thai-English bilingual tasks
- Code generation in multiple programming languages
Special Features:
- Code-switching between Thai and English
- Translation between Thai and other languages
- Multilingual reasoning capabilities