오픈소스 LLM 완전 정리 (2024-2026)

2024년과 2025년은 오픈소스 LLM 역사에서 가장 격동적인 시기였. Meta의 Llama 3가 GPT-3.5를 넘어서고, DeepSeek이 GPT-4급 성능을 오픈소스로 공개하며 AI 업계를 뒤흔들었. In this guide, 주요 오픈소스 LLM을 아키텍처, 성능, 라이선스, 활용법까지 총정리.

1. 오픈소스 LLM 생태계 Overview

클로즈드 소스 vs 오픈소스 트렌드

2023년 초까지는 GPT-4, Claude 같은 클로즈드 소스 모델이 성능에서 압도적이었. However, 오픈소스 진영이 빠르게 따라잡으면서 2024년 하반기에는 여러 오픈소스 모델이 GPT-4 수준에 도달했.

오픈소스 LLM의 장점:

비용: API 호출 비용 없이 로컬 실행 가능
프라이버시: 데이터가 외부 서버로 전송되지 않음
커스터마이징: 파인튜닝, 양자화, 배포 방식 자유롭게 선택
오프라인 사용: 인터넷 없이도 동작

오픈소스 LLM의 한계:

최고 성능 모델은 여전히 클로즈드 소스
대형 모델 실행을 위한 고사양 하드웨어 필요
안전성 필터링이 약할 수 있음

주요 발전 타임라인

2023년 2월: Meta Llama 1 공개 (7B~65B)
2023년 7월: Meta Llama 2 공개 (상업적 이용 가능)
2023년 9월: Mistral 7B 공개 (같은 크기 최강)
2024년 4월: Meta Llama 3 공개 (8B, 70B)
2024년 6월: Qwen2 공개 (0.5B~72B)
2024년 7월: Llama 3.1 405B 공개
2024년 12월: DeepSeek V3 공개 (671B MoE)
2025년 1월: DeepSeek R1 공개 (추론 특화)
2025년 7월: Llama 3.3 / Llama 4 공개

라이선스 분류

라이선스	대표 모델	상업적 사용	수정 배포
Apache 2.0	Mistral, Gemma, Phi	가능	가능
Meta Llama License	Llama 시리즈	조건부 가능	조건부
MIT	일부 Phi 모델	가능	가능
자체 라이선스	DeepSeek	조건부	제한적

Llama 라이선스의 주요 제약: 월간 활성 사용자 7억 명 이상인 서비스는 별도 계약 필요.

2. Meta Llama 시리즈

Llama 발전 과정

Llama 1 (2023.02): 7B, 13B, 33B, 65B 파라미터. 학술 연구용으로 공개되었으나 빠르게 유출되어 커뮤니티에 퍼졌.

Llama 2 (2023.07): 7B, 13B, 70B. 상업적 이용 허용. Chat 버전과 Code 버전 포함.

Llama 3 (2024.04): 8B, 70B. 128K 어휘 사전, GQA 적용. 이전 세대 대비 성능 크게 향상.

Llama 3.1 (2024.07): 8B, 70B, 405B. 128K 컨텍스트 윈도우, 다국어 지원 강화, 함수 호출 네이티브 지원.

Llama 3.2 (2024.09): 1B, 3B (소형), 11B, 90B (멀티모달). 비전 모델 포함.

Llama 3.3 (2024.12): 70B. 405B 수준 성능을 70B에서 달성.

Llama 3 아키텍처 혁신

# Llama 3 아키텍처 주요 특징
architecture_features = {
    "어휘 사전 크기": "128,256 토큰 (Llama 2의 4배)",
    "포지셔널 인코딩": "RoPE (Rotary Position Embedding)",
    "어텐션 메커니즘": "GQA (Grouped Query Attention)",
    "활성화 함수": "SwiGLU",
    "컨텍스트 윈도우": "8K (Llama 3) / 128K (Llama 3.1+)",
    "학습 데이터": "15T+ 토큰",
}

RoPE (Rotary Position Embedding)

절대 위치 인코딩 대신 상대적 위치를 회전 행렬로 표현. 긴 컨텍스트 일반화에 유리.

GQA (Grouped Query Attention)

Multi-Head Attention(MHA)의 변형으로, 여러 쿼리 헤드가 하나의 키/밸류 헤드를 공유. 추론 속도와 메모리 효율이 크게 향상.

# Multi-Head Attention vs GQA 비교
mha_params = {
    "query_heads": 32,
    "key_heads": 32,     # 쿼리와 동일
    "value_heads": 32,   # 쿼리와 동일
}

gqa_params = {
    "query_heads": 32,
    "key_heads": 8,      # 그룹당 1개
    "value_heads": 8,    # 그룹당 1개
    "메모리 절약": "4배"
}

Llama 3 실전 사용

# HuggingFace를 통한 Llama 3 사용
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch

model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

# 4비트 양자화 (메모리 절약)
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 파이프라인 생성
text_generator = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "머신러닝과 딥러닝의 차이점을 설명해주세요."},
]

output = text_generator(
    messages,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.7,
    top_p=0.9,
)
print(output[0]['generated_text'][-1]['content'])

3. Mistral AI

Mistral 7B

2023년 9월 공개된 7B 모델로, 당시 동일 크기 모델 중 최강 성능을 기록했.

핵심 기술 혁신:

Sliding Window Attention (SWA): 각 토큰이 이전 W개 토큰만 어텐션. 고정 크기 캐시로 무제한 길이 처리가 가능.

Rolling Buffer Cache: KV 캐시를 순환 버퍼로 구현해 메모리를 절약.

Pre-fill and Chunking: 긴 프롬프트를 청크로 나눠 처리.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-7B-Instruct-v0.3"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Mistral 인스트럭션 형식
messages = [
    {"role": "user", "content": "Python으로 퀵소트를 구현해주세요."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=1024,
    do_sample=True,
    temperature=0.7
)

response = tokenizer.decode(generated_ids[0][len(model_inputs.input_ids[0]):], skip_special_tokens=True)
print(response)

Mixtral 8x7B (MoE)

Mixtral은 Mixture of Experts(MoE) 아키텍처를 사용. 총 46.7B 파라미터이지만, 추론 시 12.9B만 활성화.

# MoE 아키텍처 설명
moe_params = {
    "총 전문가 수": 8,
    "활성화되는 전문가": 2,
    "총 파라미터": "46.7B",
    "활성 파라미터": "12.9B",
    "추론 속도": "12.9B 모델과 유사",
    "성능": "70B 모델과 경쟁",
}

4. DeepSeek 시리즈

DeepSeek V3

2024년 12월 중국의 DeepSeek이 공개한 671B MoE 모델. GPT-4o, Claude 3.5 Sonnet과 경쟁하는 성능을 오픈소스로 공개해 업계에 충격을 줬.

Multi-Head Latent Attention (MLA): 핵심 혁신으로, KV 캐시를 저차원 공간으로 압축.

# MLA의 핵심 아이디어 (개념적 코드)
class MultiHeadLatentAttention:
    """
    기존 MHA: K, V 캐시가 토큰 수에 비례해 증가
    MLA: K, V를 저차원 잠재 벡터로 압축 저장
    - 메모리 사용량: 5~13배 감소
    - 성능: MHA와 동등
    """
    def __init__(self, hidden_dim=7168, num_heads=128, kv_lora_rank=512):
        self.hidden_dim = hidden_dim
        self.num_heads = num_heads
        self.kv_lora_rank = kv_lora_rank  # 압축된 KV 차원
        # 기존 KV 캐시: num_heads * head_dim * 2
        # MLA KV 캐시: kv_lora_rank (훨씬 작음)

DeepSeek MoE 혁신:

표준 MoE: 각 레이어에 8개 전문가, 2개 활성화
DeepSeek MoE: 공유 전문가 + 라우팅 전문가 구분
세밀한 전문가 분화로 지식 중복 최소화

# DeepSeek V3 API 사용 (OpenAI 호환)
from openai import OpenAI

client = OpenAI(
    api_key="<DEEPSEEK_API_KEY>",
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Python으로 이진 탐색 알고리즘을 구현해주세요."}
    ],
    stream=False
)

print(response.choices[0].message.content)

DeepSeek R1

2025년 1월 공개된 추론 특화 모델. OpenAI o1과 경쟁하는 수학/코딩 성능을 보여줬.

핵심 특징:

Chain-of-Thought 강화학습: 추론 과정을 RL로 학습
소형 모델 증류: 1.5B~70B 증류 모델 공개
오픈소스: 학습 방법론과 모델 가중치 모두 공개

# DeepSeek R1 사용 예시
client = OpenAI(
    api_key="<DEEPSEEK_API_KEY>",
    base_url="https://api.deepseek.com"
)

# R1은 추론 모델이므로 reasoning_content 포함
response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "1부터 100까지 소수의 합을 구해주세요."}
    ]
)

# 추론 과정
reasoning = response.choices[0].message.reasoning_content
# 최종 답변
answer = response.choices[0].message.content

print("추론 과정 (요약):", reasoning[:200], "...")
print("최종 답변:", answer)

한국 기업 활용 시 고려사항

DeepSeek은 중국 기업이 개발했으므로 기업에서 사용할 때 다음을 고려해야 합니다:

데이터 주권: API 사용 시 데이터가 중국 서버로 전송됨
오픈소스 로컬 실행: 모델 가중치를 자체 서버에 배포하면 데이터 유출 없음
라이선스: 상업적 사용 가능하나 일부 제약 확인 필요
규제 리스크: 특정 산업(금융, 의료, 국방)에서는 사용 전 법적 검토 필요

5. Alibaba Qwen 시리즈

Qwen2 / Qwen2.5

알리바바 클라우드가 개발한 모델 시리즈. 아시아권 언어(중국어, 한국어, 일본어)에서 강점을 보.

# Qwen2.5 사용 예시
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

messages = [
    {"role": "system", "content": "You are Qwen, a helpful assistant."},
    {"role": "user", "content": "한국어로 인공지능 트렌드를 설명해주세요."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=1024,
    temperature=0.7,
    top_p=0.8,
    repetition_penalty=1.05,
)

response_ids = [
    output_ids[len(input_ids):]
    for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = tokenizer.batch_decode(response_ids, skip_special_tokens=True)[0]
print(response)

Qwen2-VL (멀티모달)

이미지, 비디오, 문서를 처리할 수 있는 멀티모달 버전.

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import torch

model = Qwen2VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2-VL-7B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")

# 이미지 분석
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://example.com/chart.png"},
            {"type": "text", "text": "이 차트에서 보이는 트렌드를 한국어로 설명해주세요."},
        ],
    }
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, video_inputs = process_vision_info(messages)

inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    return_tensors="pt",
).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=512)
response = processor.batch_decode(
    [out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)],
    skip_special_tokens=True
)[0]
print(response)

Qwen 모델 라인업 비교

모델	파라미터	특화	컨텍스트
Qwen2.5-0.5B	0.5B	경량	128K
Qwen2.5-7B	7B	범용	128K
Qwen2.5-72B	72B	고성능	128K
Qwen2.5-Coder-7B	7B	코딩	128K
Qwen2.5-Math-7B	7B	수학	4K
Qwen2-VL-7B	7B	멀티모달	128K

6. Google Gemma

Gemma 2 아키텍처

Google DeepMind가 개발한 소형 오픈소스 모델. Gemini 기술을 기반으로 만들었.

핵심 기술:

Interleaved Local/Global Attention: 짝수 레이어는 슬라이딩 윈도우, 홀수 레이어는 글로벌 어텐션
Logit Soft-Capping: 로짓 발산을 막아 학습 안정성 향상
Knowledge Distillation: 대형 Gemma로부터 소형 모델 증류

# Gemma 2 사용
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b-it")
model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-2-9b-it",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)

# Gemma 채팅 형식
chat = [
    {"role": "user", "content": "파이썬의 제너레이터와 이터레이터의 차이점을 설명해주세요."},
]

prompt = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
inputs = tokenizer.encode(prompt, add_special_tokens=False, return_tensors="pt")

outputs = model.generate(
    inputs.to(model.device),
    max_new_tokens=1024,
    do_sample=True,
    temperature=1,
    top_k=50,
    top_p=0.95,
)

response = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
print(response)

모바일/엣지 배포

Gemma는 소형 모델(2B, 9B)이 뛰어난 성능을 보여 모바일 배포에 적합.

# MediaPipe를 통한 온디바이스 실행 (개념)
# Google AI Edge SDK 사용

# Android/iOS에서 Gemma 실행
from mediapipe.tasks.python.genai import bundler, llm_inference

# 모델 번들링
bundler.bundle_model(
    model_path="gemma-2-2b-it-q4_k_m.gguf",
    tokenizer_path="tokenizer.model",
    start_token="<start_of_turn>",
    stop_tokens=["<end_of_turn>"],
    output_path="gemma_bundled.task",
)

7. Microsoft Phi 시리즈

Phi-3 / Phi-4

Microsoft Research가 개발한 소형 고성능 모델 시리즈. "교과서 수준"의 고품질 합성 데이터로 학습된 것이 특징.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "microsoft/Phi-4"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True
)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Explain quantum computing in simple terms."}
]

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

output = pipe(messages, max_new_tokens=512, return_full_text=False)
print(output[0]['generated_text'])

소형 고성능의 비결: 데이터 품질

Phi 시리즈의 The key is 데이터 품질.

학습 데이터 구성 (Phi-3-mini):
- "교과서 수준" 합성 데이터: 약 1T 토큰
- 교과서, 위키피디아, 코드: 고품질 필터링
- 크롤링 데이터: 품질 필터 통과한 것만 사용

"Less is More" 철학:
- 3.8B 파라미터로 7B 모델 성능 달성
- 데이터 효율: 3.3T 토큰으로 학습 (Llama 3의 1/4)

8. 오픈소스 LLM 선택 가이드

태스크별 최적 모델 (2025년 기준)

태스크	권장 모델	이유
일반 대화 (한국어)	EXAONE 3.5 7.8B	한국어 특화
코드 생성	Qwen2.5-Coder-32B	코드 성능 최고
수학/추론	DeepSeek-R1 (증류)	추론 특화
멀티모달	Qwen2-VL / LLaVA	이미지 이해
엣지/모바일	Gemma 2 2B	소형 고성능
범용 고성능	Llama 3.3 70B	균형적 성능
비용 효율	Mistral 7B	빠른 추론

크기별 추천

3B 이하 (GPU 없이 실행 가능):

Phi-3.5-mini (3.8B): 추론 능력 우수
Gemma 2 2B: 다국어 지원
Qwen2.5-1.5B: 경량 모델 중 최강

7B~8B (8GB VRAM):

Llama 3.1 8B: 범용 최고 성능
Mistral 7B: 빠른 추론, Apache 2.0
EXAONE 3.5 7.8B: 한국어 특화

13B~14B (16GB VRAM):

Qwen2.5-14B: 균형적 성능
Phi-4 (14B): 소형 클래스 최강

30B~34B (24GB VRAM):

Qwen2.5-32B: 매우 뛰어난 성능
Mistral-Small

70B+ (80GB VRAM 또는 멀티 GPU):

Llama 3.3 70B: 현재 오픈소스 최강급
Qwen2.5-72B: 다국어 지원 우수
DeepSeek-V3 (671B, MoE): 클라우드 배포 추천

한국어 지원 수준 비교

모델	한국어 이해	한국어 생성	한국 문화 이해
EXAONE 3.5	★★★★★	★★★★★	★★★★★
HyperCLOVA X	★★★★★	★★★★★	★★★★★
Qwen2.5-72B	★★★★	★★★★	★★★
Llama 3.3 70B	★★★	★★★	★★
DeepSeek V3	★★★	★★★	★★
Mistral 7B	★★	★★	★

9. Ollama로 로컬 실행

Ollama 설치와 사용

Ollama는 오픈소스 LLM을 로컬에서 쉽게 실행할 수 있는 도구.

# macOS/Linux 설치
curl -fsSL https://ollama.com/install.sh | sh

# 모델 다운로드 및 실행
ollama run llama3.2

# 다른 모델 예시
ollama run mistral
ollama run qwen2.5:7b
ollama run deepseek-r1:8b
ollama run gemma2:9b

Python에서 Ollama 사용

import ollama

# 간단한 채팅
response = ollama.chat(model='llama3.2', messages=[
    {
        'role': 'user',
        'content': '한국의 전통 음식을 5가지 알려주세요.',
    },
])
print(response['message']['content'])

스트리밍 응답

import ollama

def stream_response(model: str, prompt: str):
    print(f"모델: {model}")
    print(f"프롬프트: {prompt}")
    print("응답: ", end="", flush=True)

    stream = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': prompt}],
        stream=True,
    )

    full_response = ""
    for chunk in stream:
        text = chunk['message']['content']
        print(text, end='', flush=True)
        full_response += text

    print()
    return full_response

response = stream_response('mistral', '파이썬으로 피보나치 수열을 구현해주세요.')

FastAPI + Ollama 서버

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import ollama
import json

app = FastAPI()

@app.post("/chat")
async def chat(request: dict):
    model = request.get("model", "llama3.2")
    message = request.get("message", "")

    async def generate():
        stream = ollama.chat(
            model=model,
            messages=[{"role": "user", "content": message}],
            stream=True,
        )
        for chunk in stream:
            data = {
                "content": chunk["message"]["content"],
                "done": chunk.get("done", False)
            }
            yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

@app.get("/models")
async def list_models():
    models = ollama.list()
    return {"models": [m["name"] for m in models["models"]]}

Ollama 모델별 성능 vs 메모리 요구량

# 모델별 요구 메모리 (FP16 기준)
model_requirements = {
    "llama3.2:3b":    {"vram_gb": 2,  "speed": "매우 빠름",   "quality": "보통"},
    "llama3.2:8b":    {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "mistral:7b":     {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "qwen2.5:7b":     {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "gemma2:9b":      {"vram_gb": 6,  "speed": "보통",       "quality": "좋음"},
    "llama3.3:70b":   {"vram_gb": 40, "speed": "느림",       "quality": "매우 좋음"},
    "qwen2.5:72b":    {"vram_gb": 43, "speed": "느림",       "quality": "매우 좋음"},
    "deepseek-r1:8b": {"vram_gb": 5,  "speed": "보통",       "quality": "추론 특화"},
}

# 양자화 버전 (Q4 기준)
quantized_requirements = {
    "llama3.2:8b-q4":    {"vram_gb": 3,   "speed": "매우 빠름"},
    "llama3.3:70b-q4":   {"vram_gb": 20,  "speed": "보통"},
    "qwen2.5:72b-q4":    {"vram_gb": 22,  "speed": "보통"},
}

10. 오픈소스 LLM 서빙 스택

vLLM (고성능 추론 서버)

pip install vllm

from vllm import LLM, SamplingParams

# 모델 로드
llm = LLM(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    tensor_parallel_size=2,   # GPU 2개 사용
    gpu_memory_utilization=0.9,
    max_model_len=8192,
)

# 배치 추론
prompts = [
    "한국어 NLP의 특징을 설명해주세요.",
    "딥러닝과 머신러닝의 차이점은?",
    "트랜스포머 아키텍처란?",
]

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512,
)

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(f"프롬프트: {output.prompt[:50]}...")
    print(f"응답: {output.outputs[0].text[:200]}")
    print()

vLLM OpenAI 호환 서버

# 서버 실행
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2

# OpenAI 클라이언트로 vLLM 서버 사용
from openai import OpenAI

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

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    messages=[{"role": "user", "content": "안녕하세요!"}],
    max_tokens=256,
)
print(response.choices[0].message.content)

마무리

오픈소스 LLM 생태계는 2024~2026년을 거치면서 놀라운 속도로 발전했. 핵심 정리:

성능:

Llama 3.3 70B / Qwen2.5 72B: 오픈소스 최고 성능
DeepSeek V3/R1: 클로즈드 소스 모델과 경쟁
Phi-4 14B: 소형 모델 중 최강

한국어:

EXAONE 3.5: 한국어 오픈소스 최고
HyperCLOVA X: 한국어 전용 API

배포:

로컬 개발: Ollama
프로덕션: vLLM + OpenAI 호환 API
모바일: Gemma 2 2B + GGUF 양자화

올바른 모델 선택은 태스크, 한국어 지원 수준, 하드웨어 가용성, 라이선스를 종합적으로 고려해야 . 한국어 서비스를 개발does면 EXAONE이나 HyperCLOVA X를 1순위로 검토하고, 범용성이 필요하다면 Llama 3.3 70B나 Qwen2.5 72B를 고려하세요.