Mistral AI 2026: 8x7B MoE 아키텍처로 프로덕션급 로컬 LLM 배포 — 완전한 설정 가이드

# 시스템 패키지 업데이트
sudo apt update && sudo apt upgrade -y

# CUDA 툴킷 설치 (NVIDIA GPU용)
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

# CUDA 설치 확인
nvcc --version
nvidia-smi

# 전용 환경 생성
python3 -m venv ~/mistral-env
source ~/mistral-env/bin/activate

# 기본 종속성 설치
pip install --upgrade pip setuptools wheel

# mistral-inference 설치
pip install mistral-inference

# 프로덕션 서빙용 vLLM 설치
pip install vllm

# 선택 사항: CPU 추론용 GGUF 지원
pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124

# huggingface-cli 설치
pip install huggingface-hub

# Hugging Face 로그인 (일부 모델에 필요)
huggingface-cli login

# Mistral 7B Instruct 다운로드
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir ~/models/mistral-7b-instruct \
  --local-dir-use-symlinks False

# Mixtral 8x7B Instruct 다운로드
huggingface-cli download mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --local-dir ~/models/mixtral-8x7b-instruct \
  --local-dir-use-symlinks False

# 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

# 모델과 토크나이저 로드
model_path = "~/models/mistral-7b-instruct"
tokenizer = Tokenizer.from_file(f"{model_path}/tokenizer.model")
model = Transformer.from_folder(model_path, device="cuda")

# 대화 준비
messages = [
    {"role": "user", "content": "전문가 혼합 아키텍처를 설명하세요."}
]

# 채팅 템플릿으로 토큰화
tokens = tokenizer.encode_chat_completion(messages).tokens

# 응답 생성
result = generate(
    encoded=[tokens],
    model=model,
    tokenizer=tokenizer,
    max_tokens=512,
    temperature=0.7,
    top_p=0.95,
)

print(result[0].text)

# BF16으로 로드 (기본값, 권장)
model_bf16 = Transformer.from_folder(model_path, device="cuda", dtype="bfloat16")

# FP16으로 로드 (약간 더 빠름, 정밀도 문제 가능)
model_fp16 = Transformer.from_folder(model_path, device="cuda", dtype="float16")

# 8비트 양자화로 로드 (메모리 감소)
model_int8 = Transformer.from_folder(model_path, device="cuda", load_in_8bit=True)

# CPU 추론 (느리지만 GPU 불필요)
model_cpu = Transformer.from_folder(model_path, device="cpu", dtype="float32")

from mistral_inference.generate import generate

# 여러 프롬프트 준비
batch_prompts = [
    [{"role": "user", "content": "머신 러닝이 무엇인가요?"}],
    [{"role": "user", "content": "Docker 컨테이너를 설명하세요."}],
    [{"role": "user", "content": "TCP/IP는 어떻게 작동하나요?"}],
]

# 모든 프롬프트 토큰화
encoded_batch = [
    tokenizer.encode_chat_completion(msgs).tokens 
    for msgs in batch_prompts
]

# 배치로 생성
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"응답 {i+1}: {result.text}\n")

# Mistral 7B 단일 GPU 배포
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

# Mixtral 8x7B 다중 GPU 배포
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

# 최대 처리량을 위한 4 GPU 배포
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

# 샘플링 기본값
temperature: 0.7
top_p: 0.95
top_k: 40

# 서버 설정
port: 8000
host: 0.0.0.0
uvicorn_log_level: info

# 연속 사전 채우기 활성화
enable_chunked_prefill: true
max_num_batched_tokens: 4096

# 구성 파일로 시작
python -m vllm.entrypoints.openai.api_server \
  --config vllm-config.yaml

# 채팅 완성 엔드포인트
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [
      {"role": "system", "content": "당신은 유용한 코딩 어시스턴트입니다."},
      {"role": "user", "content": "JSON을 안전하게 파싱하는 Python 함수를 작성하세요."}
    ],
    "temperature": 0.2,
    "max_tokens": 512
  }'

# 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": "MoE 아키텍처의 이점을 설명하세요."}
    ],
    stream=True
)

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

# llama.cpp 변환 도구 설치
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
make -j$(nproc)

# Mistral 7B를 GGUF로 변환
python convert_hf_to_gguf.py \
  ~/models/mistral-7b-instruct \
  --outfile ~/models/mistral-7b-instruct-q4.gguf \
  --outtype q4_k_m

# Mixtral 8x7B 변환 (더 큼, CPU 사용 위해 Q4)
python convert_hf_to_gguf.py \
  ~/models/mixtral-8x7b-instruct \
  --outfile ~/models/mixtral-8x7b-instruct-q4.gguf \
  --outtype q4_k_m

# Q4 양자화 모델로 서버 시작
./server \
  -m ~/models/mistral-7b-instruct-q4.gguf \
  -c 4096 \
  -n 512 \
  -t 16 \
  --host 0.0.0.0 \
  --port 8080

# GPU 오프로딩 (일부 레이어는 GPU, 나머지는 CPU)
./server \
  -m ~/models/mistral-7b-instruct-q4.gguf \
  -ngl 35 \
  -c 8192 \
  -t 8 \
  --host 0.0.0.0 \
  --port 8080

# 완성 엔드포인트
curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "<s>[INST] 프로그래밍에 대한 하이쿠를 써주세요 [/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": "위치의 현재 날씨를 가져옵니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "도시 이름, 예: 도쿄"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "제품 데이터베이스를 검색합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

# 도구가 있는 요청
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {"role": "user", "content": "도쿄의 날씨는 어떤가요?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# 도구 호출 확인
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"함수: {tool_call.function.name}")
    print(f"인수: {tool_call.function.arguments}")

import json

# 도구 실행 (예시 구현)
def get_weather(location, unit="celsius"):
    # 실제 구현은 날씨 API를 호출합니다
    return {"temperature": 22, "condition": "sunny", "location": location}

# 도구 결과를 대화에 추가
messages = [
    {"role": "user", "content": "도쿄의 날씨는 어떤가요?"}
]
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)))
})

# 최종 응답 가져오기
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

# 메모리 효율을 위해 4비트로 모델 로드
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

# 훈련을 위해 모델 준비
model = prepare_model_for_kbit_training(model)

# LoRA 구성
lora_config = LoraConfig(
    r=16,                    # LoRA 랭크
    lora_alpha=32,           # 스케일링 계수
    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)

# 훈련 인자
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,
)

# 트레이너 초기화
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,  # 준비된 데이터셋
    args=training_args,
    dataset_text_field="text",
    max_seq_length=2048,
)

# 훈련
trainer.train()

# 어댑터 저장
model.save_pretrained("./mistral-lora-adapter")

from peft import PeftModel

# 기본 모델 로드
base_model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# LoRA 어댑터 병합
merged_model = PeftModel.from_pretrained(base_model, "./mistral-lora-adapter")
merged_model = merged_model.merge_and_unload()

# 병합된 모델 저장
merged_model.save_pretrained("./mistral-finetuned-merged")
tokenizer.save_pretrained("./mistral-finetuned-merged")

# vLLM 상태 확인
curl http://localhost:8000/health

# 예상: {"status": "healthy"}

# vLLM이 Prometheus 메트릭을 노출합니다
curl http://localhost:8000/metrics

# 주요 메트릭:
# - 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