# Ollama num_ctx를 키우면 메모리는 얼마나 늘까: 2K, 8K, 32K 측정

> 같은 2.4B 모델을 컨텍스트 길이 2048, 8192, 32768로 올려 보고 ollama ps의 메모리 사용량, 불러오는 시간, 생성 속도를 비교합니다. 긴 문서를 다루려고 num_ctx를 키울 때 치르는 비용을 숫자로 봅니다.

- 주소: https://copyandrun.com/blog/ollama-num-ctx-memory-speed/
- 분야: AI
- 발행일: 2026-10-28
- 태그: Ollama, num_ctx, 컨텍스트, 메모리

컨텍스트 길이(`num_ctx`)는 모델이 한 번에 읽고 기억할 수 있는 토큰 수입니다. 긴 문서를 넣거나 대화가 길어지면 이 값이 부족해 앞부분을 잊거나 답이 끊깁니다. 그렇다고 무작정 키우면 메모리를 더 씁니다. 이 글에서는 같은 모델에서 값만 바꿔 가며 그 비용을 잽니다.

요청을 여러 개 동시에 받을 때 처리량이 어떻게 달라지는지는 [동시 요청 처리량 재기](/blog/ollama-parallel-requests-throughput/) 글에서 1, 2, 4, 8개 요청으로 나눠 쟀습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| Ollama | 0.32.15 (Windows 11) |
| 모델 | `exaone3.5:2.4b` (파일 1.6GB) |
| PC | AMD Ryzen AI Max+ 395, 메모리 약 96GB, 그래픽이 메모리를 공유 |

## 1. 측정 스크립트

<!-- files: ctx_test.py -->

호출마다 `options.num_ctx`를 바꿔 같은 짧은 질문을 보내고, 직후 `ollama ps`로 올라간 크기를 읽습니다. `num_ctx`가 바뀌면 Ollama가 모델을 새 설정으로 다시 올립니다.

```python
import requests, subprocess

for n in (2048, 8192, 32768):
    d = requests.post("http://localhost:11434/api/generate", json={
        "model": "exaone3.5:2.4b", "prompt": "한국어로 한 문장만 인사해 주세요.",
        "stream": False, "options": {"num_ctx": n, "num_predict": 60}}).json()
    ps = subprocess.run(["ollama", "ps"], capture_output=True, text=True).stdout.splitlines()
    row = [l for l in ps if l.startswith("exaone")]
    print(n, "load %.1fs" % (d["load_duration"] / 1e9),
          "eval %.1f tok/s" % (d["eval_count"] / (d["eval_duration"] / 1e9)), "|", " ".join(row[0].split()))
```

## 2. 결과

```
# 기대 출력(이 PC)
2048  load 2.3s eval 87.8 tok/s | exaone3.5:2.4b ... 1.7 GB 100% GPU 2048
8192  load 2.4s eval 95.1 tok/s | exaone3.5:2.4b ... 2.2 GB 100% GPU 8192
32768 load 3.5s eval 91.5 tok/s | exaone3.5:2.4b ... 4.1 GB 100% GPU 32768
```

| num_ctx | ollama ps 크기 | 불러오는 시간 | 생성 속도 |
|---|---|---|---|
| 2,048 | 1.7GB | 2.3초 | 약 88토큰/초 |
| 8,192 | 2.2GB | 2.4초 | 약 95토큰/초 |
| 32,768 | 4.1GB | 3.5초 | 약 92토큰/초 |

- **메모리는 늘어납니다.** 컨텍스트를 16배로 키우자 올라간 크기가 1.7GB에서 4.1GB로 2.4배가 됐습니다. 모델 파일(1.6GB)은 그대로이므로 늘어난 몫이 대화 기억 공간입니다.
- **짧은 질문에서는 속도가 거의 같습니다.** 88에서 95토큰/초 사이의 차이는 한 번씩 잰 값이라 흔들림으로 봅니다. 이 실험은 입력이 짧아서, 컨텍스트를 실제로 가득 채웠을 때의 속도는 재지 않았습니다.
- **불러오는 시간은 조금 늘었습니다.** 2.3초에서 3.5초입니다.

## 2-1. 컨텍스트를 실제로 채우면

<!-- files: ctx_test.py -->

위 실험은 짧은 질문이라 컨텍스트가 거의 비어 있었습니다. 이번에는 긴 글 맨 앞에 비밀 코드(`ZEBRA-4417`)를 적고, 서버 점검 문장을 30줄 또는 160줄 붙인 뒤 "맨 앞의 코드가 무엇인가"를 물었습니다. 모델은 `qwen2.5:3b-instruct-q4_K_M`, `temperature`는 0입니다. 응답의 `prompt_eval_count`가 모델이 실제로 읽은 입력 토큰 수입니다.

| 글 길이 | num_ctx | 읽은 입력 | 답 |
|---|---|---|---|
| 30줄 | 2,048 | 979토큰 | 오답(질문을 되풀이함) |
| 30줄 | 8,192 | 979토큰 | 정답 |
| 160줄 | 2,048 | 1,026토큰 | 오답 |
| 160줄 | 8,192 | 4,999토큰 | 오답 |

![ctx_test.py 실행 결과에서 num_ctx별 메모리 표와, 글 길이와 num_ctx 조합별로 읽은 입력 토큰 수와 정답 여부가 나오는 것을 확인합니다.](https://copyandrun.com/img/ollama-num-ctx-memory-speed/01-ctx-실험-결과.png)

- **입력이 컨텍스트보다 길면 일부가 잘립니다.** 160줄 글은 8,192에서 4,999토큰을 읽었지만 2,048에서는 1,026토큰만 읽었습니다. 입력 전체의 약 5분의 1입니다. 어느 부분이 남았는지는 확인하지 않았지만, 읽은 토큰 수가 입력 길이보다 훨씬 작다는 것이 잘림의 신호입니다. 오류 메시지는 나오지 않았습니다.
- **그래서 `prompt_eval_count`를 확인합니다.** 긴 문서를 넣을 때 이 값이 내가 보낸 길이와 비슷한지 보면, 조용히 잘렸는지 알 수 있습니다.
- **컨텍스트가 크다고 정답이 보장되지는 않습니다.** 30줄 글에서는 979토큰이 두 설정 모두 컨텍스트 안에 들어갔는데 2,048에서만 오답이었고, 160줄 글은 4,999토큰을 전부 읽고도 오답이었습니다. 3B 모델이 긴 글 앞쪽의 정보를 찾는 데 약하기 때문으로 보이나, 한 번씩 잰 값이라 원인을 단정하지 않습니다.

## 3. 고르는 기준

이 PC는 메모리가 넉넉해서 32K도 부담이 없었지만, 메모리가 적은 PC에서는 같은 비율로 늘어나는 몫이 문제가 됩니다. 모델이 클수록 컨텍스트 하나당 늘어나는 양도 커진다고 알려져 있지만, 이 글에서는 다른 모델로 확인하지 않았습니다. 안전한 순서는 이렇습니다.

1. 기본값(`ollama ps`의 `CONTEXT` 열)으로 먼저 씁니다.
2. 답이 끊기거나 앞 내용을 잊으면 두 배씩 올립니다.
3. 올릴 때마다 `ollama ps`의 `SIZE`와 `PROCESSOR`(`100% GPU`인지)를 봅니다.

## 더 해 보기: 모델 두 개의 메모리 증가와 입력 길이별 처리 시간

위 실험은 `exaone3.5:2.4b` 하나에서 `num_ctx`를 키울수록 메모리가 늘어나는 것을 보여 주었습니다. 다른 모델에서도 같은지, `num_ctx`를 아주 크게 주면 어떻게 되는지, 긴 입력을 읽는 데 시간이 얼마나 더 드는지를 확인했습니다(`ctx_more.py`). 본 서비스(11434)를 건드리지 않으려고 11503 포트에 임시 서버를 띄웠습니다.

### num_ctx별 올라간 메모리

짧은 질문 하나로 모델을 올리고 `/api/ps`가 알려 주는 크기를 읽었습니다.

| 모델 | num_ctx | 올라간 메모리 | 불러오기 | 생성 속도 |
|---|---|---|---|---|
| exaone3.5:2.4b | 2048 | 1.7GB | 2.8초 | 86토큰/초 |
| exaone3.5:2.4b | 8192 | 2.2GB | 2.5초 | 83토큰/초 |
| exaone3.5:2.4b | 32768 | 4.1GB | 3.3초 | 86토큰/초 |
| exaone3.5:2.4b | 65536 | 4.1GB | 3.1초 | 84토큰/초 |
| qwen2.5:3b | 2048 | 2.1GB | 5.3초 | 63토큰/초 |
| qwen2.5:3b | 8192 | 2.4GB | 3.0초 | 66토큰/초 |
| qwen2.5:3b | 32768 | 3.3GB | 3.5초 | 63토큰/초 |
| qwen2.5:3b | 65536 | 3.3GB | 3.3초 | 66토큰/초 |

- **메모리는 `num_ctx`에 따라 늘어납니다.** exaone은 2048에서 1.7GB, 32768에서 4.1GB로 2.4배가 되었습니다. 모델 파일(1.6GB)보다 작업 공간이 커지는 것입니다. qwen2.5:3b는 2.1GB에서 3.3GB로 1.6배였습니다. 늘어나는 정도는 모델마다 다릅니다.
- **속도는 거의 변하지 않았습니다.** 짧은 질문에서 생성 속도는 같은 모델 안에서 83~86, 63~66토큰/초로 `num_ctx`와 무관했습니다. 메모리만 더 쓰는 셈입니다. 불러오는 시간도 모델마다 3초 안팎이어서 큰 차이가 없었습니다(qwen의 첫 5.3초는 처음 읽을 때의 영향으로 추정합니다).
- **65536을 주어도 32768과 같았습니다.** 두 모델 모두 `num_ctx`를 65536으로 주었는데 메모리가 32768일 때와 같았습니다. `ollama show`가 알려 주는 두 모델의 최대 컨텍스트(`context length`)가 모두 32768이기 때문으로 추정합니다. 모델이 지원하는 한도보다 큰 값을 주어도 한도에서 멈추고 오류는 나지 않았습니다. 입력이 한도를 넘으면 위 2-1절처럼 조용히 잘리는지는 65536 설정으로는 확인하지 않았습니다. 큰 값을 줬다고 큰 입력이 들어간다고 믿지 말고 `prompt_eval_count`를 확인합니다.

### 입력 길이에 따른 입력 처리 시간

`qwen2.5:3b`(`num_ctx` 8192)에 같은 문장을 반복해 길이를 늘려 넣고 입력을 읽는 데 걸린 시간을 쟀습니다.

| 넣은 글자 수 | 읽은 토큰 | 입력 처리 시간 | 처리 속도 |
|---|---|---|---|
| 560 | 461 | 0.28초 | 1672토큰/초 |
| 2,240 | 1,721 | 0.50초 | 3430토큰/초 |
| 8,960 | 6,761 | 2.56초 | 2643토큰/초 |

입력이 16배(560자에서 8,960자)로 늘 때 처리 시간은 약 9배(0.28초에서 2.56초)가 되었습니다. 입력 길이에 정확히 비례하지는 않았고, 아주 짧은 입력은 고정 비용 때문에 속도가 낮게 나왔습니다(1672토큰/초). 6,761토큰짜리 입력을 읽는 데 2.6초면 긴 문서를 한 번 넣는 비용은 감당할 만하지만, 같은 긴 문서를 매 질문마다 다시 넣으면 그 시간이 매번 더해집니다. 한 번씩만 잰 값입니다.

![ctx_more.py 실행 결과에서 exaone은 num_ctx 2048에서 1.7GB, 32768에서 4.1GB이고 65536에서도 4.1GB이며, qwen2.5:3b는 2.1GB에서 3.3GB로 늘고, 입력이 길수록 입력 처리 시간이 0.28초에서 2.56초로 늘어나는 것을 확인합니다.](https://copyandrun.com/img/ollama-num-ctx-memory-speed/02-모델별-메모리-입력-처리.png)

`ctx_more.py`는 아래와 같습니다. 임시 서버를 띄우고 끝에서 그 서버만 끕니다.

```python
"""Ollama num_ctx 심화: 모델 두 개에서 num_ctx 별 올라간 메모리, 불러오는 시간, 속도, 그리고 입력 길이에 따른 입력 처리 시간.

준비: Ollama 설치, ollama pull exaone3.5:2.4b qwen2.5:3b-instruct-q4_K_M, pip install requests
주의: 본 서비스(11434)는 건드리지 않고 11503 포트에 임시 서버를 띄운다. 끝에서 이 서버만 끈다.
실행: python -X utf8 ctx_more.py   (약 3분)
"""
import os
import subprocess
import time

import requests

PORT = 11503
URL = f"http://127.0.0.1:{PORT}"
MODELS = ["exaone3.5:2.4b", "qwen2.5:3b-instruct-q4_K_M"]

srv = subprocess.Popen(["ollama", "serve"], env=dict(os.environ, OLLAMA_HOST=f"127.0.0.1:{PORT}", OLLAMA_KEEP_ALIVE="2m"),
                       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, prompt, num_ctx, n=40):
    d = requests.post(URL + "/api/generate", json={"model": model, "prompt": prompt, "stream": False,
                      "options": {"num_ctx": num_ctx, "num_predict": n, "temperature": 0}}, timeout=900).json()
    return d


def mem(model):
    for m in requests.get(URL + "/api/ps").json()["models"]:
        if m["name"] == model:
            return m["size"] / 1e9
    return None


try:
    print("## 1. num_ctx 별 올라간 메모리(짧은 질문, /api/ps 의 크기)")
    print(f"  {'모델':<28}{'num_ctx':>8}{'메모리':>9}{'불러오기':>9}{'생성 속도':>12}")
    for m in MODELS:
        for n in (2048, 8192, 32768, 65536):
            subprocess.run(["ollama", "stop", m], env=dict(os.environ, OLLAMA_HOST=f"127.0.0.1:{PORT}"), capture_output=True)
            d = gen(m, "한 문장으로 인사해 주세요.", n)
            print(f"  {m:<28}{n:>8}{mem(m):>7.1f}GB{d['load_duration'] / 1e9:>7.1f}초{d['eval_count'] / (d['eval_duration'] / 1e9):>8.0f}tok/s")

    print("\n## 2. 입력 길이에 따른 입력 처리 시간(qwen2.5:3b, num_ctx 8192)")
    m = MODELS[1]
    sentence = "서버의 디스크 사용률은 높고 점검자는 김씨입니다. "
    print(f"  {'넣은 글자 수':>10}{'읽은 토큰':>10}{'입력 처리 시간':>14}{'토큰/초':>10}")
    gen(m, "준비", 8192, 1)
    for reps in (20, 80, 320):
        d = gen(m, sentence * reps + "\n위 내용을 한 단어로 요약하세요.", 8192, 5)
        pe, pd = d["prompt_eval_count"], d["prompt_eval_duration"] / 1e9
        print(f"  {len(sentence) * reps:>10}{pe:>10}{pd:>12.2f}초{pe / pd:>10.0f}")
finally:
    srv.terminate()
    srv.wait(timeout=30)
    time.sleep(1)
    r = subprocess.run(["netstat", "-ano"], capture_output=True, text=True).stdout
    print("\n## 3. 정리: 임시 서버 11503 포트가 열린 줄 수:", sum(1 for l in r.splitlines() if f":{PORT} " in l and "LISTENING" in l))
```

## 전체 코드

아래 파일 하나로 1번(메모리와 속도)과 2-1번(컨텍스트 채우기)을 모두 다시 할 수 있습니다. 그대로 복사해 `ctx_test.py`로 저장하고 `python -X utf8 ctx_test.py`로 실행합니다. 모델 두 개를 미리 받아 둡니다.

```python
# ctx_test.py
"""Ollama num_ctx 실험 두 가지.
  1. 짧은 질문으로 num_ctx 를 2048, 8192, 32768 로 바꿔 메모리, 불러오는 시간, 생성 속도를 잰다.
  2. 긴 글 맨 앞에 비밀 코드를 적고, 글을 끝까지 넣은 뒤 코드를 묻는다(num_ctx 에 따라 앞부분을 잊는지 본다).

준비: Ollama 실행 중, 모델 exaone3.5:2.4b 와 qwen2.5:3b-instruct-q4_K_M (ollama pull 로 받는다), pip install requests
실행: python -X utf8 ctx_test.py
"""
import subprocess
import time
import requests

URL = "http://localhost:11434/api/generate"
MODEL = "exaone3.5:2.4b"
MODEL2 = "qwen2.5:3b-instruct-q4_K_M"   # 2번 실험용(앞부분 기억 시험)


def ps_row():
    out = subprocess.run(["ollama", "ps"], capture_output=True, text=True).stdout.splitlines()
    rows = [l for l in out if l.startswith(MODEL.split(":")[0])]
    return " ".join(rows[0].split()) if rows else "(내려감)"


def ask(prompt, num_ctx, num_predict=60, model=MODEL):
    t = time.time()
    d = requests.post(URL, json={"model": model, "prompt": prompt, "stream": False,
                                 "options": {"num_ctx": num_ctx, "num_predict": num_predict, "temperature": 0}},
                      timeout=600).json()
    d["wall"] = time.time() - t
    return d


print("== 1. 짧은 질문: num_ctx 별 메모리와 속도")
for n in (2048, 8192, 32768):
    d = ask("한국어로 한 문장만 인사해 주세요.", n)
    print(n, "load %.1fs" % (d["load_duration"] / 1e9),
          "eval %.1f tok/s" % (d["eval_count"] / (d["eval_duration"] / 1e9)), "|", ps_row())

print("== 2. 긴 글 맨 앞의 코드를 기억하나 (모델 %s)" % MODEL2)
CODE = "ZEBRA-4417"
KINDS = ["웹", "DB", "캐시", "배치"]


def make_prompt(items):
    filler = "".join("%d번 서버(%s)의 디스크 사용률은 %d퍼센트이고 점검자는 %s입니다. "
                     % (i, KINDS[i % 4], 40 + (i * 7) % 50, "김이박최정"[i % 5]) for i in range(1, items + 1))
    return ("[중요] 이 문서의 비밀 코드는 %s 입니다.\n" % CODE + filler +
            "\n질문: 이 문서 맨 앞에 적힌 비밀 코드는 무엇입니까? 코드만 답하세요.")


for items in (30, 160):
    prompt = make_prompt(items)
    for n in (2048, 8192):
        d = ask(prompt, n, num_predict=30, model=MODEL2)
        ans = d["response"].strip().replace("\n", " ")
        print("서버 %3d줄 | num_ctx %-5d 읽은 입력 %5d토큰 | 입력 처리 %.0f tok/s | 총 %.1fs | 답: %-12s %s"
              % (items, n, d["prompt_eval_count"], d["prompt_eval_count"] / (d["prompt_eval_duration"] / 1e9),
                 d["wall"], ans[:12], "정답" if CODE in ans else "오답"))
```

## 자주 막히는 곳

| 증상 | 원인과 해결 |
|---|---|
| `num_ctx`를 바꿨는데 이전 값이 그대로입니다 | 모델이 이미 올라가 있는 경우입니다. `ollama stop 모델이름` 뒤에 다시 호출합니다 |
| 값을 키웠더니 `PROCESSOR`에 CPU 비율이 생깁니다 | 그래픽 쪽 메모리가 모자라 일부가 CPU로 넘어간 것입니다. 값을 줄이거나 작은 모델을 씁니다 |
| 호출마다 설정을 넣기 번거롭습니다 | Modelfile의 `PARAMETER num_ctx`로 고정합니다. 같은 사이트의 Modelfile 글을 봅니다 |

## 확인 범위

- **해 본 것:** 29일에 임시 서버(11503)에서 모델 두 개의 num_ctx별 메모리와 속도, 입력 길이별 처리 시간을 확인했습니다. 앞의 확인 내용은 다음과 같습니다. 2026-10-28과 29일, Windows 11 · Ollama 0.32.15, 모델 `exaone3.5:2.4b`로 위 스크립트를 실행했고, 29일에 전체 스크립트로 컨텍스트를 채우는 실험(`qwen2.5:3b-instruct-q4_K_M`)을 더했습니다. 29일 재실행에서 1번 실험의 생성 속도는 세 설정 모두 약 107토큰/초로, 처음 실행(88~95)보다 높았습니다.
- **해 보지 않은 것:** 가장 큰 모델에서의 메모리 증가, 더 큰 모델의 긴 글 기억력, 잘린 부분이 앞인지 뒤인지의 확인, 별도 그래픽 카드가 있는 PC, Linux와 macOS.
- **읽을 때 주의:** 2-1의 정답 여부는 조합마다 한 번씩만 잰 값입니다.
