Appendix — Vocabulary, Commands and a Learning Path

9.1 Vocabulary

Term	Short definition
Parameter	A number the model learned, counted in billions (B). A rough measure of size
Token	The fragment of text a model sees. Thai costs more tokens than English
Temperature	Randomness in the answer. 0 is the most deterministic, suited to work that must be exact; higher is more varied
Top-p / Top-k	Ways of limiting the candidate next tokens, used alongside temperature to control creativity
System prompt	The instruction that sets the model’s role and rules before the user types anything
KV cache	Memory holding the computation for previous tokens so it need not be redone. The main VRAM consumer at long context
Prefill / Decode	The two phases of answering: reading the prompt (compute-bound) and emitting tokens one at a time (bandwidth-bound)
TTFT	Time to first token — the number users feel most
Batching	Combining several requests so the card processes them together; a large gain in total throughput
Prefix caching	Reusing computation when several prompts share the same opening. A big help in agent work
Speculative decoding	A small model guesses ahead and a large one verifies, giving speed without changing the answer
GQA	A technique that reduces KV head count, shrinking the KV cache substantially — the reason modern models handle long context
Hallucination	The model inventing facts in a confident voice
Guardrail	A checking layer over input and output before it reaches a real user

9.2 Everyday commands

Checking the machine

# Driver and card
nvidia-smi
nvidia-smi -q -d MEMORY,POWER,TEMPERATURE

# The CUDA that PyTorch actually sees
python -c "import torch; print(
  torch.__version__,
  torch.version.cuda,
  torch.cuda.is_available(),
  torch.cuda.get_device_name(0),
  torch.cuda.get_device_properties(0).total_memory/1024**3)"

# Continuous monitoring
watch -n 1 nvidia-smi
nvtop

Managing models

# What is already downloaded, and how large
du -sh ~/.cache/huggingface/hub/* | sort -h
du -sh ~/.ollama/models

# Clear what you no longer use
huggingface-cli delete-cache
ollama rm model-name

# Inspect a model's shape before downloading the weights
python -c "
from transformers import AutoConfig
c = AutoConfig.from_pretrained('Qwen/Qwen3-8B')
print(c.num_hidden_layers,
      c.num_key_value_heads,
      c.hidden_size,
      c.max_position_embeddings)"

9.3 A learning path

Period	What to do
Week 1	Install Ollama and get an 8B model running. Change temperature and the system prompt. Watch nvidia-smi while it runs to see how VRAM moves
Week 2	Call it from code through the API and write one script that does real work. Try 4B / 8B / 14B and compare quality against speed
Week 3	Build your own eval set of 30 cases and measure which model is sufficient. Compute VRAM in advance, then compare with what you actually measure
Week 4	Connect RAG to your own documents — embedding, reranker and LLM — and learn that quality depends on retrieval more than on model size
Month 2	If you must serve several users, move from Ollama to vLLM and benchmark again. If you need domain specificity, try a LoRA fine-tune on one narrow task
Continuously	Every time you hit a problem that is hard to solve, write down the symptom, the cause and the fix. Notes like that will be worth more to you in six months than any article you read

The whole guide in eight lines

1. Not every problem needs an LLM — for tabular data, classical ML is usually better
2. Learn to read a model name; it saves a great deal of time and disk space
3. VRAM decides whether it runs, bandwidth decides how fast
4. Choose a runtime by the shape of the job, not by popularity, and always speak a standard API
5. Compute VRAM at peak concurrency, not at one user — the KV cache is what people forget
6. Choose the smallest model that passes your own test set, not the highest scorer
7. Model files can execute code — default to safetensors and keep trust_remote_code off
8. What the model reads is data, not instruction, and a person must decide anything that matters

This ecosystem moves quickly. The figures and version names in this series are examples meant to show a way of thinking, not a list to follow. What changes slowly is the eight principles above: hold to the principles, and check the numbers against official sources every time you decide.