[Local AI] 맥북 oMLX로 로컬 LLM 서버 만들기 — 설치·API·LM Studio 비교

나의 블로그 자동화 워크플로우는 오라클 클라우드 무료 서버(OCI A1)의 n8n 에서 실행된다. 무료 서버에 GPU가 없어 n8n에서 LLM 사용을 위해 외부 LLM 호출 API를 사용해야 하는 상태이고, 임베딩 벡터 생성을 필요로 하는 작업까지 한 달에 8천 건 이상의 LLM·임베딩 모델 API 호출이 발생한다.

  • OCI A1.Flex는 vCPU 2개, 메모리 12GB 다. 글 생성에 적합한 27B 4bit 양자화 모델 조차 메모리에 올리려면 17.6 GB 메모리가 필요해 A1 에서는 모델 로딩 자체가 불가능하다. (GPU가 아닌 CPU이기 때문에 더욱 그렇다)
  • 때문에 A1에서 Tailscale로 연결된 Mac을 로컬 LLM 서버로 사용 가능하도록 했다.
  • Mac 에서 LLM을 API로 서빙 해주는 프로그램은 oMLX을 사용중이다. 아래 측정 자료는 모두 oMLX 0.7.3 으로 측정했다.

현재 맥북에서 운영중인 oMLX의 주요 성능 측정값은 아래와 같다.

  • Qwen3.6-35B-A3B MLX 8bit 디코딩: 초당 110.8 토큰
    • 12,497(12K) 토큰 프리필 프롬프트의 첫 토큰 시간(TTFT): 첫 요청 7.66초
    • 같은 프롬프트를 다시 보내면 0.17초가 걸린다. (oMLX 프롬프트 캐시)
  • Qwen3.8-27B 기반 8bit 모델 디코딩: MTP 를 켜면 초당 15.6 토큰에서 29.1 토큰 정도의 생성 속도가 나온다.
목차
  1. oMLX 는 LM Studio·Ollama 와 무엇이 다른가
  2. 핵심 기능
  3. LM Studio·Ollama·vLLM 과 비교
  4. 내가 Mac 에서 oMLX 를 메인으로 사용하는 이유
  5. oMLX 설치 — 다운로드 설치 or Homebrew 설치
  6. 설치 요구 사항
  7. 메뉴바 앱(DMG)
  8. Homebrew
  9. 설치 확인
  10. 모델 관리 — MLX, GGUF 지원
  11. GGUF 를 쓰려면
  12. 모델 이름의 oQ
  13. OpenAI·Anthropic 호환 API 로 부르기 — curl·n8n·Claude Code
  14. API 키
  15. curl 로 호출
  16. 다른 서버에서 부르기 — tailscale serve
  17. n8n 에서 부르기
  18. Claude Code 연결 — omlx launch
  19. oMLX의 로컬 LLM 메모리 관리 — 고정·TTL·메모리 가드·SSD KV 캐시
  20. 메모리 상한값 계산
  21. 모델별 TTL — 놀고 있는 모델은 바로 메모리에서 내려준다
  22. 고정(pin)과 LRU
  23. SSD KV 캐시
  24. M4 Max 128G 벤치마킹 — 초당 토큰 수·상주 메모리·MTP
  25. 측정 스크립트
  26. 결과
  27. 27B 디코딩을 1.9배 향상시키는 MTP 헤드
  28. 동시 요청 — 연속 배칭의 장단점
  29. 정리 — oMLX 가 맞는 경우와 다른 도구가 나은 경우
  30. 참고 자료

oMLX 는 LM Studio·Ollama 와 무엇이 다른가

oMLX 는 Apple Silicon MacOS 전용 LLM 서버다.(한국인이 시작한 프로젝트!) 추론은 Apple 의 MLX 위에서 mlx-lm·mlx-vlm·mlx-embeddings·mlx-audio 사용이 가능하다. oMLX는 관리UI로 Swift 로 만든 메뉴바 앱과 웹 관리 화면을 제공하며, 라이선스는 Apache-2.0 을 따른다.

핵심 기능

  • 여러 모델을 한 서버에서: LLM·VLM·T2S·임베딩·리랭커를 하나의 포트로 서빙할 수 있다.
  • 연속 배칭: 동시에 들어오는 요청을 mlx-lm 의 BatchGenerator 로 묶어 처리할 수 있다.
  • 강력한 2단 KV 캐시: 메모리(hot)와 SSD(cold)에 프롬프트 KV 블록을 저장한다. 저장된 SSD 캐시 블록은 서버를 다시 시작해도 재사용이 가능하다.
  • 효율적인 메모리 관리: LLM 서빙은 메모리 관리가 핵심이다. 모델별 TTL·고정(pin), LRU(상한을 넘으면 오래 쓰지 않은 모델부터 내림)와 전체 상한을 관리하는 메모리 가드를 통해 메모리 관리가 너무너무 편리하다.
  • API: OpenAI 호환 API 와 Anthropic Messages API(/v1/messages)를 모두 제공한다. (Jev 지원도 좀…)
  • 관리 화면(앱·웹): /admin 웹과 앱에서 모델 다운로드와 설정·로그·벤치마크를 할 수 있고, 리더 보드도 제공 하고있다.

LM Studio·Ollama·vLLM 과 비교

항목oMLXLM StudioOllamavLLM
추론 엔진MLX. GGUF 는 외부 엔진 Splash 가 별도 프로세스로 실행llama.cpp(GGUF)와 MLXllama.cpp 중심, 0.19 부터 Apple Silicon 에서 MLX 미리보기CUDA 중심. Apple Silicon 은 vllm-metal 플러그인(MLX 백엔드)
모델 메모리 정책JIT 모델 로딩을 지원한다. 모델별 TTL·고정, 상한을 넘으면 LRU가 동작한다. 모델 유휴 TTL은 초단위로 설정이 가능하다.JIT 로드 모델은 유휴 TTL은 최소 1분, Auto-Evict 가 켜져 있으면 JIT 모델을 하나만 유지keep_alive(기본 5분)가 지나면 언로드프로세스 하나에 모델 하나
실행 형태메뉴바 앱 + 서버(헤드리스 실행 가능)데스크톱 앱 + lms CLI 서버 모드데몬 + CLIPython 서버
오픈소스 여부OXOO

내가 Mac 에서 oMLX 를 메인으로 사용하는 이유

  1. 하나의 엔드포인트로 임베딩과 생성을 모두 사용할 수 있다. n8n 에서 주소 1개만 설정하면 된다. https://m4max-….ts.net:8000/v1 하나로 필요한 모델을 호출만 하면 된다. (LLM + 임베딩)
  2. 모델별 TTL 로 메모리를 바로 회수한다. 같은 Mac 에서 Draw Things 로 이미지도 생성하고 있다. 임베딩 모델은 10초, 생성 모델은 30초 동안 추가 요청이 없으면 바로 메모리가 회수 되도록 했다. (LMStudio는 1분 단위)
  3. 같은 프리픽스를 반복하는 요청에서 SSD 캐시가 효과를 낸다. 누적 프롬프트 토큰 17.7억 개 중 12.8억 개(72.3%)를 캐시에서 읽었다. 코딩 에이전트용으로 쓰는 35B 모델은 90% 정도다.
  4. LM Studio 가 받아 둔 모델 디렉터리를 그대로 읽을 수 있다. LMStudio 로 다운받은 모델을 다시 다운로드하지 않아도 된다.

oMLX 설치 — 다운로드 설치 or Homebrew 설치

설치 요구 사항

  • macOS 15 이상, Apple Silicon(M1~M5).
  • 2026.11.03 현재 최신 버전은 0.7.3(빌드 3574)이다.

메뉴바 앱(DMG)

  • GitHub Releases 에서 DMG 를 받아 /Applications 로 복사하고 실행한다.
  • 앱은 CLI 실행 파일 ~/.omlx/bin/omlx 를 만들고 ~/.zshrc 에 PATH 블록을 추가한다.
  • 서버 시작·중지는 메뉴바 아이콘에서 할수 있다. 서버가 비정상 종료되면 앱이 다시 시작한다.
# ~/.zshrc 에 앱이 추가하는 블록
# oMLX: CLI shim path begin
case ":$PATH:" in
  *":$HOME/.omlx/bin:"*) ;;
  *) export PATH="$HOME/.omlx/bin:$PATH" ;;
esac
# oMLX: CLI shim path end
Code language: Bash (bash)

Homebrew

brew tap jundot/omlx https://github.com/jundot/omlx
brew install jundot/omlx/omlx

# 백그라운드 서비스로 실행 (비정상 종료 시 다시 시작)
brew services start omlx
# 또는 oMLX CLI 로
omlx start      # stop · restart
Code language: Bash (bash)

설치 확인

omlx --version
tail -1 ~/.omlx/bin/omlx
curl -s http://127.0.0.1:8000/health \
  | jq '{status, models: .engine_pool.model_count, loaded: .engine_pool.loaded_count}'
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8000/v1/models   # 키 없이 → 401
Code language: Bash (bash)

설정과 상태는 모두 ~/.omlx/ 아래 파일에 있다.

경로내용
settings.json서버·모델 디렉터리·메모리 가드·캐시·인증
model_settings.json모델별 TTL·고정·샘플링·MTP
logs/server.log로드·언로드·TTL 만료·MTP 수락률
cache/SSD KV 캐시 블록
usage.sqlite3모델별 시간 단위 사용량

앱 없이 터미널에서 직접 실행할 때는 omlx serve 를 사용한다.

omlx serve --model-dir ~/models --host 127.0.0.1 --port 8000 \
  --memory-guard balanced \
  --paged-ssd-cache-dir ~/.omlx/cache --paged-ssd-cache-max-size 100GB \
  --max-concurrent-requests 4
# 127.0.0.1 이 아닌 주소에 열 때는 --api-key 가 필요하다
Code language: Bash (bash)

모델 관리 — MLX, GGUF 지원

  • oMLX 는 모델 디렉터리 아래 하위 디렉터리 하나를 모델 하나로 인식한다.
  • 하위 디렉터리에 config.json 과 *.safetensors 가 있어야 한다.
  • 기본 위치는 ~/.omlx/models 다. 나의 경우 LM Studio 모델 폴더를 지정했다.
"model": {
  "model_dirs": ["/Users/axgo/.lmstudio/models"]
}
Code language: JSON / JSON with Comments (json)

모델은 아래 방법 가운데 하나로 받는다.

  • 관리 화면 > 모델 > 다운로드에 HuggingFace 모델 리포지토리 ID 를 넣는다.
  • 나의 경우는 아래와 같이 LMStudio로 다운로드후 oMLX로 모델을 서빙하고 있다.
    • 모델 다운로드 = LM Studio
    • 모델 서빙 = oMLX
# hf로 직접 다운로드를 진행할 경우
hf download unsloth/Qwen3.6-35B-A3B-MLX-8bit \
  --local-dir ~/.lmstudio/models/unsloth/Qwen3.6-35B-A3B-MLX-8bit
Code language: Bash (bash)

GGUF 를 쓰려면

  • oMLX 의 추론 엔진은 MLX 다. GGUF 타입은 Splash 라는 외부 엔진이 별도 프로세스로 실행한다.
  • 여기서 다루는 연속 배칭·SSD KV 캐시는 MLX 엔진의 동작이다. Splash 는 설치하지 않았다.
  • 가진 모델이 GGUF 뿐이면 MLX 로 변환해서 쓰는 편이 낫다. 변환 방법은 GGUF 대신 MLX로: Hugging Face 모델을 MLX 8bit로 직접 변환하기에 정리했다.

모델 이름의 oQ

  • oQ8e·oQ4e 처럼 이름에 붙은 oQ 는 oMLX 의 자체 양자화 형식이다. (요즘 로컬모델쪽 양자화는 군웅할거의 시대다)
  • 레이어 위치에 따라 비트 수를 다르게 주는 혼합 정밀도 방식이다. GGUF K-quant 의 레이어 배치 전략과 일부 레이어를 양자화하지 않는 방식을 함께 쓴다.
  • oQ2 부터 oQ8 까지 있다. 변환은 관리 화면 > 모델 > oQ Quantization 에서 한다.

OpenAI·Anthropic 호환 API 로 부르기 — curl·n8n·Claude Code

경로형식용도
/v1/chat/completionsOpenAI채팅
/v1/completionsOpenAI텍스트 완성
/v1/messagesAnthropicClaude Code 같은 Anthropic 클라이언트
/v1/embeddingsOpenAI임베딩
/v1/rerank–리랭커
/v1/models, /v1/models/statusOpenAI, oMLX모델 목록, 로드 상태·메모리 상한

API 키

  • 127.0.0.1 이 아닌 주소에 서버를 열면 API 키가 필수다(--api-key 또는 OMLX_API_KEY).
  • OpenAI 형식은 Authorization: Bearer <키>, Anthropic 형식은 x-api-key: <키> 헤더로 보낸다.
  • 관리 화면은 4자 이상이면 키로 받아 주므로 길게 만든다.
openssl rand -hex 32   # 이 값을 관리 화면 > 설정 > 인증 및 정보 > API 키에 넣는다
export OMLX_API_KEY='<위에서 만든 키>'
Code language: Bash (bash)

curl 로 호출

# OpenAI 채팅 — 이 서버의 Qwen3.6 모델은 thinking 이 켜져 있어 요청에서 끈다
curl -s http://127.0.0.1:8000/v1/chat/completions \
  -H "Authorization: Bearer $OMLX_API_KEY" -H 'Content-Type: application/json' \
  -d '{"model":"Qwen3.6-35B-A3B-MLX-8bit","max_tokens":200,
       "chat_template_kwargs":{"enable_thinking":false},
       "messages":[{"role":"user","content":"MLX가 뭔지 한 문장으로"}]}'

# Anthropic Messages — 응답 content 에 thinking 블록이 먼저 온다
curl -s http://127.0.0.1:8000/v1/messages \
  -H "x-api-key: $OMLX_API_KEY" -H 'anthropic-version: 2023-06-01' \
  -H 'Content-Type: application/json' \
  -d '{"model":"Qwen3.6-35B-A3B-MLX-8bit","max_tokens":1024,
       "messages":[{"role":"user","content":"MLX를 한 문장으로"}]}'

# 임베딩
curl -s http://127.0.0.1:8000/v1/embeddings \
  -H "Authorization: Bearer $OMLX_API_KEY" -H 'Content-Type: application/json' \
  -d '{"model":"Qwen3-Embedding-4B","input":["기준금리 동결","국채 금리 상승"]}'
Code language: Bash (bash)
  • oMLX 는 usage 에 time_to_first_token·generation_tokens_per_second 같은 필드를 더 넣는다. 속도를 잴 때 클라이언트에서 시간을 따로 잴 필요가 줄어든다.

다른 서버에서 부르기 — tailscale serve

tailscale serve --bg --https=8000 http://127.0.0.1:8000
Code language: Bash (bash)

A1 에서 경로·인증·지연을 한 번에 확인하는 스크립트다. 키는 명령줄 인자가 아니라 표준 입력으로 curl 에 넘긴다.

#!/usr/bin/env bash
# 다른 서버에서 oMLX 까지의 경로·인증·지연을 확인한다
#   OMLX_URL=https://<mac>.<tailnet>.ts.net:8000/v1 OMLX_API_KEY=<키> bash omlx-check.sh
set -euo pipefail
U="${OMLX_URL:?OMLX_URL 이 필요하다}"; K="${OMLX_API_KEY:?OMLX_API_KEY 가 필요하다}"
auth() { printf 'Authorization: Bearer %s\n' "$K"; }   # 키를 명령줄 인자(ps)에 남기지 않는다

echo "== no key"
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' "$U/models"
echo "== with key"
auth | curl -s -o /dev/null -H @- -w '%{http_code} connect=%{time_connect}s tls=%{time_appconnect}s total=%{time_total}s\n' "$U/models"

B='{"model":"Qwen3-Embedding-4B","input":["한국은행이 기준금리를 동결했다.","미국 국채 10년물 금리가 올랐다.",
"코스피가 외국인 매도에 하락했다.","원달러 환율이 1,400원을 넘었다.","반도체 수출이 석 달 연속 늘었다.",
"비트코인 ETF 에 자금이 순유입됐다.","유가가 OPEC 감산 소식에 올랐다.","삼성전자가 자사주 소각을 발표했다."]}'
echo "== embeddings x5 (8 texts)"
for _ in 1 2 3 4 5; do
  auth | curl -s -H @- -H 'Content-Type: application/json' -d "$B" -o /tmp/emb.json -w '%{http_code} total=%{time_total}s ' "$U/embeddings"
  python3 -c "import json;d=json.load(open('/tmp/emb.json'));print(len(d['data']),'x',len(d['data'][0]['embedding']),'tok',d['usage']['prompt_tokens'])"
done
rm -f /tmp/emb.json

H=$(sed -E 's#^https?://([^:/]+).*#\1#' <<<"$U")
if [[ "$H" == *.ts.net ]]; then tailscale ping -c 3 "$H" | tail -1; fi   # 권한에 따라 sudo 가 필요하다
Code language: Bash (bash)
  • 첫 임베딩 호출은 1.09초가 소요되었다. (TTL 로 내려간 임베딩 모델을 로딩하는 시간 추가)
  • 같은 호출을 Mac 안에서 보내면 0.14초다. A1 에서는 0.46초다. 차이 0.3초는 새 연결(TCP·TLS 약 0.1초)과 tailnet 왕복, tailscale serve 프록시를 거치면서 발생하는 지연 시간이다.

n8n 에서 부르기

  • N8N에서 LLM Provider 마다 HTTP Request 노드를 하나 두고 Header Auth 자격증명에 Authorization: Bearer <키> 를 넣는 방식으로 사용할 수 있다.
  • URL 은 https://m4max-….ts.net:8000/v1/chat/completions, 모델 이름은 표현식으로 넘긴다.
  • 임베딩을 1536차원으로 잘라 pgvector 에 저장하는 과정은 Qwen3-Embedding-4B + pgvector로 한국어 뉴스 중복 제거에 있다.

Claude Code 연결 — omlx launch

omlx launch claude --model Qwen3.6-35B-A3B-MLX-8bit
# 티어별로 다른 모델을 쓸 때
omlx launch claude --opus Qwen3.6-35B-A3B-MLX-8bit --haiku Qwen3.5-2B-oQ8e-mtp
Code language: Bash (bash)
  • omlx launch claude 는 ANTHROPIC_BASE_URL·ANTHROPIC_AUTH_TOKEN·ANTHROPIC_MODEL 과 티어별 모델 변수(ANTHROPIC_DEFAULT_OPUS_MODEL 등)를 넣고 claude 를 실행한다.
  • oMLX 는 모델의 실제 컨텍스트 길이를 Claude Code 에 알려 준다. Claude Code 는 그 값을 보고 대화를 자동 압축한다.
  • Codex·OpenCode·Hermes Agent 도 omlx launch <도구> 와 같은 방식으로 연결할 수 있다.

oMLX의 로컬 LLM 메모리 관리 — 고정·TTL·메모리 가드·SSD KV 캐시

oMLX가 MacOS의 메모리 전부를 LLM모델이 모두 사용하게 둘 수는 없다. OS, 다른 어플리케이션들도 메모리를 사용할 여유가 반드시 필요한데, oMLX 는 정적 상한·Metal 한도·동적 상한을 계산해 가장 낮은 값을 LLM 모델 메모리의 상한값으로 설정 할 수 있다.

메모리 상한값 계산

  • 정적 상한: 물리 메모리에서 등급별 예약분을 뺀 값이다.
  • Metal 한도: 커널의 iogpu.wired_limit_mb 다. macOS 기본값이면 이 Mac 에서 약 108 GB 다.
  • 동적 상한: 여유 메모리 + inactive + 다른 앱 메모리 중 압축할 수 있는 몫 − 예약분이다. 그 순간 다른 앱이 사용중인 메모리 크기에 따라 바뀐다.
등급남겨 두는 메모리다른 앱 메모리 압축측정 시점 상한
safeRAM 의 약 20% (6~16 GB)하지 않음42.8 GB
balanced (기본값)약 8% (3~8 GB)1/4 까지57.2 GB
aggressive (현재 설정)약 2% (1.5~4 GB)1/2 까지69.0 GB
custom (--memory-guard-gb)직접 지정–Metal 한도 108.1 GB 까지
  • Metal 한도를 넘는 모델을 올리려면 iogpu.wired_limit_mb 를 올려야 한다.
    • aggressive 모드에서 128GB 물리메모리에 대해 oMLX 가 제안하는 값은 124,518 MB 다.
    • sysctl 로 바꾼 값은 재부팅하면 기본값으로 돌아간다.
  • 한도는 올리지 않았다. 지금 쓰는 모델은 하나씩 올려도, 두세 개를 같이 올려도 108.1 GB 안에 들어간다.
sysctl iogpu.wired_limit_mb          # 0 이면 macOS 기본값
sudo sysctl iogpu.wired_limit_mb=124518
Code language: Bash (bash)

모델별 TTL — 놀고 있는 모델은 바로 메모리에서 내려준다

  • 나의 경우 은 생성 모델 TTL 을 30초, 임베딩 모델을 10초로 두었다.
  • 같은 Mac 에서 Draw Things 로 이미지를 생성하니 놀고 있는 모델은 빨리 내리는 편이 낫다.
  • 다시 모델을 로딩하는 부담은 크지 않다.
    • oMLX 가 98번 관측한 로드 속도는 GB 당 0.216초다.
    • 35B 모델은 디스크 캐시에 남아 있을 때 4.5초 만에 다시 올라왔다.
  • n8n 은 임베딩을 한 번에 모아서 보낸다. 10초면 한 묶음을 처리하는 동안 모델이 내려가지 않는다.

고정(pin)과 LRU

  • 고정한 모델은 TTL·LRU 대상에서 빠지고 계속 메모리에 남는다. 상시 사용 모델에 권장된다.
    • 고정 모델 미사용중: 다시 올리는 데 몇 초면 되니 TTL 로 충분하다.
  • LRU 는 새 모델을 올릴 때 상한을 넘으면 가장 오래 쓰지 않은 모델부터 내린다.
  • 나의 경우 TTL 이 먼저 메모리를 비워서 LRU 까지 가는 일이 드물었다.
    • 측정 중 35B(35.6 GB)와 27B(37.1 GB)가 함께 올라갔을 때도
    • 동적 상한이 93.7 GB 라 두 모델이 동시에 메모리에 올라가 있는 상태였다.

SSD KV 캐시

  • 현재 Mac 의 설정: SSD 캐시 최대 92 GB(~/.omlx/cache), 메모리 hot 캐시는 꺼짐(0).
  • 블록 크기는 4,096 토큰이다(server.log).
  • 같은 프롬프트를 세 번 보내 TTFT 를 비교했다. 측정 스크립트는 아래 실측 절에 있다.
# 같은 seed 는 같은 프롬프트다
python3 omlx_bench.py chat Qwen3.6-35B-A3B-MLX-8bit --prompt-tokens 12000 --gen 64 --runs 1 --seed 1793634811 --reuse
python3 omlx_bench.py chat Qwen3.6-35B-A3B-MLX-8bit --prompt-tokens 12000 --gen 64 --runs 2 --seed 1793634811 --reuse

# 관리 화면(모델 > 관리)이나 관리 API 로 모델을 내렸다 다시 올린 뒤
python3 omlx_bench.py chat Qwen3.6-35B-A3B-MLX-8bit --prompt-tokens 12000 --gen 64 --runs 1 --seed 1793634811 --reuse
Code language: Bash (bash)
  • 첫 요청은 12,497 토큰을 모두 프리필해서 7.66초가 걸렸다.
  • 같은 프롬프트를 다시 보내면 12,490 토큰을 캐시에서 읽고 0.17초에 첫 토큰이 나왔다. (약 45배 빠르다)
  • 모델을 내려 메모리의 KV 가 모두 비워진 뒤에도 SSD 블록에서 12,490 토큰을 복원해 0.96초가 걸렸다.
  • 이 모델은 하이브리드 어텐션 구조라 블록 경계 스냅샷까지 저장해서 4,096 토큰 블록 단위보다 촘촘하게 Hit 됐다.
  • 디코딩 속도는 세 경우 모두 초당 107~109 토큰으로 같았다. 캐시 효과는 프롬프트 처리에만 나타난다.
  • 누적 효율 72.3% 는 주로 코딩 에이전트 요청에서 나온다. 시스템 프롬프트와 도구 정의가 매번 앞에 붙기 때문이다.
  • 임베딩은 매번 다른 텍스트라 캐시 효율이 0% 다.
  • 한 번만 쓸 요청은 X-oMLX-Cache-Store: off 헤더를 붙여 캐시에 저장하지 않는다. 캐시 조회는 그대로 한다.
curl -s http://127.0.0.1:8000/v1/chat/completions -H 'X-oMLX-Cache-Store: off' ...
Code language: Bash (bash)

M4 Max 128G 벤치마킹 — 초당 토큰 수·상주 메모리·MTP

측정 스크립트

  • 간단하게 벤치마킹 스크립트를 돌려보자. (OMLX_BASE·OMLX_API_KEY 환경 변수 사용)
  • chat: 스트리밍으로 TTFT·프리필·디코딩 속도와 캐시 적중 토큰을 잰다.
  • embed: 임베딩 배치 처리량을 잰다.
#!/usr/bin/env python3
"""oMLX(OpenAI 호환 서버) 속도 측정 — 표준 라이브러리만 쓴다.

  chat : TTFT · 프리필(tok/s) · 디코딩(tok/s) · 캐시 적중 토큰
  embed: 임베딩 배치 처리량

환경 변수 OMLX_BASE(기본 http://127.0.0.1:8000/v1), OMLX_API_KEY
"""
import argparse, json, os, random, statistics, time, urllib.request
from concurrent.futures import ThreadPoolExecutor

BASE = os.environ.get("OMLX_BASE", "http://127.0.0.1:8000/v1").rstrip("/")
KEY = os.environ.get("OMLX_API_KEY", "")
LINE = ("Unified memory lets the GPU read model weights without a PCIe copy, "
        "so decode speed is bound by memory bandwidth rather than FLOPS. ")


def post(path, body, stream=False):
    req = urllib.request.Request(
        BASE + path, data=json.dumps(body).encode(),
        headers={"Content-Type": "application/json", "Authorization": f"Bearer {KEY}"})
    return urllib.request.urlopen(req, timeout=900)


def make_prompt(tokens, seed):
    # 앞머리 seed 가 같으면 같은 프리픽스 → 두 번째 요청부터 프리픽스 캐시 적중
    body = LINE * max(1, tokens // 26)
    return (f"[doc {seed}]\n{body}\n\nExplain the document above to an SRE team "
            "in at least 800 words, with examples.")


def chat_once(model, prompt, gen, think):
    body = {"model": model, "stream": True, "max_tokens": gen, "temperature": 0,
            "messages": [{"role": "user", "content": prompt}],
            "stream_options": {"include_usage": True},
            "chat_template_kwargs": {"enable_thinking": think}}
    t0 = time.perf_counter(); first = None; usage = {}
    with post("/chat/completions", body, stream=True) as r:
        for raw in r:
            line = raw.decode().strip()
            if not line.startswith("data:") or line.endswith("[DONE]"):
                continue
            chunk = json.loads(line[5:])
            delta = (chunk.get("choices") or [{}])[0].get("delta") or {}
            if first is None and (delta.get("content") or delta.get("reasoning_content")):
                first = time.perf_counter()
            usage = chunk.get("usage") or usage
    end = time.perf_counter()
    p, c = usage.get("prompt_tokens", 0), usage.get("completion_tokens", 0)
    cached = (usage.get("prompt_tokens_details") or {}).get("cached_tokens") or 0
    ttft = (first or end) - t0
    return {"prompt": p, "cached": cached, "gen": c, "ttft": ttft,
            "prefill_tps": (p - cached) / ttft if ttft else 0,
            "decode_tps": (c - 1) / (end - first) if first and c > 1 else 0,
            "total": end - t0}


def cmd_chat(a):
    seed = a.seed or random.randrange(10**9)
    print(f"model={a.model} prompt≈{a.prompt_tokens} gen={a.gen} seed={seed} concurrency={a.concurrency}")
    print(f"{'run':>3} {'prompt':>7} {'cached':>7} {'TTFT(s)':>8} {'prefill t/s':>11} {'decode t/s':>10} {'total(s)':>8}")
    rows = []
    for i in range(1, a.runs + 1):
        prompt = make_prompt(a.prompt_tokens, seed if a.reuse else f"{seed}-{i}")
        with ThreadPoolExecutor(a.concurrency) as ex:
            batch = list(ex.map(lambda _: chat_once(a.model, prompt if a.reuse else prompt + f" #{_}", a.gen, a.think),
                                range(a.concurrency)))
        for r in batch:
            rows.append(r)
            print(f"{i:>3} {r['prompt']:>7} {r['cached']:>7} {r['ttft']:>8.2f} {r['prefill_tps']:>11.0f} "
                  f"{r['decode_tps']:>10.1f} {r['total']:>8.2f}")
        if a.concurrency > 1:
            wall = max(r["total"] for r in batch)
            print(f"    aggregate decode {sum(r['gen'] for r in batch) / wall:.1f} tok/s over {wall:.1f}s")
    if a.runs > 1:
        print(f"median decode {statistics.median(r['decode_tps'] for r in rows):.1f} tok/s · "
              f"median TTFT {statistics.median(r['ttft'] for r in rows):.2f}s")


def cmd_embed(a):
    texts = [f"뉴스 {i}: " + "한국은행이 기준금리를 동결했다. 시장은 연내 인하 가능성을 반영했다. " * 4 for i in range(a.batch)]
    for i in range(1, a.runs + 1):
        t0 = time.perf_counter()
        with post("/embeddings", {"model": a.model, "input": texts}) as r:
            d = json.load(r)
        dt = time.perf_counter() - t0
        tok = (d.get("usage") or {}).get("prompt_tokens", 0)
        print(f"run {i}: {len(d['data'])} x {len(d['data'][0]['embedding'])}d  {dt:.2f}s  {tok} tok  {tok / dt:.0f} tok/s")


p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = p.add_subparsers(dest="cmd", required=True)
c = sub.add_parser("chat")
c.add_argument("model"); c.add_argument("--prompt-tokens", type=int, default=1024)
c.add_argument("--gen", type=int, default=256); c.add_argument("--runs", type=int, default=3)
c.add_argument("--concurrency", type=int, default=1); c.add_argument("--seed")
c.add_argument("--reuse", action="store_true", help="모든 실행에 같은 프롬프트(프리픽스 캐시 확인)")
c.add_argument("--think", action="store_true", help="thinking 켜기(기본 끔)")
e = sub.add_parser("embed")
e.add_argument("model"); e.add_argument("--batch", type=int, default=64); e.add_argument("--runs", type=int, default=3)
a = p.parse_args()
cmd_chat(a) if a.cmd == "chat" else cmd_embed(a)
Code language: Python (python)
export OMLX_API_KEY='<키>'
python3 omlx_bench.py chat Qwen3.6-35B-A3B-MLX-8bit --prompt-tokens 1024 --gen 512 --runs 3
python3 omlx_bench.py chat Qwen3.6-35B-A3B-MLX-8bit --prompt-tokens 1024 --gen 512 --runs 1 --concurrency 4
python3 omlx_bench.py embed Qwen3-Embedding-4B --batch 64 --runs 3
Code language: Bash (bash)

결과

모델상주 메모리로드TTFT (1.1K 토큰)프리필디코딩
Qwen3.6-35B-A3B MLX 8bit (MoE, 활성 3B)35.6 GB4.5~14.6초0.65초1,713 tok/s110.8 tok/s
Qwen3.8-27B 기반 8bit (oQ8e, MTP 켬)37.1 GB43.2초 (첫 로드)5.89초188 tok/s29.1 tok/s
같은 27B 모델, MTP 끔37.1 GB–6.07초182 tok/s15.6 tok/s
Qwen3-Embedding-4B (64건 배치)7.5 GB––약 1,770 tok/s–
  • 상주 메모리는 server.log 의 실제 로드 크기다. 로드 시간은 디스크에서 처음 읽을 때와 디스크 캐시에 남아 있을 때 차이가 크다.
  • 35B MoE 는 토큰마다 활성 파라미터가 3B 라 MTP 를 켠 27B dense 모델보다도 디코딩이 3.8배 빠르다.

27B 디코딩을 1.9배 향상시키는 MTP 헤드

  • MTP(Multi-Token Prediction) 헤드가 다음 토큰 여러 개를 먼저 제안하면 본 모델이 한 번에 검증한다.
  • 같은 모델·같은 조건에서 초당 15.6 토큰이 29.1 토큰이 됐다(1.87배).
  • server.log 를 보면 512 토큰을 생성하는 데 193~210 사이클이 걸렸다. 사이클당 2.44~2.65 토큰을 확정했고 제안 수락률은 67~72% 였다.
  • TTFT 는 거의 같다(6.07초 → 5.89초). MTP 는 디코딩 연산 필요성을 줄인다.
  • MTP 헤드가 있는 모델(이름 끝 -mtp)에서만 활성화할 수 있다. 모델 설정 > Acceleration 에서 활성화할 수 있다.

동시 요청 — 연속 배칭의 장단점

  • 35B 에 요청 4개를 동시에 보내면 합계가 초당 140.9 토큰이 된다. 단일 요청(110.8)의 1.27배다.
  • 하지만, 요청 하나만 보면 초당 40~48 토큰으로 느려진다. (반비례!)
    • 서빙 처리량은 늘어나지만 요청자 입장에서는 응답이 지연되는 것으로 느껴진다.
  • 현재 최대 동시 요청은 4로 두었다. oMLX를 여러곳에서 사용해야 한다면 이 값을 적당히 맞춰줘야 한다.

정리 — oMLX 가 맞는 경우와 다른 도구가 나은 경우

  • oMLX 가 맞는 경우
    • Mac 한 대를 여러 클라이언트가 API 로 쓰는 서버로 둘 때
    • 임베딩·생성·리랭커를 한 포트로 서비스할 때
    • 코딩 에이전트처럼 같은 프리픽스를 반복해서 보낼 때
  • 다른 도구가 나은 경우
    • GUI 에서 모델을 골라 대화하는 개인 사용, GGUF 와 MLX 를 같이 쓰려면 LM Studio
    • 리눅스·윈도우·맥을 같은 CLI 로 맞추려면 Ollama
    • NVIDIA GPU 서버라면 vLLM (부럽다…)
  • 나의 로컬 LLM Mac 설정
    • 메모리 가드 aggressive, 생성 모델 TTL 30초·임베딩 10초, 고정 없음
    • SSD 캐시 92 GB, 최대 동시 요청 4
    • 127.0.0.1 에만 열고 tailscale serve 로 TLS 프라이빗 서빙중

A1 처럼 작은 서버가 워크플로우를 돌리고 무거운 추론을 Mac 으로 넘긴다. 이 구성에서 oMLX 는 주소 하나, 키 하나로 모든 모델을 서빙 받는다. TTL 과 메모리 가드가 모델 메모리를 효율적으로 관리하며, 반복되는 프롬프트는 SSD 캐시가 지연시간을 줄여 준다.

참고 자료

댓글 남기기

이메일 주소는 공개되지 않습니다. 필수 필드는 *로 표시됩니다

댓글은 운영자가 확인한 뒤 공개됩니다. 이메일은 공개되지 않습니다.

공유하기

[Local AI] 맥북 oMLX로 로컬 LLM 서버 만들기 — 설치·API·LM Studio 비교

axgo.byitx.com

LINE텔레그램밴드XFacebook