Ollama vs vLLM 완전 비교 - 기능, 성능, 활용 가이드

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh
 
# Windows
# ollama.com에서 설치 파일 다운로드
 
# 설치 확인
ollama --version

# 모델 다운로드 및 실행 (자동으로 pull)
ollama run llama3.1
 
# 특정 크기의 모델 실행
ollama run llama3.1:8b
ollama run llama3.1:70b
 
# 대화 시작
>>> 안녕하세요, Spark에서 데이터 스큐를 해결하는 방법을 알려주세요.

# 사용 가능한 모델 목록
ollama list
 
# 모델 다운로드만 (실행 없이)
ollama pull llama3.1:8b
 
# 모델 삭제
ollama rm llama3.1:8b
 
# 모델 정보 확인
ollama show llama3.1:8b

# Ollama 설치 시 백그라운드 서버 자동 실행 (포트 11434)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "Kubernetes의 장점을 3가지 알려주세요.",
  "stream": false
}'

# 기본 설치
pip install vllm
 
# 특정 CUDA 버전에 맞춰 설치
pip install vllm --extra-index-url https://download.pytorch.org/whl/cu121

# OpenAI 호환 API 서버 시작
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 4096 \
    --gpu-memory-utilization 0.9

# OpenAI 호환 API로 호출
curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "meta-llama/Llama-3.1-8B-Instruct",
  "messages": [
    {"role": "user", "content": "Kubernetes의 장점을 3가지 알려주세요."}
  ],
  "temperature": 0.7,
  "max_tokens": 512
}'

from vllm import LLM, SamplingParams
 
llm = LLM(
    model="meta-llama/Llama-3.1-8B-Instruct",
    gpu_memory_utilization=0.9,
    max_model_len=4096
)
 
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512
)
 
prompts = [
    "Spark에서 데이터 스큐를 해결하는 방법은?",
    "Kafka 컨슈머 랙이 증가하는 원인은?",
    "Airflow DAG 설계 모범 사례를 알려주세요."
]
 
outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(f"Prompt: {output.prompt[:50]}...")
    print(f"Response: {output.outputs[0].text[:200]}...")
    print("---")

# GPU 사용
docker run -d --gpus all \
    -v ollama:/root/.ollama \
    -p 11434:11434 \
    --name ollama \
    ollama/ollama
 
# 모델 실행
docker exec -it ollama ollama run llama3.1:8b
 
# CPU 전용 (GPU 없이)
docker run -d \
    -v ollama:/root/.ollama \
    -p 11434:11434 \
    --name ollama \
    ollama/ollama

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --max-model-len 4096

# Modelfile: 커스텀 모델 생성
FROM llama3.1:8b
 
# 시스템 프롬프트 설정
SYSTEM """당신은 Data Dynamics의 빅데이터 엔지니어링 전문가입니다.
Apache Spark, Kafka, NiFi, Kudu 등의 기술에 대해 정확하고 실용적인 답변을 제공합니다.
코드 예시를 포함해주세요."""
 
# 파라미터 설정
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER stop "<|eot_id|>"
 
# 템플릿 (선택)
TEMPLATE """{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}
<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""

# 커스텀 모델 생성 및 실행
ollama create dd-engineer -f Modelfile
ollama run dd-engineer

# Hugging Face 모델을 직접 지정하여 실행
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct
 
# 양자화 모델 사용 (AWQ)
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Llama-3.1-8B-Instruct-AWQ \
    --quantization awq
 
# GPTQ 양자화 모델
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Llama-3.1-8B-Instruct-GPTQ \
    --quantization gptq

# LoRA 어댑터를 동적으로 로드
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --enable-lora \
    --lora-modules \
        finance-adapter=./adapters/finance \
        legal-adapter=./adapters/legal \
    --max-lora-rank 16

# API에서 LoRA 어댑터 지정하여 호출
import openai
 
client = openai.OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
 
# 금융 도메인 어댑터 사용
response = client.chat.completions.create(
    model="finance-adapter",  # LoRA 어댑터 이름
    messages=[{"role": "user", "content": "PER 밸류에이션 분석 방법은?"}]
)
 
# 법률 도메인 어댑터 사용
response = client.chat.completions.create(
    model="legal-adapter",    # 다른 LoRA 어댑터
    messages=[{"role": "user", "content": "계약 해지 조건 검토해주세요."}]
)

# vLLM 오프라인 배치 추론
from vllm import LLM, SamplingParams
 
llm = LLM(model="meta-llama/Llama-3.1-8B-Instruct")
sampling_params = SamplingParams(temperature=0.0, max_tokens=256)
 
# 1,000개 프롬프트 배치 처리
prompts = [f"질문 {i}: ..." for i in range(1000)]
outputs = llm.generate(prompts, sampling_params)
# vLLM: ~2분 (A100), Ollama: ~15분 (같은 GPU)

from openai import OpenAI
 
# Ollama (포트 11434)
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # 아무 값이나 가능
)
 
response = client.chat.completions.create(
    model="llama3.1",
    messages=[{"role": "user", "content": "안녕하세요"}],
    temperature=0.7
)
print(response.choices[0].message.content)

from openai import OpenAI
 
# vLLM (포트 8000)
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="vllm"  # 아무 값이나 가능
)
 
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "안녕하세요"}],
    temperature=0.7
)
print(response.choices[0].message.content)

from langchain_ollama import ChatOllama
 
llm = ChatOllama(
    model="llama3.1",
    base_url="http://localhost:11434",
    temperature=0.7
)
 
response = llm.invoke("Spark에서 데이터 스큐를 해결하는 방법은?")
print(response.content)

from langchain_openai import ChatOpenAI
 
# vLLM은 OpenAI 호환이므로 ChatOpenAI 사용
llm = ChatOpenAI(
    model="meta-llama/Llama-3.1-8B-Instruct",
    base_url="http://localhost:8000/v1",
    api_key="vllm",
    temperature=0.7
)
 
response = llm.invoke("Spark에서 데이터 스큐를 해결하는 방법은?")
print(response.content)

# Ollama
from llama_index.llms.ollama import Ollama
llm = Ollama(model="llama3.1", base_url="http://localhost:11434")
 
# vLLM (OpenAI 호환)
from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(
    model="meta-llama/Llama-3.1-8B-Instruct",
    api_base="http://localhost:8000/v1",
    api_key="vllm"
)

import requests
 
def query_ollama(prompt: str, model: str = "llama3.1"):
    """Ollama 네이티브 API 호출"""
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False,
            "options": {
                "temperature": 0.7,
                "num_predict": 512
            }
        }
    )
    return response.json()["response"]
 
def query_vllm(prompt: str, model: str = "meta-llama/Llama-3.1-8B-Instruct"):
    """vLLM OpenAI 호환 API 호출"""
    response = requests.post(
        "http://localhost:8000/v1/chat/completions",
        json={
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.7,
            "max_tokens": 512
        }
    )
    return response.json()["choices"][0]["message"]["content"]

# 개발 환경 세팅 (5분 이내)
ollama pull llama3.1:8b
ollama pull nomic-embed-text  # 임베딩 모델
 
# RAG 프로토타입 개발 시작
python rag_prototype.py

# 프로덕션 배포 (텐서 병렬 + 자동 스케일링)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 8192 \
    --max-num-seqs 256 \
    --host 0.0.0.0 \
    --port 8000

import os
from openai import OpenAI
 
# 환경 변수로 백엔드 전환
if os.getenv("ENV") == "production":
    client = OpenAI(base_url="http://vllm-server:8000/v1", api_key="vllm")
    model = "meta-llama/Llama-3.1-70B-Instruct"
else:
    client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
    model = "llama3.1:8b"
 
# 동일한 API 코드
response = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "안녕하세요"}]
)

# Vision 모델 실행
ollama run llava
 
# 이미지와 함께 질의
>>> [이미지 경로] 이 이미지에 무엇이 보이나요?

# API로 멀티모달 호출
import ollama
import base64
 
with open("chart.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()
 
response = ollama.chat(
    model="llava",
    messages=[{
        "role": "user",
        "content": "이 차트를 분석해주세요.",
        "images": [image_data]
    }]
)

import ollama
 
# 임베딩 생성 (RAG용)
response = ollama.embeddings(
    model="nomic-embed-text",
    prompt="Apache Spark는 분산 데이터 처리 프레임워크입니다."
)
embedding = response["embedding"]  # 768차원 벡터

# Modelfile: 외부 GGUF 파일 사용
FROM ./my-custom-model-Q4_K_M.gguf
 
SYSTEM "당신은 전문 어시스턴트입니다."
PARAMETER temperature 0.7

ollama create my-model -f Modelfile
ollama run my-model

# 4개 GPU로 70B 모델 실행
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4
 
# 8개 GPU로 405B 모델 실행
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-405B-Instruct \
    --tensor-parallel-size 8 \
    --pipeline-parallel-size 1

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --speculative-model meta-llama/Llama-3.1-8B-Instruct \
    --num-speculative-tokens 5

from openai import OpenAI
 
client = OpenAI(base_url="http://localhost:8000/v1", api_key="vllm")
 
# JSON Schema를 강제하여 구조화된 응답 생성
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "서울의 날씨를 알려주세요."}],
    extra_body={
        "guided_json": {
            "type": "object",
            "properties": {
                "city": {"type": "string"},
                "temperature": {"type": "number"},
                "condition": {"type": "string", "enum": ["맑음", "흐림", "비", "눈"]},
                "humidity": {"type": "number"}
            },
            "required": ["city", "temperature", "condition"]
        }
    }
)
# 반드시 지정된 JSON 스키마 형태로 응답

# 여러 LoRA 어댑터를 동시에 로드
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --enable-lora \
    --lora-modules \
        finance=./lora/finance \
        legal=./lora/legal \
        medical=./lora/medical \
    --max-lora-rank 32 \
    --max-num-seqs 256