[active] Zeta의 비용 구조를 참고한 저비용 AI 챗봇 아키텍처

# Zeta의 비용 구조를 참고한 저비용 AI 챗봇 아키텍처

## 💡 핵심 아이디어

**Zeta가 증명한 것:**
- 자체 sLLM = 비용 90% 절감
- Freemium = 안정적 수익
- 몰입도 > 사용자 수

**여기에 Elixir/Phoenix를 더하면?**
- 인프라 비용 70% 추가 절감
- **총 비용 44% 절감 (vs Node.js + sLLM)**
- **96% 절감은 GPT-4o 대비 (불공정 비교)**

---

## 📊 비용 비교: 3가지 아키텍처

### 시나리오: MAU 10만, 월 500만 메시지

**1) Node.js + OpenAI API (일반적)**
```
LLM 비용:
- GPT-4o-mini: $975/월
- GPT-4o: $16,250/월

인프라:
- Node.js 서버 (t3.large × 5): $500/월
- DB: $200/월
- Redis: $100/월

총 비용: $1,775/월 (GPT-4o-mini)
```

**2) Node.js + 자체 sLLM (Zeta 방식)**
```
LLM 비용:
- GPU 서버 (g5.xlarge × 1): $650/월

인프라:
- Node.js 서버 (t3.large × 5): $500/월
- DB: $200/월
- Redis: $100/월

총 비용: $1,450/월
→ 절감: 18% vs OpenAI
```

**3) Elixir + 자체 sLLM (최적)**
```
LLM 비용:
- GPU 서버 (g5.xlarge × 1): $650/월

인프라:
- Phoenix 서버 (t3.large × 2): $200/월
- DB: $150/월
- Redis: $0 (Phoenix PubSub 내장)

총 비용: $1,000/월
→ 절감: 44% vs Node.js + sLLM (공정한 비교)
→ 절감: 96% vs Node.js + GPT-4o (최악 대 최선 비교)
```

**⚠️ 비용 비교 주의사항:**
- 44% 절감은 같은 조건 (자체 sLLM) 비교
- 96% 절감은 GPT-4o($16,250)와 비교한 것으로 불공정한 비교
- **현실적인 절감: 44%**

---

## 🚀 Elixir가 비용을 줄이는 방식

### 1. 동시성 = 서버 수 감소
```
BEAM VM:
- 경량 프로세스 수백만 개 동시 처리
- Discord: 500만 동시 접속, Elixir 5개 노드

비교:
- Node.js: 동시 접속 10만 → 서버 10대
- Elixir: 동시 접속 10만 → 서버 2대

→ 서버 비용 70% 감소
```

### 2. 실시간 스트리밍 = 별도 인프라 불필요
```elixir
# Phoenix Channels로 LLM 스트리밍
defmodule ZetaWeb.ChatChannel do
use Phoenix.Channel

def handle_in("message", %{"text" => text}, socket) do
Task.async(fn -> stream_llm_response(text, socket) end)
{:noreply, socket}
end

defp stream_llm_response(text, socket) do
HTTPoison.get!("http://llm-server/stream", stream_to: self())
|> Stream.each(fn chunk ->
push(socket, "token", %{text: chunk})
end)
|> Stream.run()
end
end
```

**절감:**
- Redis Pub/Sub 불필요 → $100/월 절감
- Sticky session 불필요
- WebSocket 서버 별도 구축 불필요

### 3. 메모리 효율 = 수직 확장 최소화
```
동시 채팅 세션 10만 개:
- Python/Node.js: 16GB RAM × 10대 = 160GB
- Elixir: 32GB RAM × 2대 = 64GB

→ 메모리 60% 절감
```

---

## 🔧 자체 sLLM 구축 방법

### "개발" = 오픈소스 활용

**❌ 불가능한 것:**
- LLM을 처음부터 학습 (비용 $100M+)

**✅ 가능한 것:**
1. 오픈소스 모델 다운로드 (Llama, Qwen, Mistral)
2. 양자화 (4bit → GPU 메모리 4GB로 8B 모델 실행)
3. vLLM/llama.cpp로 추론 서버 구축
4. (선택) LoRA 파인튜닝

**개발 시간:**
- **vLLM 서버 구축**: 1~2주
- **프로덕션 서비스**: 3~6개월 (캐릭터, 모더레이션, UX 등)

---

### 1단계: 모델 선택

**추천 모델:**
- **Llama 3.1-8B** (Meta) - 범용, 균형형
- **Qwen2.5-7B** (Alibaba) - 한국어 강함
- **SOLAR-10.7B** (업스테이지) - 한국어 최적화

```bash
# HuggingFace에서 다운로드
huggingface-cli download meta-llama/Llama-3.1-8B-Instruct \
--local-dir ./models/llama-3.1-8b

# 양자화 (16GB → 4GB)
python -m llama_cpp.quantize \
./models/llama-3.1-8b/model.safetensors \
./models/llama-3.1-8b-q4.gguf q4_k_m
```

### 2단계: 추론 서버 (vLLM)

```python
# server.py
from vllm import LLM, SamplingParams
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()
llm = LLM(model="./models/llama-3.1-8b-q4.gguf")

@app.post("/chat")
async def chat(prompt: str):
params = SamplingParams(temperature=0.7, max_tokens=300)

def generate():
for output in llm.generate([prompt], params):
yield output.outputs[0].text

return StreamingResponse(generate(), media_type="text/plain")
```

**실행:**
```bash
vllm serve ./models/llama-3.1-8b-q4.gguf --port 8000
```

### 3단계: Elixir Phoenix 연동

```elixir
# lib/zeta/llm_client.ex
defmodule Zeta.LLMClient do
@llm_url "http://localhost:8000/chat"

def stream_chat(user_id, message) do
body = Jason.encode!(%{prompt: build_prompt(message)})

HTTPoison.post!(@llm_url, body,
[{"Content-Type", "application/json"}],
stream_to: self(), async: :once
)

receive_stream(user_id)
end

defp receive_stream(user_id) do
receive do
%HTTPoison.AsyncChunk{chunk: chunk} ->
ZetaWeb.Endpoint.broadcast("chat:#{user_id}", "token", %{text: chunk})
HTTPoison.stream_next(self())
receive_stream(user_id)

%HTTPoison.AsyncEnd{} -> :ok
end
end

defp build_prompt(message) do
"""
<|im_start|>system
당신은 친절한 AI 어시스턴트입니다.
<|im_end|>
<|im_start|>user
#{message}
<|im_end|>
<|im_start|>assistant
"""
end
end
```

### 4단계: 파인튜닝 (선택)

**LoRA 방식 - 메모리 90% 절감**

```python
from transformers import AutoModelForCausalLM, Trainer
from peft import LoraConfig, get_peft_model

# 베이스 모델 로드
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

# LoRA 설정
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q_proj", "v_proj"]
)
model = get_peft_model(model, lora_config)

# 학습 (RTX 4090 × 2시간 = $0.88)
trainer = Trainer(model=model, train_dataset=dataset)
trainer.train()
```

**데이터 형식:**
```json
{"prompt": "안녕?", "completion": "안녕하세요! 무엇을 도와드릴까요?"}
```

---

## 🏗️ 아키텍처

```
┌─────────────────┐
│ 사용자 │
└────────┬────────┘
│ WebSocket
┌────────▼────────┐
│ Phoenix (Elixir)│ ← API, 실시간 스트리밍, 세션 관리
│ - Channels │ 동시 접속 10만+ (서버 2대)
│ - LiveView │
│ - Ecto │
└────────┬────────┘
│ HTTP
┌────────▼────────┐
│ Python vLLM │ ← sLLM 추론 전용
│ - Llama 8B │ GPU 1대 (g5.xlarge)
│ - vLLM │
└─────────────────┘
```

**비용:**
- Phoenix: t3.large × 2 = $200/월
- vLLM: g5.xlarge × 1 = $650/월
- RDS: db.t3.medium = $150/월
- **총: $1,000/월**

---

## 💰 GPU 서버 옵션

### AWS EC2
```
g5.xlarge:
- GPU: NVIDIA A10G (24GB VRAM)
- 비용: $730/월
- 모델: Llama 8B (4bit) 또는 13B (4bit)
- 동시 처리: 10~20 req/sec
```

### RunPod (저렴)
```
RTX 4090 (24GB VRAM):
- 비용: $320/월
- 성능: A10G와 유사
```

### 온프레미스 (장기 운영)
```
RTX 4060 Ti 16GB:
- 구매가: $500
- 전기료: $30/월
- 6개월 이상 운영 시 가장 저렴
```

---

## 📈 확장성 비교

### 사용량 10배 증가 시 (MAU 10만 → 100만)

**OpenAI API:**
```
LLM 비용:
- 기존: $975/월
- 10배: $9,750/월
- 증가율: 900%
```

**자체 sLLM + Elixir:**
```
LLM 비용:
- 기존: $650/월 (GPU 1대)
- 10배: $1,300/월 (GPU 2대)
- 증가율: 100%

인프라 비용:
- Phoenix 서버: $200/월 (그대로)
- 증가율: 0%

총 증가율: 55%
```

**선형 확장 vs 기하급수적 증가**

---

## ⚠️ 품질 트레이드오프 (중요)

### sLLM vs GPT-4o 품질 차이

**Llama 8B 4bit의 현실:**
- GPT-4o 대비 대화 품질 하락
- 한국어 성능은 영어 대비 더 약함
- 복잡한 추론, 긴 맥락 이해에서 한계

**Zeta 성공의 핵심:**
- 모델 자체가 아니라 **캐릭터 몰입도**
- 대화 히스토리 관리
- 세심한 프롬프트 엔지니어링

**리스크:**
- 사용자가 품질 차이 체감 → MAU 감소
- 모더레이션 실패 → 법적 리스크
- 한국어 품질 부족 → 사용자 이탈

### 누락된 핵심 요소

**이 글에서 다루지 않은 것들:**
1. **콘텐츠 모더레이션** - AI 챗봇 서비스 필수
2. **대화 히스토리 관리** - 메모리/요약 없으면 멍청해짐
3. **한국어 품질 검증** - 8B 모델의 한국어 성능 테스트 필요
4. **모니터링/로깅** - 프로덕션 운영 필수
5. **모델 업데이트 전략** - 오픈소스 모델 버전 관리

---

## 🎯 결론

### 비용 절감 효과
- Elixir 인프라: **70% 절감** (동시성)
- 자체 sLLM: **90% 절감** (vs OpenAI)
- **총 44% 절감** (vs Node.js + sLLM, 공정한 비교)
- **96% 절감은 GPT-4o 대비** (불공정한 비교)

### 개발 현실성
- ✅ 모델 학습 불필요 (오픈소스 활용)
- ⚠️ vLLM 서버: 1~2주 / 프로덕션: 3~6개월
- ✅ 초기 투자 $0 (오픈소스)
- ✅ 운영 비용 $1,000/월 (MAU 10만)
- ⚠️ 품질 트레이드오프 존재

### 추천 스택
- **프론트**: React/Next.js
- **백엔드**: Elixir/Phoenix
- **LLM 추론**: Python vLLM
- **모델**: Llama 3.1-8B (4bit 양자화)
- **GPU**: AWS g5.xlarge 또는 RunPod RTX 4090

### 다음 단계
1. Elixir/Phoenix 프로젝트 생성
2. vLLM 서버 구축 (로컬 테스트)
3. Phoenix Channels 연동
4. GPU 서버 배포 (RunPod 추천)
5. (선택) LoRA 파인튜닝

---

**참고:**
- Llama 3.1: https://github.com/meta-llama/llama-models
- vLLM: https://github.com/vllm-project/vllm
- llama.cpp: https://github.com/ggerganov/llama.cpp
- Phoenix Channels: https://hexdocs.pm/phoenix/channels.html

*작성일: 2026-02-24*