nanochat: $100 ChatGPT của Karpathy — Xây dựng ứng dụng AI Chat của bạn trên một GPU duy nhất — Hướng dẫn thực tế 2026 #

nanoChat — $100 ChatGPT bạn tự huấn luyện

Introduction #

Crawl4AI đã tăng từ 12.000 lên 63.000 sao GitHub trong 90 ngày. Còn nanochat thì tăng từ 0 lên 54.800 chỉ trong chưa đầy 8 tháng — không có server, không phụ thuộc API key, không có gói đăng ký $20/tháng. Đây là một script Python duy nhất do Andrej Karpathy viết cho phép bạn huấn luyện một ứng dụng chat kiểu ChatGPT từ đầu trên một GPU consumer, chỉ với khoảng $100 compute. Không phải tutorial fine-tuning. Không phải LoRA adapter. Là một ứng dụng chat hoàn chỉnh được xây dựng từ một file Python duy nhất, có streaming, lịch sử hội thoại và web UI. Nếu bạn luôn muốn hiểu những gì xảy ra bên trong giao diện chat AI, nanochat chính là phòng thí nghiệm thực hành.

What Is nanochat? #

nanochat là một ứng dụng chat tối giản mã nguồn mở do Andrej Karpathy viết, minh họa cách xây dựng trải nghiệm kiểu ChatGPT bằng các mô hình bạn tự huấn luyện trên một GPU duy nhất. Nó không phải framework hay thư viện. Đó là một file app.py (~400 dòng) triển khai:

• Tạo văn bản dựa trên token với streaming
• Quản lý lịch sử hội thoại (đa lượt)
• Web UI render qua Streamlit
• Hai chế độ: SGLang (huấn luyện từ đầu với dữ liệu thực) và vLLM (phục vụ mô hình đã huấn luyện trước tại chỗ)

Triết lý là “build để hiểu”. Karpathy có thành tích biến các khái niệm AI phức tạp thành code tối giản — từ nanoGPT đến karpathy/llm.c — và nanochat tiếp nối truyền thống này bằng cách cho bạn thấy chính xác chat app hoạt động như thế nào, từ đầu đến cuối.

How nanochat Works #

nanochat hoạt động ở hai chế độ riêng biệt, mỗi chế độ có pipeline training/inference khác nhau:

Chế độ SGLang: Huấn luyện từ đầu #

Corpus văn bản thô → Huấn luyện tokenizer → Huấn luyện mô hình → Chat UI

1. Thu thập dữ liệu — Tải xuống và parse một corpus văn bản (vd: Wikipedia, sách, code)
2. Huấn luyện tokenizer — Huấn luyện BPE (BytePair Encoding) tokenizer trên corpus
3. Huấn luyện mô hình — Huấn luyện transformer kiểu GPT bằng distributed training của SGLang
4. Phục vụ chat — Mô hình đã huấn luyện được phục vụ qua giao diện web của nanochat

Chế độ vLLM: Phục vụ mô hình pre-trained #

Mô hình pre-trained (HuggingFace) → vLLM serving → Chat UI

1. Tải mô hình — Pull mô hình pre-trained từ HuggingFace (vd: Qwen, Llama, Mistral)
2. vLLM serving — Sử dụng PagedAttention của vLLM cho inference throughput cao
3. Phục vụ chat — Nanochat wrap endpoint vLLM với web UI chat streaming

┌──────────────────────────────────────────────┐
│              nanochat Web UI                 │
│           (Streamlit + WebSocket)             │
├──────────────────────────────────────────────┤
│           SGLang / vLLM Inference Engine      │
├──────────────────────────────────────────────┤
│  Chế độ SGLang: Huấn luyện từ đầu  │  Chế độ vLLM: Phục vụ mô hình HF  │
└──────────────────────────────────────────────┘

Kiến trúc nanoChat: hai chế độ, một web UI

Insight cốt lõi: cả hai chế độ dùng chung giao diện chat. Chỉ khác là bạn generate token từ mô hình tự huấn luyện (SGLang) hay mô hình tải về (vLLM).

Installation & Setup #

Yêu cầu tiên quyết #

Bạn cần một máy có ít nhất một GPU. Cho chế độ SGLang (huấn luyện từ đầu), khuyến nghị 8+ GB VRAM. Cho chế độ vLLM, 6+ GB VRAM hoạt động cho mô hình nhỏ.

# Clone repository
git clone https://github.com/karpathy/nanochat.git
cd nanochat

# Tạo virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Cài đặt dependencies
pip install -r requirements.txt

Tùy chọn A: Chế độ SGLang — Huấn luyện từ đầu #

# Cài đặt SGLang (cần CUDA 12.x)
pip install sglang

# Huấn luyện tokenizer trên corpus
python train_tokenizer.py --input data/wikipedia.txt --output tokenizer.json --vocab_size 50000

# Huấn luyện mô hình (vd: GPT 1B parameter)
python train_model.py --tokenizer tokenizer.json --epochs 3 --batch_size 32

# Khởi chạy chat app
python app.py --mode sglang --model_path checkpoints/latest.pth

Tùy chọn B: Chế độ vLLM — Phục vụ mô hình pre-trained #

# Cài đặt vLLM (cần CUDA 12.x)
pip install vllm

# Khởi chạy vLLM server với mô hình HuggingFace
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-1.5B-Instruct \
  --port 8000 \
  --max-model-len 4096

# Khởi chạy chat app (chỉ đến vLLM)
python app.py --mode vllm --api_url http://localhost:8000/v1/chat/completions

Quick Start — Docker #

Cho cài đặt nhanh nhất, dùng Dockerfile có sẵn:

# Build Docker image
docker build -t nanochat .

# Chạy với GPU support
docker run --gpus all -p 8501:8501 nanochat \
  --mode vllm --model Qwen/Qwen2.5-3B-Instruct

Truy cập web UI tại http://localhost:8501.

Integration with SGLang, vLLM, HuggingFace Models #

nanochat được thiết kế để hoạt động mượt mà với hệ sinh thái AI inference rộng hơn:

Tích hợp SGLang #

SGLang (Structured Generation Language) là backend training. Cung cấp distributed training capabilities tối ưu cho transformer models:

# sglang_config.py — cài đặt đặc thù SGLang
config = {
    "model_type": "gpt",
    "vocab_size": 50000,
    "num_hidden_layers": 24,
    "num_attention_heads": 16,
    "hidden_size": 1024,
    "intermediate_size": 4096,
    "max_position_embeddings": 4096,
    "learning_rate": 3e-4,
    "warmup_ratio": 0.05,
    "weight_decay": 0.01,
    "bf16": True,
}

Tích hợp vLLM #

vLLM cung cấp inference throughput cao với PagedAttention, quản lý KV cache memory động:

# vllm_config.py — cài đặt serving vLLM
from vllm import LLM, SamplingParams

llm = LLM(
    model="Qwen/Qwen2.5-7B-Instruct",
    tensor_parallel_size=1,
    max_model_len=8192,
    enable_chunked_prefill=True,
)

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=2048,
    stop=["\n\n"],
)

Tương thích mô hình HuggingFace #

nanochat hỗ trợ mọi mô hình HuggingFace tuân theo kiến trúc transformer tiêu chuẩn:

Cho self-hosting production, tôi khuyên dùng DigitalOcean GPU droplets hoặc HTStack cho kết nối độ trễ thấp đáng tin cậy đến model repositories.

Benchmarks / Real-World Use Cases #

Benchmark Huấn luyện SGLang #

Performance training trên RTX 4090 đơn (24 GB VRAM), huấn luyện GPT 1B parameter trên 10GB corpus:

Benchmark Inference vLLM #

Serving Qwen2.5-7B-Instruct trên A10G đơn (24 GB VRAM):

Use Case thực tế 1: Giáo dục — Dạy fundamentals LLM #

Giáo sư CS dùng nanochat để dạy sinh viên cách LLM hoạt động:

# Sinh viên bắt đầu với tokenizer training
python train_tokenizer.py --input data/shakespeare.txt --output tokenizer.json
# Rồi train 200M model trên corpus Shakespeare
python train_model.py --tokenizer tokenizer.json --epochs 2 --batch_size 16
# Chat với mô hình tự huấn luyện
python app.py --mode sglang --model_path checkpoints/epoch2.pth

Điều này cho sinh viên trải nghiệm thực tế về tokenization, training loop và inference mà không textbook nào sánh được.

Use Case thực tế 2: Prototype custom chatbots #

Kỹ sư prototype startup dùng nanochat để test custom-trained chatbots trước khi commit cho production:

# Train trên company-specific documentation
python train_tokenizer.py --input data/docs/ --output company_tokenizer.json
python train_model.py --tokenizer company_tokenizer.json --epochs 5
# So sánh responses
# Prompt: "Làm sao reset mật khẩu?"
# Model A (general): "Truy cập trang settings..."
# Model B (custom-trained): "Tới /auth/reset hoặc email support@company.com..."

Custom-trained model tạo responses domain-specific mà general models không thể.

Advanced Usage / Production Hardening #

Multi-GPU SGLang Training #

Cho models lớn hơn hoặc training nhanh hơn, SGLang hỗ trợ multi-GPU distributed training:

# Train trên 4 GPUs
python -m torch.distributed.run \
  --nproc_per_node=4 \
  train_model.py \
  --tokenizer tokenizer.json \
  --epochs 5 \
  --distributed_backend nccl

Custom Chat System Prompts #

Chỉnh sửa app.py để customize system prompt:

# System prompt tùy chỉnh trong app.py
SYSTEM_PROMPT = """Bạn là trợ lý lập trình hữu ích chuyên về Python.
Luôn cung cấp ví dụ code với comment.
Sử dụng định dạng markdown cho code blocks."""

Docker Production Deployment #

Cho production deployment lên cloud provider:

FROM nvidia/cuda:12.2-runtime-ubuntu22.04
RUN apt-get update && apt-get install -y python3 python3-pip git
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt
WORKDIR /app
COPY . .
EXPOSE 8501
CMD ["python3", "app.py", "--mode", "vllm", "--model", "Qwen/Qwen2.5-7B-Instruct"]

# Deploy trên DigitalOcean GPU droplet
docker run -d --gpus all -p 8501:8501 \
  --restart unless-stopped \
  nanochat:latest

Comparison with Alternatives #

Limitations / Honest Assessment #

nanochat không dành cho tất cả mọi người. Đây là lúc nó không phù hợp:

1. Production chatbot — nanochat là công cụ học tập và prototype platform, không phải production-grade chatbot service. Thiếu authentication, rate limiting, load balancing và monitoring mà production systems cần.

2. Machines không GPU — Không GPU, training không thực tế (vài tuần đến vài tháng). Inference vLLM cũng cần GPU; CPU-only inference cực chậm (1-2 tokens/second cho 3B model).

3. Training models lớn từ đầu — Huấn luyện models lớn hơn 3B parameters từ đầu trên single GPU cực chậm (vài tuần cho 7B model). Cân nhắc cloud GPU services như DigitalOcean GPU droplets cho models lớn hơn.

4. Real-time responsiveness — Streamlit UI của nanochat không tối ưu cho low-latency chat. Mong đợi 200-500ms response latency cho typical interactions, đủ tốt cho learning nhưng không đủ cho production UX.

5. Multi-language tokenization — Huấn luyện tokenizer trên non-English corpora cần data preparation cẩn thận. BPE tokenizer hoạt động tốt cho Latin-script languages nhưng có thể cần adjustments cho CJK tokenization.

Frequently Asked Questions #

Q: Có cần API key để dùng nanochat không?

A: Không. Không cần API key. nanochat hoàn toàn self-hosted. Khi dùng SGLang mode, bạn train model tại chỗ không có external API calls. Khi dùng vLLM mode, bạn serve model tại chỗ từ HuggingFace — không cần Anthropic hay OpenAI key.

Q: Cần GPU loại nào?

A: Cho training (SGLang mode), GPU 8+ GB VRAM (RTX 3060 12GB, RTX 4090 24GB) khuyến nghị. Cho serving pre-trained models (vLLM mode), 4+ GB VRAM hoạt động cho smaller models (1.5B-3B), 8+ GB cho 7B models, 24+ GB cho 13B+ models.

Q: Training mất bao lâu?

A: Trên RTX 4090 đơn (24 GB VRAM), training 1B parameter model trên 10GB corpus mất khoảng 4 giờ per epoch. 3B model mất khoảng 12 giờ per epoch. Các số này scale linearly với model size và inversely với GPU compute capability.

Q: Có thể dùng cloud GPU cho nanochat không?

A: Có. Docker setup hoạt động trên mọi cloud GPU provider. Cho cost-effective options, cân nhắc HTStack GPU instances hoặc DigitalOcean GPU droplets. Chỉ cần mount model weights hoặc training data làm volume.

Q: nanochat có phù hợp cho production deployment không?

A: nanochat được thiết kế là educational prototype và research tool. Thiếu production features như authentication, rate limiting và load balancing. Cho production chatbot deployments, cân nhắc build trên top của kiến trúc nanochat dùng proper production frameworks như FastAPI, LangServe hoặc vLLM deployment tools.

Sources & Further Reading #

• Tài liệu chính thức: https://github.com/karpathy/nanochat
• SGLang framework: https://sgl.ai
• vLLM inference engine: https://vllm.ai
• HuggingFace model hub: https://huggingface.co
• nanoGPT của Karpathy (predecessor project): https://github.com/karpathy/nanoGPT

Conclusion: $100 ChatGPT là thật — Đây là cách làm #

nanochat chứng minh bạn không cần $20/tháng API subscription hay datacenter để chạy ứng dụng chat kiểu ChatGPT. Với một consumer GPU duy nhất và khoảng $100 compute credits, bạn có thể train model của riêng mình và deploy fully functional chat interface. Code là transparent (~400 dòng), training pipeline là complete (tokenizer → model → chat), và results là immediately observable.

Dù bạn là sinh viên học LLM fundamentals, developer prototype custom chatbot, hoặc chỉ là người muốn hiểu những gì xảy ra bên trong “black box”, nanochat mang lại trải nghiệm thực hành mà không tutorial video nào sánh được.

Tham gia nhóm Telegram dibi8 tiếng Việt để thảo luận kinh nghiệm và cấu hình huấn luyện nanochat. Xem hướng dẫn về Langflow visual workflows và AI Agent memory systems cho các công cụ bổ trợ. Thử nanochat ngay hôm nay — clone repo, chạy python app.py, và xem model của bạn phản hồi.

Một số liên kết bên trên là liên kết tiếp thị. Nếu bạn đăng ký qua các liên kết này, dibi8.com có thể nhận hoa hồng mà bạn không tốn thêm chi phí.