Mistral AI 2026: Triển khai LLM Local Cấp Production với Kiến trúc 8x7B MoE — Hướng dẫn Thiết lập Đầy đủ

# Cập nhật các gói hệ thống
sudo apt update && sudo apt upgrade -y

# Cài đặt CUDA toolkit (cho GPU NVIDIA)
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install -y cuda-toolkit-12-4

# Xác minh cài đặt CUDA
nvcc --version
nvidia-smi

# Tạo môi trường chuyên dụng
python3 -m venv ~/mistral-env
source ~/mistral-env/bin/activate

# Cài đặt các phụ thuộc cơ bản
pip install --upgrade pip setuptools wheel

# Cài đặt mistral-inference
pip install mistral-inference

# Cài đặt vLLM cho production serving
pip install vllm

# Cài đặt tùy chọn: Hỗ trợ GGUF cho suy luận CPU
pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124

# Cài đặt huggingface-cli
pip install huggingface-hub

# Đăng nhập Hugging Face (bắt buộc cho một số model)
huggingface-cli login

# Tải Mistral 7B Instruct
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir ~/models/mistral-7b-instruct \
  --local-dir-use-symlinks False

# Tải Mixtral 8x7B Instruct
huggingface-cli download mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --local-dir ~/models/mixtral-8x7b-instruct \
  --local-dir-use-symlinks False

# Tải Mistral Nemo
huggingface-cli download mistralai/Mistral-Nemo-Instruct-2407 \
  --local-dir ~/models/mistral-nemo \
  --local-dir-use-symlinks False

from mistral_inference.model import Transformer
from mistral_inference.generate import generate
from mistral_inference.tokenizer import Tokenizer

# Tải model và tokenizer
model_path = "~/models/mistral-7b-instruct"
tokenizer = Tokenizer.from_file(f"{model_path}/tokenizer.model")
model = Transformer.from_folder(model_path, device="cuda")

# Chuẩn bị cuộc trò chuyện
messages = [
    {"role": "user", "content": "Giải thích kiến trúc Mixture of Experts."}
]

# Tokenize với chat template
tokens = tokenizer.encode_chat_completion(messages).tokens

# Tạo phản hồi
result = generate(
    encoded=[tokens],
    model=model,
    tokenizer=tokenizer,
    max_tokens=512,
    temperature=0.7,
    top_p=0.95,
)

print(result[0].text)

# Tải với BF16 (mặc định, khuyến nghị)
model_bf16 = Transformer.from_folder(model_path, device="cuda", dtype="bfloat16")

# Tải với FP16 (nhanh hơn chút, có thể có vấn đề về độ chính xác)
model_fp16 = Transformer.from_folder(model_path, device="cuda", dtype="float16")

# Tải với 8-bit quantization (giảm bộ nhớ)
model_int8 = Transformer.from_folder(model_path, device="cuda", load_in_8bit=True)

# Suy luận CPU (chậm nhưng không cần GPU)
model_cpu = Transformer.from_folder(model_path, device="cpu", dtype="float32")

from mistral_inference.generate import generate

# Chuẩn bị nhiều prompt
batch_prompts = [
    [{"role": "user", "content": "Machine learning là gì?"}],
    [{"role": "user", "content": "Giải thích Docker containers."}],
    [{"role": "user", "content": "TCP/IP hoạt động như thế nào?"}],
]

# Tokenize tất cả prompt
encoded_batch = [
    tokenizer.encode_chat_completion(msgs).tokens 
    for msgs in batch_prompts
]

# Tạo theo lô
results = generate(
    encoded=encoded_batch,
    model=model,
    tokenizer=tokenizer,
    max_tokens=256,
    temperature=0.7,
    batch_size=len(batch_prompts),
)

for i, result in enumerate(results):
    print(f"Phản hồi {i+1}: {result.text}\n")

# Triển khai đơn GPU cho Mistral 7B
python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --dtype bfloat16 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.85 \
  --port 8000

# Triển khai đa GPU cho Mixtral 8x7B
python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --dtype bfloat16 \
  --tensor-parallel-size 2 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --port 8000

# Triển khai 4 GPU cho thông lượng tối đa
python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --dtype bfloat16 \
  --tensor-parallel-size 4 \
  --pipeline-parallel-size 1 \
  --max-num-seqs 256 \
  --max-model-len 32768 \
  --port 8000

model: mistralai/Mistral-7B-Instruct-v0.3
dtype: bfloat16
tensor_parallel_size: 1
max_model_len: 32768
gpu_memory_utilization: 0.85
max_num_seqs: 128
quantization: null

# Giá trị mặc định Sampling
temperature: 0.7
top_p: 0.95
top_k: 40

# Cài đặt máy chủ
port: 8000
host: 0.0.0.0
uvicorn_log_level: info

# Bật chunked prefill liên tục
enable_chunked_prefill: true
max_num_batched_tokens: 4096

# Khởi động với file cấu hình
python -m vllm.entrypoints.openai.api_server \
  --config vllm-config.yaml

# Điểm cuối chat completion
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [
      {"role": "system", "content": "Bạn là một trợ lý lập trình hữu ích."},
      {"role": "user", "content": "Viết hàm Python để phân tích JSON an toàn."}
    ],
    "temperature": 0.2,
    "max_tokens": 512
  }'

# Client Python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed-for-local"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {"role": "user", "content": "Giải thích lợi ích của kiến trúc MoE."}
    ],
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

# Cài đặt công cụ chuyển đổi llama.cpp
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
make -j$(nproc)

# Chuyển đổi Mistral 7B sang GGUF
python convert_hf_to_gguf.py \
  ~/models/mistral-7b-instruct \
  --outfile ~/models/mistral-7b-instruct-q4.gguf \
  --outtype q4_k_m

# Chuyển đổi Mixtral 8x7B (lớn hơn, dùng Q4 cho CPU)
python convert_hf_to_gguf.py \
  ~/models/mixtral-8x7b-instruct \
  --outfile ~/models/mixtral-8x7b-instruct-q4.gguf \
  --outtype q4_k_m

# Khởi động máy chủ với model Q4 quantized
./server \
  -m ~/models/mistral-7b-instruct-q4.gguf \
  -c 4096 \
  -n 512 \
  -t 16 \
  --host 0.0.0.0 \
  --port 8080

# Với GPU offloading (một số layer trên GPU, phần còn lại trên CPU)
./server \
  -m ~/models/mistral-7b-instruct-q4.gguf \
  -ngl 35 \
  -c 8192 \
  -t 8 \
  --host 0.0.0.0 \
  --port 8080

# Điểm cuối completion
curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "<s>[INST] Viết một bài thơ haiku về lập trình [/INST]",
    "n_predict": 128,
    "temperature": 0.7,
    "stop": ["</s>"]
  }'

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="local")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Lấy thờ tiết hiện tại cho một địa điểm",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Tên thành phố, ví dụ Tokyo"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Tìm kiếm cơ sở dữ liệu sản phẩm",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

# Yêu cầu với tools
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {"role": "user", "content": "Thờ tiết ở Tokyo như thế nào?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Kiểm tra tool calls
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"Hàm: {tool_call.function.name}")
    print(f"Tham số: {tool_call.function.arguments}")

import json

# Thực thi công cụ (ví dụ triển khai)
def get_weather(location, unit="celsius"):
    # Triển khai thực tế sẽ gọi weather API
    return {"temperature": 22, "condition": "sunny", "location": location}

# Thêm kết quả công cụ vào cuộc trò chuyện
messages = [
    {"role": "user", "content": "Thờ tiết ở Tokyo như thế nào?"}
]
messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "name": tool_call.function.name,
    "content": json.dumps(get_weather(**json.loads(tool_call.function.arguments)))
})

# Nhận phản hồi cuối cùng
final_response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=messages
)
print(final_response.choices[0].message.content)

from transformers import (
    AutoModelForCausalLM, 
    AutoTokenizer, 
    TrainingArguments, 
    BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
import torch

# Tải model ở chế độ 4-bit để tiết kiệm bộ nhớ
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

tokenizer = AutoTokenizer.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    trust_remote_code=True
)
tokenizer.pad_token = tokenizer.eos_token

# Chuẩn bị model cho việc training
model = prepare_model_for_kbit_training(model)

# Cấu hình LoRA
lora_config = LoraConfig(
    r=16,                    # LoRA rank
    lora_alpha=32,           # Hệ số scale
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

# Tham số Training
training_args = TrainingArguments(
    output_dir="./mistral-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    max_grad_norm=0.3,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    logging_steps=10,
    save_strategy="epoch",
    fp16=False,
    bf16=True,
    optim="paged_adamw_8bit",
    group_by_length=True,
)

# Khởi tạo trainer
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,  # Tập dữ liệu đã chuẩn bị
    args=training_args,
    dataset_text_field="text",
    max_seq_length=2048,
)

# Huấn luyện
trainer.train()

# Lưu adapter
model.save_pretrained("./mistral-lora-adapter")

from peft import PeftModel

# Tải base model
base_model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Merge LoRA adapter
merged_model = PeftModel.from_pretrained(base_model, "./mistral-lora-adapter")
merged_model = merged_model.merge_and_unload()

# Lưu model đã merge
merged_model.save_pretrained("./mistral-finetuned-merged")
tokenizer.save_pretrained("./mistral-finetuned-merged")

# Kiểm tra sức khỏe vLLM
curl http://localhost:8000/health

# Mong đợi: {"status": "healthy"}

# vLLM expose số liệu Prometheus
curl http://localhost:8000/metrics

# Các số liệu chính:
# - vllm:num_requests_running
# - vllm:gpu_cache_usage_perc
# - vllm:time_to_first_token_seconds
# - vllm:time_per_output_token_seconds

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mistral-vllm
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mistral-vllm
  template:
    metadata:
      labels:
        app: mistral-vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.3
          - --dtype
          - bfloat16
          - --tensor-parallel-size
          - "1"
          - --gpu-memory-utilization
          - "0.85"
        ports:
        - containerPort: 8000
        resources:
          limits:
            nvidia.com/gpu: "1"
            memory: "32Gi"
          requests:
            nvidia.com/gpu: "1"
            memory: "16Gi"
        volumeMounts:
        - name: model-cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: model-cache
        persistentVolumeClaim:
          claimName: model-cache-pvc
      nodeSelector:
        accelerator: nvidia-gpu
---
apiVersion: v1
kind: Service
metadata:
  name: mistral-vllm-service
spec:
  selector:
    app: mistral-vllm
  ports:
  - port: 80
    targetPort: 8000
  type: ClusterIP