🇹🇭 OpenThai Chinda 4B

Latest Model, Think in Thai, Answer in Thai, Built by Thai Startup

OpenThai Chinda 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 OpenThai Chinda 4B)
• 📦 Model Download: https://huggingface.co/iapp/chinda-qwen3-4b
• 🐋 Ollama: https://ollama.com/iapp/chinda-qwen3-4b
• 🏠 Homepage: https://iapp.co.th/openmodels/openthai-chinda-opensource-llm
• 📄 License: Apache 2.0

✨ Key Features

🆓 0. Free and Opensource for Everyone

OpenThai Chinda 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

OpenThai Chinda 4B demonstrates superior performance compared to other Thai language models in its category:

• Alternative: scb10x_typhoon2.1-gemma3-4b
• Tested by Skythought and Evalscope Benchmark Libraries by iApp Technology team. Results show OpenThai Chinda 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 OpenThai Chinda 4B model
ollama pull iapp/chinda-qwen3-4b

Basic Usage:

# Start chatting with OpenThai Chinda
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

OpenThai Chinda 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

OpenThai Chinda 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

1. Monitor Token Count: Keep track of total tokens (input + output)
2. Truncate Old Messages: Remove oldest messages when approaching limits
3. Use YaRN for Long Contexts: Enable rope scaling for documents > 32K tokens
4. 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

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, OpenThai Chinda 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.

Yes! OpenThai Chinda 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!

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.

OpenThai Chinda 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.

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)

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

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

The model weights are open-source, but the specific training datasets are not publicly released. However:

• Base Model: Built on Qwen3-4B (Alibaba's open foundation)
• Thai Optimization: Custom dataset curation for Thai language tasks
• Quality Focus: Carefully selected high-quality Thai content
• Privacy Compliant: No personal or sensitive data included

For research collaborations or dataset inquiries, contact our research team.

For Technical Issues:

• GitHub Issues: Report bugs and technical problems
• Hugging Face: Model-specific questions and discussions
• Documentation: Check our comprehensive guides

For Commercial Support:

• Email: sale@iapp.co.th
• Enterprise Support: Custom training, deployment assistance
• Consulting: Integration and optimization services

Community Support:

• Thai AI Community: Join discussions about Thai AI development
• Developer Forums: Connect with other Chinda users

Model Specifications:

• Parameters: 4.02 billion (4B)
• Download Size: ~8GB (compressed)
• Format: Safetensors (recommended) and PyTorch
• Precision: BF16 (Brain Float 16)

Download Options:

• Hugging Face Hub: huggingface.co/iapp/chinda-qwen3-4b
• Git LFS: For version control integration
• Direct Download: Individual model files
• Quantized Versions: Available for reduced memory usage (GGUF, AWQ)

Quantization Options:

• 4-bit (GGUF): ~2.5GB, runs on 4GB VRAM
• 8-bit: ~4GB, balanced performance/memory
• 16-bit (Original): ~8GB, full performance

📚 Citation

If you use OpenThai Chinda 4B in your research or projects, please cite:

@misc{chinda-llm-4b,
  title={OpenThai Chinda 4B: Thai Sovereign AI Language Model},
  author={iApp Technology},
  year={2025},
  publisher={Hugging Face},
  url={https://huggingface.co/iapp/chinda-qwen3-4b}
}

Built with 🇹🇭 by iApp Technology - Empowering Thai Businesses with Sovereign AI Excellence

Powered by iApp Technology

Disclaimer: Provided responses are not guaranteed.