一行命令 ollama run llama3，本地大模型就跑起来了。
Ollama 把本地 LLM 部署的门槛压到了最低——但"能跑"和"跑得快"之间，隔着 GPU 配置、量化选择、多卡调度、API 集成这些硬核知识
这篇文章从安装到优化，完整覆盖。
一、Ollama 是什么
Ollama 是一个一键本地运行大模型的工具，极简 CLI 体验，开发者入门标配。
1.1 核心定位
Ollama = 本地大模型的 Docker
├── 一行命令拉取模型: ollama pull llama3
├── 一行命令运行模型: ollama run llama3
├── OpenAI 兼容 API: http://localhost:11434/v1
├── 自动 GPU 加速: 检测到 GPU 就用，没有就 CPU
├── GGUF 量化格式: 4-bit 量化，8GB 显存跑 7B 模型
└── 多模型管理: 拉取/删除/列表/更新
1.2 与其他工具的定位对比
吞吐量/性能
▲
│
TensorRT-LLM ● │
│
SGLang ● │
vLLM ● │
│
Ollama ● │
llama.cpp●
LM Studio ● │
│
└──────────────────────────► 易用性
一句话：Ollama 是本地开发的首选，vLLM/SGLang 是生产服务的首选，TensorRT-LLM 是极致性能的首选。
二、实战1：安装 Ollama
2.1 安装
# macOS / Linux（一键安装）
curl -fsSL https://ollama.com/install.sh | sh
# Windows
# 从 https://ollama.com/download 下载安装包
# 验证安装
ollama --version
# 输出: ollama version is 0.x.x
2.2 系统要求
2.3 一键拉取运行
# 拉取并运行 Llama 3.1
ollama run llama3.1
# 首次运行自动拉取模型（约 4.7GB），后续直接加载
# 拉取 Qwen3
ollama run qwen3:7b
# 拉取 DeepSeek
ollama run deepseek-r1:7b
# 在对话中直接使用
>>> 你好，请介绍一下自己
# 模型开始生成回答...
# 退出对话
>>> /bye
2.4 GPU 支持情况
Ollama GPU 支持：
├── NVIDIA
│ ├── 计算能力 5.0+（GTX 900 系列及以后）
│ ├── 驱动版本 531+
│ └── 自动检测，无需配置
│
├── AMD
│ ├── Radeon RX 5000 系列及以后
│ ├── Windows 和 Linux 支持
│ └── 需要安装 ROCm
│
└── Apple Silicon
├── M1/M2/M3/M4 系列芯片
├── 统一内存架构，内存越大越好
└── Metal 自动加速，无需配置
验证 GPU 是否被使用：
# NVIDIA
nvidia-smi
# 在 Ollama 运行时查看 GPU 使用率
nvidia-smi dmon -s u
# "sm" 值 > 0 说明 GPU 正在被使用
# Apple Silicon
# 打开"活动监视器" → "GPU 历史记录"
# Ollama 运行时 GPU 使用率应上升
三、实战2：自定义 Modelfile
3.1 什么是 Modelfile
Modelfile 是 Ollama 的模型定义文件，类似 Dockerfile。
你可以基于已有模型创建自定义变体。
3.2 从 GGUF 创建自定义模型
# 1. 下载 GGUF 模型文件
# 从 Hugging Face 下载，例如：
wget https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf
# 2. 创建 Modelfile
cat > Modelfile <<EOF
FROM ./llama-2-7b-chat.Q4_K_M.gguf
# 设置参数
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER num_batch 512
# 设置系统提示词
SYSTEM """
You are a helpful AI assistant specializing in software engineering.
You provide clear, practical answers with code examples.
Always respond in the same language as the user's question.
"""
# 设置模板
TEMPLATE """
{{- if .System }}
<|im_start|>system
{{ .System }}<|im_end|>
{{- end }}
<|im_start|>user
{{ .Prompt }}<|im_end|>
<|im_start|>assistant
{{ .Response }}<|im_end|>
"""
EOF
# 3. 创建模型
ollama create my-llama2 -f Modelfile
# 4. 运行自定义模型
ollama run my-llama2
3.3 基于已有模型创建变体
# 基于官方模型修改参数
cat > Modelfile <<EOF
FROM qwen3:7b
# 调整参数
PARAMETER temperature 0.3
PARAMETER top_p 0.85
PARAMETER num_ctx 8192
PARAMETER repeat_penalty 1.1
# 自定义系统提示词
SYSTEM """
你是一位资深 Python 开发工程师。
你擅长代码审查、性能优化和架构设计。
回答问题时：
1. 先给出结论
2. 再解释原因
3. 最后给出代码示例
"""
EOF
# 创建并运行
ollama create python-expert -f Modelfile
ollama run python-expert
3.4 Modelfile 参数详解
# 核心参数
PARAMETER temperature 0.7 # 生成随机性 (0-2)
PARAMETER top_p 0.9 # 核采样概率
PARAMETER top_k 40 # Top-K 采样
PARAMETER num_ctx 4096 # 上下文窗口长度
PARAMETER num_batch 512 # 批处理大小
PARAMETER num_gpu 1 # GPU 层数 (-1=全部)
PARAMETER repeat_penalty 1.1 # 重复惩罚
PARAMETER seed 42 # 随机种子（可复现）
# 高级参数
PARAMETER mirostat 2 # Mirostat 采样 (0/1/2)
PARAMETER mirostat_eta 0.1 # Mirostat 学习率
PARAMETER mirostat_tau 5.0 # Mirostat 目标熵
PARAMETER stop "<|im_end|>" # 停止词
PARAMETER num_keep 0 # 保留的 token 数
四、多 GPU 配置
4.1 单实例多 GPU（Tensor 并行）
# Ollama 自动检测多 GPU 并分布模型层
# 默认行为：将模型层平均分配到所有可用 GPU
# 查看可用 GPU
nvidia-smi -L
# GPU 0: NVIDIA RTX 4090 (UUID: ...)
# GPU 1: NVIDIA RTX 4090 (UUID: ...)
# 直接运行，Ollama 自动使用多 GPU
ollama run llama3.1:70b
# Ollama 会自动将 70B 模型分布到两张 GPU 上
4.2 指定使用特定 GPU
# 只使用 GPU 0
CUDA_VISIBLE_DEVICES=0 ollama run llama3.1:7b
# 只使用 GPU 1
CUDA_VISIBLE_DEVICES=1 ollama run llama3.1:7b
# 使用 GPU 0 和 1
CUDA_VISIBLE_DEVICES=0,1 ollama run llama3.1:70b
# 禁用 GPU，纯 CPU 运行
OLLAMA_NUM_GPU=0 ollama run llama3.1:7b
4.3 多实例负载均衡（推荐生产方案）
┌─────────────────────────────────────────────────────────┐
│ Nginx 负载均衡器 │
│ least_conn 策略 │
│ ┌──────────────┬──────────────┐ │
└───────────┼──────────────┼──────────────┼──────────────┘
│ │ │
┌──────▼──────┐ ┌────▼──────┐ ┌────▼──────┐
│ Ollama #1 │ │ Ollama #2 │ │ Ollama #3 │
│ Port:11434 │ │ Port:11435│ │ Port:11436│
│ GPU:0 │ │ GPU:1 │ │ GPU:2 │
└─────────────┘ └───────────┘ └───────────┘
# Nginx 配置：Ollama 多实例负载均衡
upstream ollama_backend {
least_conn; # 最少连接数策略
server 127.0.0.1:11434;
server 127.0.0.1:11435;
server 127.0.0.1:11436;
}
server {
listen 11439;
location / {
proxy_pass http://ollama_backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
# SSE 支持
proxy_buffering off;
proxy_cache off;
proxy_read_timeout 600s;
}
}
# 启动多个 Ollama 实例（每个绑定不同 GPU 和端口）
# 实例 1：GPU 0
CUDA_VISIBLE_DEVICES=0 OLLAMA_HOST=0.0.0.0:11434 ollama serve &
# 实例 2：GPU 1
CUDA_VISIBLE_DEVICES=1 OLLAMA_HOST=0.0.0.0:11435 ollama serve &
# 实例 3：GPU 2
CUDA_VISIBLE_DEVICES=2 OLLAMA_HOST=0.0.0.0:11436 ollama serve &
# 通过负载均衡器访问
curl http://localhost:11439/api/generate -d '{
"model": "llama3.1",
"prompt": "Hello, how are you?"
}'
4.4 为什么多实例 > 单实例多 GPU
结论：生产环境推荐多实例 + Nginx 负载均衡。
五、API 服务：OpenAI 兼容 API
5.1 启动 API 服务
# Ollama 启动后自动提供 API 服务
# 默认地址: http://localhost:11434
# 修改监听地址（允许远程访问）
OLLAMA_HOST=0.0.0.0:11434 ollama serve
5.2 OpenAI 兼容 API
"""
使用 OpenAI SDK 调用 Ollama
完全兼容 OpenAI API 格式
"""
from openai import OpenAI
# 只需修改 base_url，其他代码完全不变
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # Ollama 不需要真实 API Key，随便填
)
# 聊天补全
response = client.chat.completions.create(
model="llama3.1",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain quantum computing in simple terms."}
],
temperature=0.7,
max_tokens=500
)
print(response.choices[0].message.content)
# 流式输出
stream = client.chat.completions.create(
model="llama3.1",
messages=[
{"role": "user", "content": "Write a Python quicksort function."}
],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
5.3 原生 Ollama API
"""
使用 Ollama 原生 API
功能更丰富，支持更多参数
"""
import requests
import json
BASE_URL = "http://localhost:11434"
def generate(model: str, prompt: str, stream: bool = False) -> str:
"""文本生成"""
response = requests.post(
f"{BASE_URL}/api/generate",
json={
"model": model,
"prompt": prompt,
"stream": stream,
"options": {
"temperature": 0.7,
"num_ctx": 4096,
"num_batch": 512
}
}
)
if stream:
result = ""
for line in response.iter_lines():
if line:
data = json.loads(line)
result += data.get("response", "")
return result
else:
return response.json()["response"]
def chat(model: str, messages: list, stream: bool = False) -> str:
"""聊天对话"""
response = requests.post(
f"{BASE_URL}/api/chat",
json={
"model": model,
"messages": messages,
"stream": stream,
"options": {
"temperature": 0.7,
"num_ctx": 4096
}
}
)
if stream:
result = ""
for line in response.iter_lines():
if line:
data = json.loads(line)
if "message" in data:
result += data["message"].get("content", "")
return result
else:
return response.json()["message"]["content"]
def list_models() -> list:
"""列出已下载的模型"""
response = requests.get(f"{BASE_URL}/api/tags")
return response.json()["models"]
def pull_model(model_name: str) -> dict:
"""拉取模型"""
response = requests.post(
f"{BASE_URL}/api/pull",
json={"name": model_name, "stream": False}
)
return response.json()
def delete_model(model_name: str) -> dict:
"""删除模型"""
response = requests.delete(
f"{BASE_URL}/api/delete",
json={"name": model_name}
)
return response.json()
# 使用示例
if __name__ == "__main__":
# 列出模型
models = list_models()
print("Available models:")
for m in models:
print(f" {m['name']} ({m['size'] / 1e9:.1f} GB)")
# 生成文本
result = generate("llama3.1", "Explain Docker in 3 sentences.")
print(f"\nGenerated: {result}")
# 聊天对话
messages = [
{"role": "system", "content": "You are a Python expert."},
{"role": "user", "content": "Write a decorator that caches function results."}
]
result = chat("llama3.1", messages)
print(f"\nChat: {result}")
5.4 接入 LangChain
"""
Ollama + LangChain 集成
"""
from langchain_ollama import OllamaLLM, ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
# 方式1：使用 OllamaLLM
llm = OllamaLLM(
model="llama3.1",
base_url="http://localhost:11434",
temperature=0.7
)
result = llm.invoke("What is the capital of France?")
print(result)
# 方式2：使用 ChatOllama（推荐）
chat = ChatOllama(
model="llama3.1",
base_url="http://localhost:11434",
temperature=0.7
)
# 带 Chain 的用法
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful coding assistant."),
("human", "{input}")
])
chain = prompt | chat | StrOutputParser()
result = chain.invoke({"input": "Write a Python function to calculate fibonacci."})
print(result)
5.5 接入 Dify
Dify + Ollama 集成步骤：
1. 确保 Ollama 在运行
2. 进入 Dify → 设置 → 模型供应商
3. 选择 Ollama
4. 填入服务地址：
- Dify 和 Ollama 在同一主机: http://host.docker.internal:11434
- Ollama 在远程服务器: http://your-server-ip:11434
5. 保存
6. 在应用中选择 Ollama 模型即可使用
六、多模态模型
6.1 运行视觉语言模型
# 拉取 LLaVA（视觉语言模型）
ollama pull llava
# 运行并传入图片
ollama run llava
>>> What's in this image? /path/to/image.jpg
# 通过 API 传入图片
curl http://localhost:11434/api/generate -d '{
"model": "llava",
"prompt": "Describe what you see in this image",
"images": ["/path/to/image.jpg"]
}'
6.2 可用的多模态模型
# LLaVA 系列
ollama pull llava:7b # 7B 视觉模型
ollama pull llava:13b # 13B 视觉模型
# MiniCPM-V
ollama pull minicpm-v # 高效中文视觉模型
# Qwen-VL
ollama pull qwen2-vl # 通义千问视觉模型
七、模型管理
7.1 常用命令
# 拉取模型
ollama pull llama3.1 # 拉取最新版
ollama pull llama3.1:7b # 指定参数量
ollama pull llama3.1:7b-q4_K_M # 指定量化级别
# 运行模型（如果未拉取，自动拉取）
ollama run llama3.1
# 列出已下载的模型
ollama list
# NAME ID SIZE MODIFIED
# llama3.1:7b 1234abcd... 4.7 GB 2 days ago
# qwen3:7b 5678efgh... 4.4 GB 1 week ago
# 删除模型
ollama rm llama3.1:7b
# 查看模型信息
ollama show llama3.1:7b
# 更新模型（重新拉取）
ollama pull llama3.1
# 如果有新版本，自动更新
7.2 模型存储位置
# 默认存储位置
# macOS: ~/.ollama/models
# Linux: /usr/share/ollama/.ollama/models
# Windows: C:\Users\<username>\.ollama\models
# 修改存储位置
export OLLAMA_MODELS=/data/ollama/models
ollama serve
八、量化选择
8.1 量化级别对比
8.2 如何选择量化级别
你的显存有多少？
│
├── 4GB 以下
│ └── Q2_K 或换更小的模型（3B/1B）
│
├── 4-8GB
│ └── Q4_K_M ✅（性价比最优，精度损失可接受）
│
├── 8-16GB
│ └── Q5_K_M（更好的精度）或更大的模型
│
├── 16-24GB
│ └── Q8_0 或 13B/34B 模型的 Q4_K_M
│
└── 24GB+
└── FP16（研究用途）或 70B 模型的 Q4_K_M
8.3 量化对质量的影响
# 实测数据：不同量化级别在 MMLU 基准上的表现
# 模型：Llama 3.1 8B
quantization_results = {
"FP16": {"mmlu": 68.4, "vram_gb": 14.2, "tok_per_sec": 45},
"Q8_0": {"mmlu": 68.1, "vram_gb": 7.2, "tok_per_sec": 55},
"Q5_K_M": {"mmlu": 67.5, "vram_gb": 5.1, "tok_per_sec": 65},
"Q4_K_M": {"mmlu": 66.8, "vram_gb": 4.4, "tok_per_sec": 70},
"Q2_K": {"mmlu": 63.2, "vram_gb": 2.8, "tok_per_sec": 85},
}
# 结论：
# Q4_K_M：精度损失 1.6%，显存节省 69%，速度提升 56%
# Q2_K：精度损失 7.6%，显存节省 80%，但精度损失较大
# 推荐：日常使用 Q4_K_M，精度敏感场景 Q5_K_M
九、与 MCP 集成
9.1 Ollama 作为本地推理后端
Ollama 可以作为 MCP 生态中的本地推理后端，实现"工具调用用 MCP，推理用 Ollama"的架构：
┌──────────────────────────────────────────────────────┐
│ MCP Host (Claude Desktop) │
│ │
│ ┌─────────────┐ ┌─────────────────────────┐ │
│ │ MCP Client │────→│ MCP Server (工具) │ │
│ │ │ │ ├── 文件系统 │ │
│ │ 推理请求 ───┼────→│ ├── 数据库查询 │ │
│ │ │ │ └── Web搜索 │ │
│ └─────────────┘ └─────────────────────────┘ │
│ │ │
│ │ 本地推理 │
│ ▼ │
│ ┌─────────────┐ │
│ │ Ollama │ │
│ │ (本地LLM) │ │
│ │ Port:11434 │ │
│ └─────────────┘ │
└──────────────────────────────────────────────────────┘
9.2 配置示例
"""
Ollama + MCP 集成示例
使用 Ollama 作为推理后端，MCP 提供工具
"""
from openai import OpenAI
import requests
import json
class OllamaMCPAgent:
"""Ollama + MCP 的简单 Agent"""
def __init__(self, ollama_url: str = "http://localhost:11434/v1"):
self.client = OpenAI(
base_url=ollama_url,
api_key="ollama"
)
self.tools = self._discover_mcp_tools()
def _discover_mcp_tools(self) -> list:
"""发现 MCP 工具（简化版）"""
# 实际实现中，会通过 MCP 协议发现工具
return [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Read a file from the filesystem",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "File path"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "web_search",
"description": "Search the web for information",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "Search query"}
},
"required": ["query"]
}
}
}
]
def chat(self, message: str) -> str:
"""聊天，自动调用工具"""
messages = [
{"role": "system", "content": "You are a helpful assistant. Use tools when needed."},
{"role": "user", "content": message}
]
# 第一次调用：可能触发工具
response = self.client.chat.completions.create(
model="llama3.1",
messages=messages,
tools=self.tools,
temperature=0.3
)
# 如果模型请求调用工具
if response.choices[0].finish_reason == "tool_calls":
tool_calls = response.choices[0].message.tool_calls
# 执行工具调用
for tool_call in tool_calls:
tool_result = self._execute_tool(
tool_call.function.name,
json.loads(tool_call.function.arguments)
)
# 将工具结果加入消息
messages.append(response.choices[0].message)
messages.append({
"role": "tool",
"content": json.dumps(tool_result),
"tool_call_id": tool_call.id
})
# 第二次调用：基于工具结果生成回答
response = self.client.chat.completions.create(
model="llama3.1",
messages=messages,
temperature=0.3
)
return response.choices[0].message.content
def _execute_tool(self, name: str, arguments: dict) -> dict:
"""执行工具调用（简化版）"""
if name == "read_file":
try:
with open(arguments["path"], "r") as f:
return {"content": f.read()[:4000]}
except Exception as e:
return {"error": str(e)}
elif name == "web_search":
# 实际实现中调用搜索 API
return {"results": f"Search results for: {arguments['query']}"}
return {"error": f"Unknown tool: {name}"}
# 使用
if __name__ == "__main__":
agent = OllamaMCPAgent()
result = agent.chat("Read the file /etc/hostname and tell me what it says.")
print(result)
十、性能调优
10.1 上下文长度优化
# KV Cache 与上下文长度的关系
# 上下文长度翻倍 → KV Cache 翻倍 → 显存需求翻倍
# 默认上下文：2048 tokens
ollama run llama3.1 # num_ctx=2048
# 增加上下文：8192 tokens（显存需求增加约 4 倍）
# 方式1：Modelfile
PARAMETER num_ctx 8192
# 方式2：运行时参数
ollama run llama3.1 --ctx-size 8192
# 方式3：API 调用
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1",
"prompt": "...",
"options": {
"num_ctx": 8192
}
}'
10.2 批处理优化
# num_batch：批处理大小
# 更大的 batch = 更高的吞吐量 = 更多的显存
# 默认：512
PARAMETER num_batch 512
# 高并发场景：增大到 1024 或 2048
PARAMETER num_batch 1024
# 显存紧张时：减小到 256
PARAMETER num_batch 256
10.3 KV Cache 管理
# KV Cache 是推理性能的关键
# 每次 token 生成都需要读取 KV Cache
# 优化1：减少上下文长度
# 短对话用 num_ctx=2048，长文档用 num_ctx=8192
# 优化2：启用 Flash Attention
# Ollama 默认启用，无需配置
# 优化3：监控 KV Cache 使用
# 通过 API 查看推理统计
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1",
"prompt": "Hello",
"stream": false
}'
# 返回中包含 eval_count、eval_duration 等统计信息
10.4 性能基准参考
推理速度参考（Q4_K_M 量化，短上下文 ≤2K tokens）：
GPU 型号 7B 模型 70B 模型
──────────────────── ────────── ──────────
RTX 4090 (24GB) ~110-130 t/s ~25-35 t/s
RTX 4070 (12GB) ~60-80 t/s 超出 VRAM
RTX 3060/4060 (8GB) ~35-50 t/s 超出 VRAM
Apple M3 Max (48GB) ~50-70 t/s ~15-20 t/s
Apple M2 Pro (16GB) ~25-35 t/s 超出 RAM
CPU only (i9/Ryzen 9) ~3-6 t/s 不可用
注：t/s = tokens/second，数据来自社区实测，仅供参考
10.5 参数优先级
当显存紧张时，按以下优先级调整参数：
调整优先级（从高到低）：
1. 量化级别 ──── 最有效，Q4 比 FP16 节省 75% 显存
2. 上下文长度 ── num_ctx 减半，KV Cache 减半
3. 批处理大小 ── num_batch 从 512 减到 256
4. GPU 层数 ──── num_gpu 减少，部分层回退到 CPU
5. 低显存模式 ── low_vram=True，KV Cache 放到系统内存
十一、踩坑记录
坑1：GPU 没有被使用
现象: ollama run llama3.1 很慢，nvidia-smi 显示 GPU 使用率 0%
原因1: NVIDIA 驱动版本太低（<531）
修复1: 更新 NVIDIA 驱动
原因2: Windows 上 Ollama 使用了集成显卡而非独显
修复2: 在 Windows 图形设置中，将 Ollama 设置为"高性能"
设置 → 图形设置 → 添加 Ollama → 选择"高性能(GPU)"
原因3: WSL2 中没有正确传递 GPU
修复3: 确保 WSL2 更新到最新版
wsl --update
原因4: OLLAMA_NUM_GPU=0（被手动禁用了）
修复4: 取消环境变量设置
unset OLLAMA_NUM_GPU
坑2：模型下载失败或速度极慢
现象: ollama pull llama3.1 速度只有几十 KB/s
原因: Ollama 默认从海外服务器下载
修复:
方式1: 配置代理
export https_proxy=http://127.0.0.1:7890
ollama pull llama3.1
方式2: 手动下载 GGUF 文件
wget https://huggingface.co/.../model-q4_k_m.gguf
# 创建 Modelfile
FROM ./model-q4_k_m.gguf
ollama create my-model -f Modelfile
方式3: 使用国内镜像
# 设置 OLLAMA_MIRRORS 环境变量（如果可用）
坑3：显存不足，模型无法运行
现象: CUDA out of memory 或模型加载失败
原因: 模型需要的显存超过了 GPU 显存
修复:
1. 使用更低量化级别（Q4_K_M → Q2_K）
2. 使用更小参数量的模型（7B → 3B）
3. 关闭其他占用显存的程序
4. 让 Ollama 自动回退到 CPU（会变慢但能跑）
5. 增加系统内存（Ollama 会自动用 RAM 补充 VRAM）
坑4：端口 11434 被占用
现象: Error: listen tcp 127.0.0.1:11434: bind: address already in use
原因: 另一个 Ollama 实例或其他程序占用了端口
修复:
# 查找并关闭占用端口的进程
# Linux/macOS
lsof -i :11434
kill -9 <PID>
# Windows
netstat -ano | findstr :11434
taskkill /PID <PID> /F
# 或修改端口
OLLAMA_HOST=0.0.0.0:11435 ollama serve
坑5：Apple Silicon 上性能不佳
现象: M1/M2 Mac 上推理速度比预期慢
原因1: 使用了 Rosetta 模式（非原生 ARM）
修复1: 从官网重新安装原生版 Ollama
原因2: 内存被其他程序占用
修复2: 关闭不必要的程序，释放统一内存
原因3: 模型过大，超出物理内存
修复3: 使用更小的模型或更低量化
M1 8GB: 最多跑 3B-Q4 或 7B-Q2
M2 16GB: 可以跑 7B-Q4 或 13B-Q2
M3 Max 48GB: 可以跑 34B-Q4 甚至 70B-Q2
坑6：长上下文导致显存溢出
现象: 短对话正常，长文档分析时 CUDA out of memory
原因: KV Cache 随上下文长度线性增长
num_ctx=8192 的 KV Cache 是 num_ctx=2048 的 4 倍
修复:
1. 按需设置上下文长度（不要一律用最大值）
2. 对长文档做分段处理
3. 启用 low_vram 模式（KV Cache 放到系统内存）
4. 换用更大的 GPU
# VRAM 估算公式（Q4_K_M 量化）：
# VRAM(GB) ≈ 参数量(B) × 0.5 + 1 + KV_Cache
# KV_Cache ≈ num_ctx × 0.001 × 参数量(B)
# 例：7B 模型，num_ctx=8192
# VRAM ≈ 7 × 0.5 + 1 + 8192 × 0.001 × 7 = 4.5 + 1 + 5.7 ≈ 11.2 GB
总结
Ollama 的价值在于把本地大模型的门槛压到了最低。一行命令跑模型，OpenAI 兼容 API 接入任何框架，Docker 式的模型管理——开发者不再需要关心量化、推理引擎、GPU 调度这些底层细节。
但它不是万能的：
推荐路线：
步骤1: 安装 Ollama，跑第一个模型 (5分钟)
步骤2: 选择合适的量化级别 (Q4_K_M 日常够用)
步骤3: 配置 OpenAI 兼容 API，接入你的应用
步骤4: 按需调整 GPU/上下文/批处理参数
步骤5: 需要生产服务时，迁移到 vLLM/SGLang
参考来源：
据《Ollama 本地部署完整指南(2026 最新版)》(CSDN, 2026-05-14)
据《Ollama GPU Scheduling and Resource Management》(EastonDev, 2026-04-11)
据《vLLM vs Ollama: Which Inference Engine Should You Use?》(GigaGPU, 2026-04-10)
据《Best Open-Source LLM Inference Servers 2026》(AwesomeAgents, 2026-04-17)
评论区