Ollama 모델 가이드

Ollama 모델 개요

Ollama는 다양한 오픈소스 LLM 모델을 로컬에서 실행할 수 있도록 지원하며, 일부 최신 모델은 cloud 태그로 연동할 수 있습니다. 각 모델은 특정 용도와 하드웨어 환경에 최적화되어 있으므로, 크기와 성능뿐 아니라 로컬 실행 여부, 컨텍스트 길이, 도구 사용 능력까지 함께 고려해야 합니다.

주요 모델 패밀리

Ollama가 지원하는 주요 모델 패밀리는 다음과 같습니다:

모델 선택 프로세스

모델 선택 의사결정 흐름: 용도와 자원에 따라 후보를 좁히는 과정

모델명:크기-양자화

# 예시
llama3.2:7b-instruct-q4_0
│       │   │         └─ 양자화 레벨 (4-bit)
│       │   └─────────── 튜닝 타입 (instruction)
│       └─────────────── 파라미터 크기 (7 billion)
└─────────────────────── 모델 패밀리 (Llama 3.2)

Llama 시리즈

Meta의 Llama (Large Language Model Meta AI)는 가장 인기 있는 오픈소스 LLM 패밀리입니다. Ollama에서 지원하는 Llama 모델은 다음과 같습니다.

Llama 4 (최신)

2025년 4월 출시된 Llama 4는 MoE (Mixture of Experts) 아키텍처를 도입하고 네이티브 멀티모달(이미지+텍스트)을 지원하는 최신 세대입니다.

설치 및 실행

# Llama 4 Scout (MoE 109B, 17B 활성)
ollama run llama4:scout

# Llama 4 Maverick (MoE 400B, 17B 활성)
ollama run llama4:maverick

# 멀티모달 테스트 (이미지 입력)
ollama run llama4:scout "이 이미지에 무엇이 보이나요?" /path/to/image.jpg

Llama 3.2

2024년 9월 출시된 Llama 3.2는 경량화와 멀티모달 기능에 초점을 맞춘 버전입니다.

설치 및 실행

# 기본 모델 다운로드 (7B)
ollama pull llama3.2

# 경량 모델 (1B)
ollama pull llama3.2:1b

# 비전 모델 (이미지 처리)
ollama pull llama3.2:11b-vision

# 실행
ollama run llama3.2
>>> 안녕하세요. 한국어로 답변해주세요.
안녕하세요! 네, 한국어로 답변드리겠습니다. 무엇을 도와드릴까요?

Llama 3.1

2024년 7월 출시된 Llama 3.1은 대규모 컨텍스트 윈도우(128K 토큰)를 지원하며, 최대 405B 파라미터 모델까지 제공합니다.

# Llama 3.1 8B 설치
ollama pull llama3.1:8b

# 특정 양자화 버전 선택
ollama pull llama3.1:8b-instruct-q4_0  # 4-bit 양자화
ollama pull llama3.1:8b-instruct-q8_0  # 8-bit 양자화 (고품질)

# 70B 모델 (강력한 GPU 필요)
ollama pull llama3.1:70b

Llama 3

2024년 4월 출시된 Llama 3는 뛰어난 성능과 안정성으로 여전히 많이 사용됩니다.

CodeLlama - 코딩 특화 모델

CodeLlama는 Llama 2를 코드 생성에 특화시킨 모델입니다. Python, JavaScript, C++, Java 등 다양한 언어를 지원하며, 특히 Python에서 뛰어난 성능을 보입니다.

CodeLlama 변형

실전 활용 예제

# CodeLlama 설치
ollama pull codellama:7b-instruct

# 코드 생성 예제
ollama run codellama:7b-instruct

>>> Write a Python function to calculate Fibonacci numbers with memoization

def fibonacci(n, memo={}):
    """
    Calculate the nth Fibonacci number using memoization.

    Args:
        n: The position in the Fibonacci sequence
        memo: Dictionary to store previously calculated values

    Returns:
        The nth Fibonacci number
    """
    if n in memo:
        return memo[n]

    if n <= 1:
        return n

    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

# 사용 예시
for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")

CodeLlama vs 일반 Llama

Mistral & Mixtral

Mistral AI의 모델들은 효율성과 성능의 균형이 뛰어나며, 프로덕션 환경에서 많이 사용됩니다. Mistral 모델은 Ollama에서 지속적으로 업데이트되고 있습니다.

Mistral Small 3.1 (최신)

Mistral Small 3.1은 비전(이미지 입력) 기능을 지원하는 최신 소형 모델입니다. 24B 파라미터로 효율적이면서도 멀티모달 작업을 처리할 수 있습니다.

# Mistral Small 3.1 설치 (비전 지원)
ollama pull mistral-small3.1

# 실행
ollama run mistral-small3.1

Mistral 7B

Mistral 7B는 7B 파라미터임에도 불구하고 13B 모델과 비슷한 성능을 보이는 것으로 유명합니다.

# Mistral 7B 설치
ollama pull mistral

# Mistral 7B Instruct (대화 최적화)
ollama pull mistral:7b-instruct

# 실행
ollama run mistral:7b-instruct

Mixtral - Mixture of Experts

Mixtral은 MoE (Mixture of Experts) 아키텍처를 사용하여 큰 모델의 성능을 작은 메모리 풋프린트로 구현합니다.

# Mixtral 8x7B 설치
ollama pull mixtral

# Mixtral 8x22B (더 큰 모델)
ollama pull mixtral:8x22b

MoE 아키텍처 원리

MoE 구조: 라우터가 일부 전문가만 활성화해 효율을 높이는 방식

Mistral vs Llama 비교

Phi - 소형 고성능 모델 (Phi-4 시리즈)

Microsoft의 Phi 시리즈는 작은 크기로 큰 모델에 준하는 성능을 제공하는 것이 특징입니다. 최신 Phi-4 시리즈는 복잡한 추론, 수학, 코딩에서 크게 향상된 성능을 보여줍니다.

Phi-4 모델 라인업 (최신)

Phi-3 모델 라인업 (이전 세대)

Phi 사용 예제

# Phi-4 설치 (추론/코딩 최강)
ollama pull phi4

# Phi-4 mini 설치 (경량, function calling)
ollama pull phi4-mini

# Phi-4 reasoning (추론 특화)
ollama pull phi4-reasoning

# 실행
ollama run phi4

>>> 양자 얽힘을 간단하게 설명해줘

양자 얽힘은 마치 두 개의 마법 동전이 신비롭게 연결되어 있는 것과 같습니다. 
하나의 동전을 던져 앞면이 나오면, 다른 동전은 즉시 뒷면이 나옵니다. 
아무리 멀리 떨어져 있어도 이 연결은 빛보다 빠르게 일어납니다. 
이것은 아인슈타인을 당황하게 했고 그는 이를 "잠 Entangled action at a distance"라 불렀습니다.

Phi vs 다른 소형 모델 벤치마크

Gemma - Google의 경량 모델

Google의 Gemma는 Gemini 모델의 기술을 기반으로 개발된 오픈소스 모델입니다. 최신 Gemma 3/4 시리즈는 멀티모달과 140개 이상의 언어를 지원합니다.

Gemma 4 (최신)

Gemma 4는 동영상, 이미지, 텍스트를 모두 처리할 수 있는 멀티모달 모델로, 가변 이미지 해상도를 지원합니다.

Gemma 3

2025년 3월 출시된 Gemma 3는 멀티모달(비전+텍스트)을 지원하며 128K 컨텍스트, 140개 이상의 언어를 처리합니다.

# Gemma 3 4B 설치 (멀티모달, 권장)
ollama pull gemma3:4b

# Gemma 3 27B 설치 (고성능)
ollama pull gemma3:27b

# 실행
ollama run gemma3:4b

Gemma 2 / Gemma 1 (이전 세대)

Gemma의 주요 특징

• 멀티모달: Gemma 3/4에서 이미지, 비디오 입력 지원
• 140개+ 언어: 한국어 포함 광범위한 다국어 지원
• 안전성 강화: 유해 콘텐츠 필터링 내장
• 상업적 사용 가능: 제한 없는 라이선스
• 빠른 추론: 최적화된 추론 속도

Qwen - 다국어 강자

Alibaba의 Qwen (통의천문)은 특히 중국어와 다국어 처리에 강점을 보이는 모델입니다. Qwen 3 시리즈부터 thinking 모드를 지원하며, Apache 2.0 라이선스로 공개되었습니다. 2026년 4월 Qwen 3.6 시리즈가 출시되어 코딩 에이전트 성능에서 큰 도약을 이뤘습니다.

Qwen 3.6 ★ (최신, 2026-04)

2026년 4월 출시된 Qwen 3.6은 코딩 에이전트 성능을 대폭 향상시킨 시리즈입니다. 로컬 오픈소스 모델(Apache 2.0)과 API 전용 플래그십 모델을 모두 제공합니다.

# 경량 MoE (22GB RAM, 소비자 GPU)
$ ollama run qwen3.6:35b-a3b

# 고성능 Dense (충분한 RAM 필요)
$ ollama run qwen3.6:27b

# thinking 모드 활성화 (모델 내장 지원)
$ ollama run qwen3.6:35b-a3b "/think 이 코드의 버그를 찾아줘"

# 컨텍스트 윈도우: 262,144 tokens
# Apache 2.0 라이선스 (상업적 이용 가능)

Qwen 3.5 (이전 세대)

2026년 출시된 Qwen 3.5는 MoE 및 Dense 모델을 제공합니다.

Qwen 3

2025년 4월 출시된 Qwen 3는 Dense 모델과 MoE 모델을 모두 제공하며, thinking 모드(단계별 추론)를 지원합니다. Apache 2.0 라이선스입니다.

Qwen 2 / 2.5 (이전 세대)

Qwen 실전 예제

# Qwen 3 8B 설치 (추천)
ollama pull qwen3:8b

# Qwen 3 32B 설치 (고성능)
ollama pull qwen3:32b

# 코딩 특화 버전 (Qwen2.5-Coder)
ollama pull qwen2.5-coder

# 다국어 테스트
ollama run qwen3:8b

>>> 한국어로 머신러닝을 설명해줘

# 한국어 응답:
머신러닝은 인공지능의 한 분야로, 컴퓨터가 명시적인 프로그래밍
없이도 데이터로부터 학습하고 성능을 개선할 수 있게 합니다.

Qwen의 강점

• thinking 모드: Qwen 3부터 단계별 추론(thinking) 모드 지원
• 다국어: 영어, 중국어, 한국어, 일본어 등 29개+ 언어 지원
• MoE + Dense: 다양한 아키텍처 선택 가능
• 긴 컨텍스트: 최대 128K 토큰
• 수학/코딩: GSM8K, HumanEval에서 높은 점수
• Apache 2.0: 자유로운 상업적 사용

DeepSeek - 추론 + 코딩 전문가

DeepSeek은 특히 추론, 코딩, 수학 문제에 강한 성능을 보이는 중국 기반 모델입니다. DeepSeek R1은 thinking/reasoning 모델로 큰 주목을 받았으며, V3는 범용 고성능 모델입니다.

DeepSeek R1 (추론 모델)

DeepSeek R1은 단계별 사고(thinking/reasoning)를 수행하는 모델입니다. 전체 671B 파라미터 모델 외에 다양한 크기의 distilled(증류) 버전을 제공합니다. 128K 컨텍스트를 지원하며, R1-0528 업그레이드가 적용되었습니다.

DeepSeek V3

DeepSeek V3는 671B MoE (37B 활성) 아키텍처의 범용 모델입니다. 128K 컨텍스트를 지원하며, 2025년 8월 V3.1이 출시되었습니다.

DeepSeek Coder (이전 세대)

DeepSeek Coder는 코딩 특화 모델로, 최신 R1/V3로 대체되고 있습니다.

DeepSeek 사용 예제

# DeepSeek R1 8B 설치 (추론 모델, 추천)
ollama pull deepseek-r1:8b

# DeepSeek R1 32B 설치 (고성능 추론)
ollama pull deepseek-r1:32b

# DeepSeek V3 설치 (범용 고성능)
ollama pull deepseek-v3

# 추론 모델 실행
ollama run deepseek-r1:8b

>>> Implement a B-tree insertion algorithm in Python

class BTreeNode:
    def __init__(self, leaf=True):
        self.keys = []
        self.children = []
        self.leaf = leaf

class BTree:
    def __init__(self, t):
        self.root = BTreeNode()
        self.t = t  # Minimum degree

    def insert(self, key):
        root = self.root
        if len(root.keys) == (2 * self.t) - 1:
            # Root is full, split it
            new_root = BTreeNode(leaf=False)
            new_root.children.append(self.root)
            self._split_child(new_root, 0)
            self.root = new_root
        self._insert_non_full(self.root, key)

    def _split_child(self, parent, index):
        t = self.t
        full_child = parent.children[index]
        new_child = BTreeNode(leaf=full_child.leaf)

        # Split keys
        mid_key = full_child.keys[t - 1]
        new_child.keys = full_child.keys[t:(2 * t) - 1]
        full_child.keys = full_child.keys[0:t - 1]

        # Split children if not leaf
        if not full_child.leaf:
            new_child.children = full_child.children[t:2 * t]
            full_child.children = full_child.children[0:t]

        # Insert mid_key into parent
        parent.keys.insert(index, mid_key)
        parent.children.insert(index + 1, new_child)

    def _insert_non_full(self, node, key):
        i = len(node.keys) - 1

        if node.leaf:
            # Insert into leaf
            node.keys.append(None)
            while i >= 0 and key < node.keys[i]:
                node.keys[i + 1] = node.keys[i]
                i -= 1
            node.keys[i + 1] = key
        else:
            # Find child to insert into
            while i >= 0 and key < node.keys[i]:
                i -= 1
            i += 1

            if len(node.children[i].keys) == (2 * self.t) - 1:
                self._split_child(node, i)
                if key > node.keys[i]:
                    i += 1

            self._insert_non_full(node.children[i], key)

DeepSeek 벤치마크

추가로 볼 만한 최신 모델 패밀리

기존 Llama, Qwen, DeepSeek 외에도 최근 Ollama에서 자주 비교되는 모델들이 빠르게 늘고 있습니다. 특히 코딩 에이전트, 한국어 품질, RAG/도구 호출, 로컬 고성능 추론 관점에서는 아래 계열을 함께 보는 것이 실전적입니다.

gpt-oss

gpt-oss는 OpenAI의 오픈 웨이트 모델로, 로컬 실행 가능한 고성능 추론 계열입니다. Ollama는 MXFP4 양자화를 네이티브 지원하므로 gpt-oss:20b는 16GB급 메모리에서 시작할 수 있고, gpt-oss:120b는 80GB급 GPU 환경을 겨냥합니다. 함수 호출, 구조화 출력, 추론 강도 조절이 필요한 개발용 워크플로에 특히 잘 맞습니다.

# 로컬 고성능 추론 / 에이전트 작업
ollama pull gpt-oss:20b
ollama run gpt-oss:20b

# 더 큰 워크스테이션 / 서버 환경
ollama pull gpt-oss:120b

GLM 계열

GLM 계열은 로컬 태그와 cloud 태그가 공존합니다. glm4는 9B/128K 로컬 모델이고, glm-4.7-flash는 30B-A3B/198K 경량 MoE이며, glm-5:cloud는 최신 Z.ai MoE 계열로 복잡한 코딩과 에이전트 작업을 겨냥합니다. 한중영 혼합 문서, UI 생성, 터미널 중심 코딩 워크플로우에서 후보로 넣어둘 가치가 큽니다.

실무에서 함께 비교할 모델

특수 목적 모델

Ollama는 특정 작업에 특화된 다양한 모델도 지원합니다.

멀티모달 (비전) 모델

비전 모델 사용 예제

# LLaVA 설치
ollama pull llava

# 이미지와 함께 프롬프트 전송
ollama run llava "What's in this image?" /path/to/image.jpg

# API를 통한 이미지 분석
curl http://localhost:11434/api/generate -d '{
  "model": "llava",
  "prompt": "이 이미지를 상세히 설명해줘",
  "images": ["'$(base64 < image.jpg)'"]
}'

임베딩 모델

벡터 검색, RAG (Retrieval-Augmented Generation)에 사용되는 임베딩 모델들입니다.

임베딩 생성 예제

# 임베딩 모델 설치
ollama pull nomic-embed-text

# Python으로 임베딩 생성
import requests

def get_embedding(text):
    response = requests.post(
        'http://localhost:11434/api/embeddings',
        json={
            'model': 'nomic-embed-text',
            'prompt': text
        }
    )
    return response.json()['embedding']

# 사용 예시
text = "Ollama is a tool for running LLMs locally"
embedding = get_embedding(text)
print(f"Embedding dimension: {len(embedding)}")  # 768

기타 특화 모델

양자화 레벨 이해

양자화는 모델의 가중치를 낮은 정밀도로 변환하여 메모리 사용량과 추론 속도를 개선하는 기술입니다.

양자화 타입

양자화 비교 예제

# 다양한 양자화 버전 비교
# Llama 3.2 7B 기준

ollama pull llama3.2:7b-instruct-fp16    # ~14 GB
ollama pull llama3.2:7b-instruct-q8_0    # ~7.7 GB
ollama pull llama3.2:7b-instruct-q6_K    # ~5.9 GB
ollama pull llama3.2:7b-instruct-q5_K_M  # ~5.1 GB (권장)
ollama pull llama3.2:7b-instruct-q4_K_M  # ~4.4 GB
ollama pull llama3.2:7b-instruct-q4_0    # ~4.1 GB
ollama pull llama3.2:7b-instruct-q3_K_M  # ~3.2 GB
ollama pull llama3.2:7b-instruct-q2_K    # ~2.6 GB

양자화 레벨별 품질과 속도의 균형 비교

양자화 명명 규칙 상세

# 양자화 타입 해석
q4_K_M
│ │ └─ M = Medium (중간 품질)
│ └─── K = K-quant 방식
└───── 4 = 4-bit 양자화

# 변형
q4_K_S  # S = Small (가장 빠름, 낮은 품질)
q4_K_M  # M = Medium (균형)
q4_K_L  # L = Large (높은 품질, 느림)

# 레거시 형식
q4_0    # 구식 4-bit 양자화
q4_1    # 개선된 4-bit (bias 추가)

용도별 모델 선택 가이드

작업 유형별 추천

하드웨어별 추천

8GB RAM (통합 그래픽)

• exaone3.5:2.4b - 1.6 GB
• granite3.3:2b - 1.5 GB
• qwen3:1.7b - 1.2 GB
• llama3.2:3b - 2.0 GB

16GB RAM (일반 개발자 노트북)

• gpt-oss:20b - 14 GB 다운로드, 16GB급 메모리부터
• glm4 - 5.5 GB
• exaone3.5:7.8b - 4.8 GB
• granite3.3:8b - 4.9 GB

32GB RAM (고성능 워크스테이션)

• devstral-small-2 - 24B, 32GB Mac / RTX 4090급
• deepseek-r1:32b - 19 GB
• qwen3:32b - 19 GB
• glm-4.7-flash - 19 GB
• gemma3:27b - 16 GB

64GB+ RAM + 고성능 GPU

• gpt-oss:120b - 65 GB
• deepseek-r1:70b - 40 GB
• llama3.1:70b - 40 GB
• mixtral:8x22b - 80 GB

언어별 추천

모델 태그 시스템

Ollama는 Docker와 유사한 태그 시스템을 사용합니다.

태그 예제

# 기본 형식
모델명:태그

# 태그 생략 시 :latest 자동 적용
ollama pull llama3.2
# = ollama pull llama3.2:latest

# 크기 지정
ollama pull llama3.2:7b
ollama pull llama3.2:3b
ollama pull llama3.2:1b

# 크기 + 튜닝 타입
ollama pull llama3.2:7b-instruct
ollama pull llama3.2:7b-text

# 크기 + 튜닝 + 양자화
ollama pull llama3.2:7b-instruct-q4_K_M
ollama pull llama3.2:7b-instruct-q8_0

# 특수 변형
ollama pull llama3.2:11b-vision
ollama pull codellama:7b-python

태그 구성 요소

태그 관리

# 설치된 모델 확인 (태그 포함)
ollama list

NAME                           ID              SIZE      MODIFIED
llama3.2:latest                abc123          4.7 GB    2 days ago
llama3.2:7b-instruct-q4_0      def456          4.1 GB    1 week ago
mistral:7b-instruct-v0.2       ghi789          4.1 GB    3 days ago

# 특정 태그 삭제
ollama rm llama3.2:7b-instruct-q4_0

# 모델 정보 확인
ollama show llama3.2:7b-instruct-q4_0

# 모든 버전 확인 (원격 레지스트리)
ollama search llama3.2

모델 비교 매트릭스

종합 비교

모델 비교는 용도(대화/코딩/다국어), 하드웨어 제약, 지연 시간 목표를 기준으로 판단하는 것이 가장 안전합니다.

객관적 벤치마크 점수

벤치마크 점수는 모델/버전/환경에 따라 크게 달라질 수 있습니다. 동일 조건에서 직접 테스트해 확인하세요.

모델 선택 모범 사례

평가 프로세스

1. 요구사항 정의
   • 주요 작업 유형 (대화, 코딩, 번역 등)
   • 응답 품질 vs 속도 우선순위
   • 다국어 지원 필요성
2. 하드웨어 확인
   • 사용 가능한 RAM/VRAM 크기
   • GPU 유무 및 성능
   • 저장 공간 (모델당 수 GB)
3. 후보 모델 선정
   • 3-5개 후보 모델 리스트업
   • 다양한 양자화 레벨 포함
4. 실전 테스트
   • 실제 사용 케이스로 테스트
   • 응답 품질, 속도, 메모리 사용량 측정
5. 최종 선택
   • 정량적 + 정성적 평가 결합
   • 프로덕션 환경 고려

간단한 테스트 스크립트

#!/bin/bash

# 여러 모델 성능 비교 스크립트

MODELS=("qwen3:8b" "deepseek-r1:8b" "gemma3:4b")
PROMPT="Write a Python function to find prime numbers"

for model in "${MODELS[@]}"; do
    echo "Testing $model..."

    # 시간 측정
    start=$(date +%s)

    # 응답 생성
    ollama run "$model" "$PROMPT" > "result_${model//:/_}.txt"

    end=$(date +%s)
    duration=$((end - start))

    echo "$model: ${duration}s" >> benchmark.txt

    # 메모리 사용량 확인
    ollama ps | grep "$model" >> benchmark.txt

    echo "---" >> benchmark.txt
done

echo "Benchmark complete. Check benchmark.txt for results."

핵심 정리

• 범용 축은 여전히 Llama, Qwen, DeepSeek, Gemma이지만, 실무 후보군은 gpt-oss, GLM, EXAONE, Devstral까지 넓어졌습니다.
• 로컬 태그와 :cloud 태그를 구분해야 하며, 하드웨어 예산과 오프라인 요구 사항이 모델 선택의 첫 기준입니다.
• 코딩 에이전트, 한국어 문서, RAG처럼 작업 성격이 뚜렷할수록 범용 1개보다 특화 모델 2~3개를 A/B 테스트하는 편이 안전합니다.

실무 팁

• 한국어 품질이 중요하면 exaone3.5, qwen3, glm4를 같은 프롬프트 세트로 비교하세요.
• 코딩 에이전트는 devstral-small-2, gpt-oss:20b, deepseek-r1:32b를 기준군으로 두면 판단이 빠릅니다.
• 재현성이 필요하면 :latest와 :cloud를 그대로 쓰지 말고, 구체적인 태그와 실행 조건을 문서화하세요.