Copy & Run

Ollama keep_alive: 모델을 메모리에 얼마나 올려 둘지 정하기

Ollama는 모델을 한 번 쓰면 일정 시간 메모리에 남겨 둡니다. keep_alive를 0, 20초, 무기한으로 바꿔 가며 ollama ps의 UNTIL 열과 다음 호출의 불러오는 시간이 어떻게 달라지는지 직접 확인합니다.

실습 노트 · 2026-10-28 발행 · 2026-11-14 수정 · 6분 · 2026-10 확인

로컬 모델은 처음 부를 때 디스크에서 메모리로 올라오는 데 시간이 걸립니다. 그래서 Ollama는 답을 마친 뒤에도 모델을 잠시 메모리에 둡니다. 이 시간이 keep_alive입니다. 길게 잡으면 다음 질문이 빠르지만 메모리를 계속 차지하고, 짧게 잡으면 메모리를 돌려주지만 다음 질문이 느립니다. 이 글에서는 값을 바꿔 가며 그 차이를 잽니다.

같은 모델에 요청이 몰릴 때의 처리량은 동시 요청 처리량 재기 글에서 따로 측정했습니다.

준비물

항목 확인한 값
Ollama 0.32.15 (Windows 11)
모델 exaone3.5:2.4b
도구 Python 3.12.10, requests

1. 현재 설정 보기

ollama ps

UNTIL 열이 그 모델이 메모리에서 내려가는 시각입니다. 이 PC에서는 Forever로 표시됐습니다. 사용자 환경 변수에 OLLAMA_KEEP_ALIVE=-1이 들어 있었기 때문입니다(시스템 환경 변수에는 없었습니다). 변수가 없으면 기본값은 5분으로 알려져 있지만, 이 PC에서는 변수를 지워 확인하지 않았습니다.

2. 호출마다 값 바꾸기

keep_alive는 요청마다 줄 수 있고, 환경 변수보다 우선합니다. 숫자는 초, 문자열은 "20s", "5m" 같은 시간, -1은 무기한, 0은 답한 직후 내리기입니다.

import requests, subprocess, time

U = "http://localhost:11434/api/generate"

def ps():
    out = subprocess.run(["ollama", "ps"], capture_output=True, text=True).stdout.splitlines()
    return [" ".join(l.split()) for l in out[1:] if l.startswith("exaone")]

def go(keep):
    d = requests.post(U, json={"model": "exaone3.5:2.4b", "prompt": "안녕", "stream": False,
                               "keep_alive": keep, "options": {"num_predict": 5}}).json()
    return round(d["load_duration"] / 1e9, 2)

print("keep_alive=0    load", go(0), "| after:", ps())
print("keep_alive=20s  load", go("20s"), "| after:", ps())
print("second call     load", go("20s"))
time.sleep(25)
print("after 25s idle:", ps())
print("reload          load", go(0))
이 단계의 파일 내려받기:keep_alive_test.py

3. 결과

# 기대 출력(이 PC)
keep_alive=0    load 4.09 | after: []
keep_alive=20s  load 2.3  | after: ['exaone3.5:2.4b ... 100% GPU ... 19 seconds from now']
second call     load 0.0
after 25s idle: []
reload          load 2.3
상황 불러오는 시간 ollama ps
keep_alive=0으로 호출 4.09초 (메모리에 없던 상태) 목록이 비어 있음
"20s"로 호출 2.3초 19 seconds from now로 카운트다운
20초 안에 다시 호출 0.0초 시간이 다시 20초로 갱신됨
25초 동안 쉼 - 목록이 비어 있음
내려간 뒤 다시 호출 2.3초 -
  • 0초로 부르면 바로 내려갑니다. 답을 받자마자 ollama ps가 비어 있었습니다.
  • 연속 호출에서는 불러오는 시간이 사라집니다. 두 번째 호출은 0.0초였습니다.
  • 내려간 뒤에는 불러오는 시간이 다시 듭니다. 이 모델은 2.3초였고, 큰 모델일수록 길어집니다. 앞선 글에서 31B 모델을 처음 올릴 때는 26초가 걸렸습니다.

keep_alive_test.py 실행 결과에서 keep_alive 0은 호출 직후 모델이 메모리에 없고, 20s는 19 seconds from now로 남으며, 바로 한 번 더 부르면 load 0.0이고, 25초 뒤에는 다시 사라지는 것을 확인합니다.
keep_alive_test.py 실행 결과에서 keep_alive 0은 호출 직후 모델이 메모리에 없고, 20s는 19 seconds from now로 남으며, 바로 한 번 더 부르면 load 0.0이고, 25초 뒤에는 다시 사라지는 것을 확인합니다.

29일에 전체 스크립트로 다시 실행해도 결과는 같았습니다. 불러오는 시간만 2.5~2.8초로 처음보다 조금 길었습니다.

이 단계의 파일 내려받기:keep_alive_test.py

4. 어떻게 고를까

상황 권장
하루 종일 쓰는 개인 PC, 메모리가 넉넉함 -1(무기한)이나 긴 시간
메모리가 빠듯하고 가끔 씀 기본값이나 "2m" 정도
한 번 돌리고 메모리를 비우고 싶음 호출에 keep_alive: 0
여러 모델을 번갈아 씀 짧게 잡아 두 모델이 동시에 메모리를 차지하지 않게 함

환경 변수로 전체 기본값을 바꿀 때는 Ollama를 완전히 종료했다가 다시 시작해야 합니다. 이 글에서는 환경 변수를 바꾸지 않았습니다.

더 해 보기: 표기, 서버 기본값, 모델 크기별 비용

위 실험에서 한 걸음 더 나가, 값을 어떻게 적느냐에 따라 달라지는 점, 서버 전체 기본값(OLLAMA_KEEP_ALIVE)과 요청값 중 무엇이 이기는지, 모델이 커질수록 첫 호출이 얼마나 비싸지는지를 확인했습니다. 본 서비스(11434)를 건드리지 않으려고 11501 포트에 임시 서버를 따로 띄웠고, 그 서버의 기본값을 OLLAMA_KEEP_ALIVE=10s로 주었습니다(keep_alive_more.py).

값의 표기

/api/ps가 알려 주는 expires_at(내려갈 시각)으로 호출 직후 남은 시간을 읽었습니다.

요청의 keep_alive 결과
0 또는 "0" 메모리에 없음. 응답 직후 바로 내려감
30 (숫자) 약 30초 뒤 내려감. 숫자는 초로 읽힘
"30s" 약 30초 뒤 내려감
"2m" 약 120초 뒤 내려감
"1h" 약 3600초 뒤 내려감
-1 (숫자) 무기한. 내려가지 않음
"-1" (문자열) 오류: time: missing unit in duration "-1"
지정 안 함 서버 기본값(이 글에서는 10초)을 따름. 약 10초 뒤 내려감

가장 조심할 것은 문자열 "-1"입니다. 숫자 -1은 "무기한"이지만 따옴표를 붙인 문자열 "-1"은 단위가 없는 기간으로 읽혀 오류가 납니다. 같은 값이 JSON 타입 하나에 따라 정반대로 처리되므로, 무기한은 숫자 -1로 씁니다. 숫자 30과 문자열 "30s"는 같았습니다.

서버 기본값과 요청값의 우선순위

지정 없이 호출하면 서버 기본값(10초)이 적용되었습니다. 호출 5초 뒤에는 "약 5초 뒤 내려감"으로 남은 시간이 줄고 있었고, 15초 뒤에는 모델이 메모리에서 사라졌습니다. 같은 서버에서 요청에 keep_alive: "1m"을 주면 서버 기본값이 아니라 요청값이 이겨서, 15초가 지난 뒤에도 약 45초가 남아 있었습니다(60초에서 15초 지남). 서버 설정은 기본값이고 요청마다 덮어쓸 수 있다는 뜻입니다. 여러 프로그램이 한 서버를 나눠 쓸 때, 각 프로그램이 자기 요청에 값을 주면 서로 영향을 주지 않습니다.

모델이 클수록 첫 호출이 비쌉니다

세 모델을 각각 내린 뒤 첫 호출과 바로 이어서 한 호출의 시간을 쟀습니다.

모델 첫 호출 불러오기 첫 호출 전체 이어서 부른 전체
exaone3.5:2.4b (1.6GB) 2.9초 3.0초 0.1초
qwen2.5:3b-instruct-q4_K_M (1.9GB) 4.9초 5.1초 0.1초
gemma4:31b (20GB) 44.3초 45.0초 0.6초

큰 모델은 첫 호출에 44초가 걸렸고 이어서 부르면 1초가 되지 않았습니다. 작은 모델은 3~5초라서 keep_alive: 0으로 매번 내려도 견딜 수 있지만, 20GB 모델은 사용자가 매번 45초를 기다리게 됩니다. 큰 모델은 keep_alive를 넉넉히 주고 메모리 압박이 있을 때만 줄입니다. 28일에 본 31B의 로딩 26초와 이번의 44초가 다른 것은 이번에 다른 모델 두 개가 이미 메모리에 올라 있고 한 번씩만 재서 생긴 차이로 추정합니다.

keep_alive_more.py 실행 결과에서 표기별 남는 시간이 0은 없음, 30과 30s는 30초, 숫자 -1은 무기한, 문자열 -1은 오류로 나오고, 서버 기본값 10초가 지켜지며 요청의 1m이 이기고, 31B의 첫 호출이 44초인 것을 확인합니다.
keep_alive_more.py 실행 결과에서 표기별 남는 시간이 0은 없음, 30과 30s는 30초, 숫자 -1은 무기한, 문자열 -1은 오류로 나오고, 서버 기본값 10초가 지켜지며 요청의 1m이 이기고, 31B의 첫 호출이 44초인 것을 확인합니다.

keep_alive_more.py(아래)는 임시 서버를 띄우고 끝에서 그 서버만 끕니다. 큰 모델을 한 번 더 올리므로 메모리가 넉넉한 PC에서만 실행합니다.

"""Ollama keep_alive 심화: 값의 여러 표기, 서비스 기본값(OLLAMA_KEEP_ALIVE)과 요청값의 우선순위, 모델 크기별 첫 호출 비용.

준비: Ollama 설치, ollama pull exaone3.5:2.4b qwen2.5:3b-instruct-q4_K_M gemma4:31b, pip install requests
주의: 본 서비스(11434)는 건드리지 않고, 11501 포트에 임시 서버를 따로 띄운다(OLLAMA_KEEP_ALIVE=10s). 끝에서 이 서버만 끈다.
      큰 모델(20GB)을 임시 서버가 한 번 더 올리므로 메모리가 넉넉한 PC에서만 실행한다.
실행: python -X utf8 keep_alive_more.py   (약 3분)
"""
import os
import subprocess
import time
from datetime import datetime, timezone

import requests

PORT = 11501
URL = f"http://127.0.0.1:{PORT}"
SMALL, MID, BIG = "exaone3.5:2.4b", "qwen2.5:3b-instruct-q4_K_M", "gemma4:31b"

env = dict(os.environ, OLLAMA_HOST=f"127.0.0.1:{PORT}", OLLAMA_KEEP_ALIVE="10s")
srv = subprocess.Popen(["ollama", "serve"], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
for _ in range(30):
    try:
        requests.get(URL + "/api/version", timeout=1)
        break
    except requests.RequestException:
        time.sleep(1)


def gen(model, keep=None, n=5):
    body = {"model": model, "prompt": "안녕", "stream": False, "options": {"num_predict": n}}
    if keep is not None:
        body["keep_alive"] = keep
    t = time.time()
    d = requests.post(URL + "/api/generate", json=body, timeout=600).json()
    if "error" in d:
        return d["error"], None
    return d["load_duration"] / 1e9, time.time() - t


def remaining(model):
    """/api/ps 의 expires_at 에서 지금까지 남은 초(없으면 None)"""
    for m in requests.get(URL + "/api/ps").json()["models"]:
        if m["name"] == model:
            e = datetime.fromisoformat(m["expires_at"].replace("Z", "+00:00"))
            return (e - datetime.now(timezone.utc)).total_seconds()
    return None


def fmt(s):
    return "메모리에 없음" if s is None else ("무기한" if s > 3e8 else f"약 {s:.0f}초 뒤 내려감")


try:
    print("## 1. keep_alive 표기별로 모델이 얼마나 남는가(exaone, 호출 직후 /api/ps 의 expires_at)")
    for keep in (0, "0", 30, "30s", "2m", "1h", -1, "-1", None):
        subprocess.run(["ollama", "stop", SMALL], env=env, capture_output=True)
        err, _ = gen(SMALL, keep)
        label = "(지정 안 함, 서버 기본값 10s)" if keep is None else repr(keep)
        print(f"  keep_alive={label:<30} -> {('오류: ' + str(err)[:70]) if isinstance(err, str) else fmt(remaining(SMALL))}")

    print("\n## 2. 서버 기본값(10s)이 실제로 지켜지는가: 지정 없이 호출한 뒤 5초, 15초 후")
    subprocess.run(["ollama", "stop", SMALL], env=env, capture_output=True)
    gen(SMALL)
    time.sleep(5)
    a = remaining(SMALL)
    time.sleep(10)
    b = remaining(SMALL)
    print(f"  호출 5초 뒤: {fmt(a)}   /   15초 뒤: {fmt(b)}")

    print("\n## 3. 요청의 keep_alive 가 서버 기본값보다 우선하는가: keep_alive=\"1m\" 로 호출하고 15초 뒤")
    gen(SMALL, "1m")
    time.sleep(15)
    print(f"  15초 뒤: {fmt(remaining(SMALL))}")

    print("\n## 4. 첫 호출(모델 불러오기) 비용과 이어서 부른 비용 - 모델 크기별")
    print(f"  {'모델':<28}{'첫 호출 불러오기':>16}{'첫 호출 전체':>12}{'이어서 부른 전체':>16}")
    for m in (SMALL, MID, BIG):
        subprocess.run(["ollama", "stop", m], env=env, capture_output=True)
        l1, t1 = gen(m, "1m")
        l2, t2 = gen(m, "1m")
        print(f"  {m:<28}{l1:>14.1f}초{t1:>10.1f}초{t2:>14.1f}초")
        subprocess.run(["ollama", "stop", m], env=env, capture_output=True)
finally:
    srv.terminate()
    srv.wait(timeout=30)
    time.sleep(1)
    r = subprocess.run(["netstat", "-ano"], capture_output=True, text=True).stdout
    print("\n## 5. 정리: 임시 서버 11501 포트가 열린 줄 수:", sum(1 for l in r.splitlines() if f":{PORT} " in l and "LISTENING" in l))
이 단계의 파일 내려받기:keep_alive_more.py

전체 코드

아래 파일 하나가 이 글의 시험을 모두 실행합니다(약 40초). 그대로 복사해 keep_alive_test.py로 저장하고 python -X utf8 keep_alive_test.py로 실행합니다. 이 모델만 내리고 올리며 다른 모델과 서비스 설정은 건드리지 않습니다.

# keep_alive_test.py
"""Ollama keep_alive: 모델을 메모리에 얼마나 남길지 호출마다 정하고, ollama ps 로 확인한다.

준비: Ollama 실행 중, ollama pull exaone3.5:2.4b, pip install requests
주의: 이 파일은 exaone3.5:2.4b 만 건드린다. 서비스 전체 설정(OLLAMA_KEEP_ALIVE)은 바꾸지 않는다.
실행: python -X utf8 keep_alive_test.py   (약 40초)
"""
import subprocess
import time
import requests

URL = "http://localhost:11434/api/generate"
MODEL = "exaone3.5:2.4b"


def ps():
    out = subprocess.run(["ollama", "ps"], capture_output=True, text=True).stdout.splitlines()
    rows = [" ".join(l.split()) for l in out[1:] if l.startswith("exaone")]
    return rows or ["(메모리에 없음)"]


def go(keep_alive):
    d = requests.post(URL, json={"model": MODEL, "prompt": "안녕", "stream": False,
                                 "keep_alive": keep_alive, "options": {"num_predict": 5}}, timeout=120).json()
    return round(d["load_duration"] / 1e9, 2)   # 모델을 불러오는 데 걸린 초(이미 올라 있으면 0)


subprocess.run(["ollama", "stop", MODEL], capture_output=True)   # 깨끗한 상태에서 시작
print("keep_alive=0    load", go(0), "| 호출 직후:", ps())
time.sleep(1)
print("keep_alive=20s  load", go("20s"), "| 호출 직후:", ps())
print("바로 한 번 더   load", go("20s"))
time.sleep(25)
print("25초 쉰 뒤:", ps())
print("다시 호출       load", go("0"))
이 단계의 파일 내려받기:keep_alive_test.py

자주 막히는 곳

증상 원인과 해결
호출에서 keep_alive: 0을 줬는데 모델이 남아 있습니다 다른 프로그램이 같은 모델을 동시에 쓰고 있을 수 있습니다. 이 글에서는 확인하지 않았습니다
ollama ps에 Forever가 보입니다 OLLAMA_KEEP_ALIVE=-1 또는 호출의 -1 때문입니다. 환경 변수 위치를 확인합니다
모델을 바로 내리고 싶습니다 ollama stop 모델이름

확인 범위

  • 해 본 것: 29일에 임시 서버(11501)로 keep_alive 표기 아홉 가지, 서버 기본값과 요청값의 우선순위, 모델 세 개의 첫 호출 시간을 확인했습니다. 앞의 확인 내용은 다음과 같습니다. 2026-10-28과 29일, Windows 11 · Ollama 0.32.15, 모델 exaone3.5:2.4b로 위 스크립트를 실행했고 29일에 전체 스크립트로 다시 확인했습니다.
  • 해 보지 않은 것: 서비스 전체 기본값(OLLAMA_KEEP_ALIVE)을 본 서비스에서 바꾸는 것, 모델 여러 개가 동시에 올라 있을 때의 메모리 압박으로 인한 강제 해제, 환경 변수를 지웠을 때의 기본 동작, Linux와 macOS.
  • 읽을 때 주의: 불러오는 시간은 모델 크기와 디스크 상태에 따라 달라집니다. 한 번 잰 값입니다.

이 글은 Ollama와 로컬 LLM 실습 로드맵의 한 단계입니다.

이 글의 다음 단계

이 내용을 팀 교육으로 진행하고 싶으신가요?

인원, 수준, 일정에 맞춰 실습 환경까지 준비해 진행합니다. 대상과 기간을 알려 주시면 구성을 제안해 드립니다.

교육 문의하기

교육 진행 순서와 자주 묻는 질문 보기

팀이나 교육 담당자에게 이 글 제안하기

메일로 보내실 수도 있습니다: fankh111@gmail.com

같은 카테고리의 글