本地部署 DeepSeek + Ollama 完全指南：AI 大模型本地化部署与 RAG 知识库搭建

2026 年，大模型本地化部署已经不是开发者的专利。借助 Ollama 这样的工具，即使是普通用户也能在个人电脑上运行 DeepSeek 这样的中文大模型。本地部署不仅能保护隐私，还能与知识库结合构建专属的 AI 助手。

本文完整讲解 DeepSeek + Ollama 的本地化部署全流程，包括：

硬件要求评估与环境准备
Ollama 安装与配置（Windows/macOS/Linux）
DeepSeek 模型下载与推理
Web UI 部署（Ollama Web UI / Open WebUI）
兼容 OpenAI 的 REST API 调用
RAG 知识库搭建（PDF/Word/Markdown）
多模型管理与切换
性能调优与常见问题

一、硬件要求与环境准备#

1.1 硬件推荐配置#

DeepSeek 模型分多个参数版本，硬件要求差异较大：

模型	参数	内存要求	显存（GPU）	推理速度	推荐场景
DeepSeek-LLM 7B Chat	7B	16GB	8GB+	快	日常对话、入门
DeepSeek-LLM 16B Chat	16B	32GB	16GB+	中	专业任务
DeepSeek-LLM 67B Chat	67B	64GB	40GB+	慢	研究/服务器
DeepSeek-Coder 7B	7B	16GB	8GB+	快	代码辅助
DeepSeek-Coder 33B	33B	32GB	24GB+	中	专业开发
Qwen 14B Chat	14B	32GB	12GB+	中	中文任务

💡 量化版本：Ollama 默认使用量化版本（Q4_K_M），可将显存要求降低约 60%，精度损失较小，适合普通用户。

1.2 环境要求#

操作系统：

macOS 13+（支持 M1/M2/M3 芯片的 Apple Silicon）
Windows 10/11（WSL2 推荐）
Linux（Ubuntu 20.04+、Debian 11+）

显卡要求（可选）：

NVIDIA GeForce RTX 2060 及以上（6GB 显存起步）
NVIDIA RTX 3060/4060（12GB，性价比推荐）
NVIDIA RTX 3090/4090（24GB，流畅运行 16B 模型）
AMD Radeon RX 6000/7000 系列（需 ROCm，较复杂）
Apple Silicon M1 Pro/M2/M3（统一内存，性能优秀）

1.3 磁盘空间#

1
模型文件：        4-8 GB （7B 模型，Q4 量化）
2
                 8-16 GB（16B 模型）
3
Ollama 程序：    < 200 MB
4
Web UI 程序：    < 500 MB
5
模型缓存：       2-10 GB（取决于模型数量）
6
RAG 知识库向量： 1-5 GB（取决于文档量）

建议至少预留 20 GB 可用空间。

二、Ollama 安装与配置#

2.1 macOS 安装#

1
# 方法 1：使用 Homebrew（推荐）
2
brew install ollama
3

4
# 方法 2：下载官方安装包
5
# 访问 https://ollama.ai/download
6
# 下载并安装 Ollama.dmg
7

8
# 启动 Ollama 服务
9
ollama serve
10

11
# 验证安装
12
ollama --version
13
# ollama version 0.5.x 或更高

2.2 Linux 安装#

1
# 方法 1：官方一键脚本（推荐）
2
curl -fsSL https://ollama.com/install.sh | sh
3

4
# 方法 2：手动下载二进制
5
wget https://github.com/ollama/ollama/releases/latest/download/ollama-linux-amd64
6
chmod +x ollama-linux-amd64
7
sudo mv ollama-linux-amd64 /usr/local/bin/ollama
8

9
# 配置为系统服务（可选）
10
sudo tee /etc/systemd/system/ollama.service << 'EOF'
11
[Unit]
12
Description=Ollama Service
13
After=network-online.target
14

15
[Service]
16
ExecStart=/usr/local/bin/ollama serve
17
User=$USER
18
Restart=always
19
Environment="OLLAMA_HOST=0.0.0.0"
20
Environment="OLLAMA_ORIGINS=*"
21

22
[Install]
23
WantedBy=default.target
24
EOF
25

26
sudo systemctl daemon-reload
27
sudo systemctl enable ollama
28
sudo systemctl start ollama
29

30
# 验证
31
ollama --version

2.3 Windows 安装#

1
# 方法 1：使用官方安装包
2
# 访问 https://ollama.ai/download
3
# 下载 OllamaSetup.exe 并双击安装
4

5
# 方法 2：WSL2（推荐，性能更好）
6
# 在 WSL2 Ubuntu 中执行
7
curl -fsSL https://ollama.com/install.sh | sh
8

9
# 安装后启动服务
10
ollama serve
11

12
# 验证
13
ollama --version

2.4 环境变量配置#

1
# 常用环境变量（可写入 ~/.bashrc 或 ~/.zshrc）
2

3
# 模型存储位置（默认 ~/.ollama/models）
4
export OLLAMA_MODELS=/path/to/models
5

6
# 监听地址（默认 127.0.0.1:11434）
7
export OLLAMA_HOST=0.0.0.0
8

9
# 允许的来源（跨域访问时需要）
10
export OLLAMA_ORIGINS=*
11

12
# 显存限制（避免显存溢出）
13
export OLLAMA_GPU_LAYERS=50
14

15
# 线程数（CPU 推理时调优）
16
export OLLAMA_NUM_THREADS=8
17

18
# 启用 NVIDIA GPU 支持（Linux）
19
export OLLAMA_CUDA=1

三、运行 DeepSeek 模型#

3.1 模型列表与选择#

1
# 查看所有可用的 DeepSeek 模型
2
ollama list | grep deepseek
3

4
# 搜索模型
5
ollama search deepseek

推荐模型：

模型名称	说明	运行命令
`deepseek-coder:6.7b`	代码助手（中文支持）	`ollama run deepseek-coder:6.7b`
`deepseek-llm:7b-chat`	通用对话模型	`ollama run deepseek-llm:7b-chat`
`qwen2:7b`	通义千问（中文更佳）	`ollama run qwen2:7b`
`llama3:8b`	Llama 3（英文最佳）	`ollama run llama3:8b`
`mistral:7b`	Mistral（速度快）	`ollama run mistral:7b`

3.2 快速开始#

1
# 1. 拉取并运行 DeepSeek-Coder（首次运行自动下载模型）
2
ollama run deepseek-coder:6.7b
3

4
# 2. 等待模型下载完成后，直接在命令行对话
5
# >>> 请写一个 Python 快速排序函数
6

7
# 3. 退出交互：/bye 或 Ctrl+D
8
>>> /bye

3.3 常用命令#

1
# 查看已下载模型
2
ollama list
3

4
# 查看模型详情
5
ollama show deepseek-coder:6.7b
6

7
# 删除模型
8
ollama rm deepseek-coder:6.7b
9

10
# 后台运行模型（不进入交互）
11
ollama serve &
12

13
# 停止服务
14
pkill -f ollama

3.4 自定义模型（Modelfile）#

1
# 创建自定义模型配置
2
cat > Modelfile << 'EOF'
3
# 基于 DeepSeek-Coder 7B
4
FROM deepseek-coder:6.7b
5

6
# 设置系统提示（决定模型行为）
7
SYSTEM """
8
你是一个专业的编程助手，精通 Python/JavaScript/Go 等语言。
9
回答时：
10
1. 提供清晰的代码示例
11
2. 解释关键概念
12
3. 给出最佳实践建议
13
"""
14

15
# 推理参数（可选）
16
PARAMETER temperature 0.7
17
PARAMETER top_p 0.9
18
PARAMETER top_k 50
19
PARAMETER num_ctx 4096
20
PARAMETER num_predict -1  # 无限生成长度
21
PARAMETER repeat_penalty 1.1
22

23
# 模板（控制输入输出格式）
24
TEMPLATE """{{ .System }}
25

26
用户: {{ .Prompt }}
27
助手:"""
28
EOF
29

30
# 基于 Modelfile 创建自定义模型
31
ollama create my-coder -f Modelfile
32

33
# 运行自定义模型
34
ollama run my-coder

3.5 参数调优指南#

参数	作用	推荐值
`temperature`	创造性/随机性	0.5-0.7（代码）/ 0.8-1.0（创意写作）
`top_p`	概率累积阈值	0.9（平衡多样性与质量）
`top_k`	候选词数量限制	40-100
`num_ctx`	上下文窗口大小	4096-16384（越大越耗显存）
`num_predict`	最大生成 tokens	-1（无限制）/ 2000（限制长度）
`repeat_penalty`	重复惩罚	1.1-1.2
`num_gpu`	GPU 层数	50（自动分配，越多越快）

四、Web UI 部署#

命令行对话不够直观，推荐部署 Web UI 获得更好的体验。

4.1 Open WebUI（推荐）#

Open WebUI（原 Ollama Web UI）是功能最完整的开源前端：

1
# Docker 部署（推荐，最简单）
2
docker run -d \
3
  -p 3000:3000 \
4
  --add-host=host.docker.internal:host-gateway \
5
  -v open-webui:/app/backend/data \
6
  --name open-webui \
7
  --restart always \
8
  ghcr.io/open-webui/open-webui:main
9

10
# 访问: http://localhost:3000
11

12
# 首次打开创建管理员账号
13

14
# 如果 Ollama 在远程服务器
15
docker run -d \
16
  -p 3000:3000 \
17
  -e OLLAMA_API_BASE_URL=http://192.168.1.100:11434/api \
18
  -v open-webui:/app/backend/data \
19
  --name open-webui \
20
  --restart always \
21
  ghcr.io/open-webui/open-webui:main

Open WebUI 主要功能：

✅ 多模型切换（支持所有 Ollama 模型）
✅ 对话历史管理与搜索
✅ 多用户系统与权限控制
✅ 多模态支持（图片/语音）
✅ 插件系统（Python/TypeScript）
✅ RAG 知识库（PDF/DOC/Markdown/TXT/网页）
✅ 对话导出（Markdown/JSON/JSONL）
✅ 代码高亮与 LaTeX 渲染
✅ OpenAI API 兼容模式

4.2 Open WebUI RAG 知识库配置#

Open WebUI 内置了 RAG 功能，零配置即可使用：

1
# 1. 打开 Web UI 左侧边栏「文档」功能
2
# 2. 点击「上传文档」上传 PDF/Word/Markdown/TXT
3
# 3. 上传后自动进行向量化
4
# 4. 对话时勾选「检索文档」即可引用知识库内容
5

6
# 支持的文档格式：
7
# - PDF: 自动解析文本（带 OCR 选项）
8
# - DOC/DOCX: Microsoft Word 文档
9
# - TXT/TXT: 纯文本
10
# - MD/Markdown: Markdown 文件
11
# - HTML/URL: 网页内容
12
# - CSV/Excel: 表格数据
13
# - EPUB: 电子书
14

15
# 高级设置（在「设置 → 文档」中配置）：
16
# - 切分大小（默认 500 tokens）
17
# - 切分重叠（默认 50 tokens）
18
# - 相似度阈值（默认 0.75）
19
# - 返回结果数量（默认 5）
20
# - 嵌入模型选择（默认 bge-m3）

4.3 其他 Web UI 选择#

1
# 方案 2：Ollama WebUI（轻量）
2
docker run -d -p 3000:3000 --name ollama-webui ollama-webui:latest
3

4
# 方案 3：AnythingLLM（企业级知识库方案）
5
docker run -d --name anything-llm \
6
  -p 3001:3001 \
7
  -v anything-llm-storage:/app/server/storage \
8
  mintplexlabs/anythingllm
9

10
# 方案 4：Chatbot UI（类 ChatGPT 界面）
11
docker run -d -p 3000:3000 \
12
  -e OPENAI_API_KEY=ollama \
13
  -e OPENAI_API_BASE_URL=http://localhost:11434/v1 \
14
  ghcr.io/mckaywrigley/chatbot-ui:main

五、Ollama REST API 调用#

Ollama 提供兼容 OpenAI 的 REST API，便于集成到你的应用中。

5.1 生成文本（Completion）#

1
# 基本调用
2
curl http://localhost:11434/api/generate -d '{
3
  "model": "deepseek-coder:6.7b",
4
  "prompt": "写一个 Python 快速排序函数",
5
  "stream": false
6
}' | jq

5.2 对话接口（Chat Completion）#

1
# 单轮对话
2
curl http://localhost:11434/api/chat -d '{
3
  "model": "deepseek-coder:6.7b",
4
  "messages": [
5
    {
6
      "role": "user",
7
      "content": "Python 和 JavaScript 有什么区别？"
8
    }
9
  ],
10
  "stream": false
11
}' | jq
12

13
# 多轮对话（保留上下文）
14
curl http://localhost:11434/api/chat -d '{
15
  "model": "deepseek-coder:6.7b",
16
  "messages": [
17
    {
18
      "role": "user",
19
      "content": "什么是面向对象编程？"
20
    },
21
    {
22
      "role": "assistant",
23
      "content": "面向对象编程（OOP）是一种编程范式..."
24
    },
25
    {
26
      "role": "user",
27
      "content": "Python 如何实现多态？"
28
    }
29
  ],
30
  "stream": false
31
}' | jq

5.3 流式响应#

1
// Node.js 示例：流式输出
2
const response = await fetch('http://localhost:11434/api/chat', {
3
  method: 'POST',
4
  headers: { 'Content-Type': 'application/json' },
5
  body: JSON.stringify({
6
    model: 'deepseek-coder:6.7b',
7
    messages: [{ role: 'user', content: '你好' }],
8
    stream: true
9
  })
10
});
11

12
const reader = response.body.getReader();
13
const decoder = new TextDecoder();
14

15
while (true) {
16
  const { done, value } = await reader.read();
17
  if (done) break;
18

19
  const chunk = decoder.decode(value, { stream: true });
20
  const data = JSON.parse(chunk);
21
  if (data.message) {
22
    process.stdout.write(data.message.content);
23
  }
24
}

5.4 Python SDK 调用#

1
# 安装 SDK
2
# pip install ollama
3

4
import ollama
5

6
# 基本对话
7
response = ollama.chat(model='deepseek-coder:6.7b', messages=[
8
    {
9
        'role': 'user',
10
        'content': 'Python 装饰器的用法',
11
    },
12
])
13
print(response['message']['content'])
14

15
# 流式对话
16
for response in ollama.chat(
17
    model='deepseek-coder:6.7b',
18
    messages=[{'role': 'user', 'content': '解释一下闭包'}],
19
    stream=True
20
):
21
    print(response['message']['content'], end='')
22

23
# 生成嵌入向量
24
embeddings = ollama.embeddings(
25
    model='mxbai-embed-large',
26
    prompt='这是需要向量化的文本'
27
)
28
print(embeddings['embedding'])  # 1024 维向量
29

30
# 查看模型列表
31
models = ollama.list()
32
for m in models['models']:
33
    print(f"{m['name']} - {m['details']['parameter_size']}")

5.5 兼容 OpenAI API#

如果你已有基于 OpenAI 的代码，可以无缝切换到 Ollama：

1
from openai import OpenAI
2

3
# 使用 Ollama（完全兼容 OpenAI SDK）
4
client = OpenAI(
5
    base_url='http://localhost:11434/v1',
6
    api_key='ollama'  # 任意字符串即可
7
)
8

9
response = client.chat.completions.create(
10
    model='deepseek-coder:6.7b',
11
    messages=[
12
        {'role': 'user', 'content': '你好'}
13
    ]
14
)
15

16
print(response.choices[0].message.content)
17

18
# 流式输出
19
stream = client.chat.completions.create(
20
    model='deepseek-coder:6.7b',
21
    messages=[{'role': 'user', 'content': '写一首诗'}],
22
    stream=True
23
)
24

25
for chunk in stream:
26
    if chunk.choices[0].delta.content:
27
        print(chunk.choices[0].delta.content, end='')

六、RAG 知识库搭建#

6.1 RAG 原理图解#

1
用户提问 "产品价格策略是什么？"
2
    ↓
3
[文本嵌入] → 将问题转换为向量
4
    ↓
5
[向量检索] → 在文档向量库中搜索最相似的片段
6
    ↓
7
[上下文组装] → 组装系统提示 + 检索到的文档片段 + 用户问题
8
    ↓
9
[大模型推理] → DeepSeek 基于增强上下文生成答案
10
    ↓
11
回答: "根据文档第3.2节，产品采用差异化定价策略..."

6.2 手工搭建 RAG 系统（进阶）#

1
# 安装依赖
2
# pip install llama-index chromadb pypdf
3

4
import os
5
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex, Settings
6
from llama_index.llms.ollama import Ollama
7
from llama_index.embeddings.ollama import OllamaEmbedding
8

9
# 配置 Ollama
10
Settings.llm = Ollama(model='deepseek-coder:6.7b', request_timeout=300)
11
Settings.embed_model = OllamaEmbedding(model_name='mxbai-embed-large')
12

13
# 1. 加载文档
14
documents = SimpleDirectoryReader('./docs').load_data()
15
print(f"加载了 {len(documents)} 个文档片段")
16

17
# 2. 构建向量索引
18
index = VectorStoreIndex.from_documents(documents, show_progress=True)
19

20
# 3. 保存索引（持久化）
21
index.storage_context.persist(persist_dir="./vector_store")
22

23
# 4. 创建问答引擎
24
query_engine = index.as_query_engine(response_mode="compact")
25

26
# 5. 提问
27
response = query_engine.query("产品的核心定价策略是什么？")
28
print(response)
29
print("\n引用来源:")
30
for node in response.source_nodes:
31
    print(f"- 文档: {node.metadata.get('file_name', '未知')}")
32
    print(f"  相似度: {node.score:.4f}")
33

34
# 6. 加载已有索引
35
from llama_index.core import StorageContext, load_index_from_storage
36

37
storage_context = StorageContext.from_defaults(persist_dir="./vector_store")
38
index = load_index_from_storage(storage_context)

6.3 支持的文档格式与处理#

1
# PDF 文档处理
2
from llama_index.readers.file import PDFReader
3

4
reader = PDFReader()
5
documents = reader.load_data('./data/product_manual.pdf')
6

7
# Word 文档
8
from llama_index.readers.file import DocxReader
9

10
reader = DocxReader()
11
documents = reader.load_data('./data/report.docx')
12

13
# Markdown 文档
14
from llama_index.readers.file import MarkdownReader
15

16
reader = MarkdownReader()
17
documents = reader.load_data('./data/guide.md')
18

19
# 网页内容
20
from llama_index.readers.web import SimpleWebPageReader
21

22
reader = SimpleWebPageReader(html_to_text=True)
23
documents = reader.load_data(urls=[
24
    'https://example.com/product',
25
    'https://example.com/pricing'
26
])
27

28
# 批量目录加载（混合格式）
29
documents = SimpleDirectoryReader(
30
    input_dir='./data',
31
    recursive=True,
32
    required_exts=['.pdf', '.docx', '.md', '.txt']
33
).load_data()

6.4 RAG 性能调优#

1
# 关键参数调优
2
from llama_index.core import Settings
3

4
# 切分参数
5
Settings.chunk_size = 512        # 片段大小（默认 1024，中文推荐 200-500）
6
Settings.chunk_overlap = 50       # 重叠大小（默认 200，中文推荐 50-100）
7

8
# 检索参数
9
query_engine = index.as_query_engine(
10
    similarity_top_k=5,            # 返回最相似的 5 个片段
11
    response_mode="compact",       # compact/refine/tree_summarize
12
    use_async=True
13
)
14

15
# 提示词调优（中文更准确）
16
from llama_index.core.prompts import PromptTemplate
17

18
new_tmpl = (
19
    "你是一个专业的文档助手，参考以下上下文回答问题。\n"
20
    "不要编造信息，仅引用上下文内容。\n"
21
    "如果上下文中没有答案，请说：'文档中未找到相关信息'。\n"
22
    "---------------------\n"
23
    "{context_str}\n"
24
    "---------------------\n"
25
    "用户问题: {query_str}\n"
26
    "你的回答:"
27
)
28
query_engine.update_prompts(
29
    {"response_synthesizer:text_qa_template": PromptTemplate(new_tmpl)}
30
)

七、多模型管理#

7.1 下载与切换模型#

1
# 下载多个模型
2
ollama pull qwen2:7b          # 通义千问
3
ollama pull llama3:8b         # Llama 3
4
ollama pull mistral:7b        # Mistral
5
ollama pull nomic-embed-text  # 嵌入模型
6

7
# 查看已安装模型
8
ollama list
9
# NAME                  ID              SIZE    MODIFIED
10
# deepseek-coder:6.7b   xxxxxxxx        3.8 GB  2 hours ago
11
# qwen2:7b              xxxxxxxx        4.4 GB  1 hour ago
12
# llama3:8b             xxxxxxxx        4.7 GB  30 min ago
13

14
# 在代码中切换模型
15
import ollama
16

17
# 方法 1：创建不同的客户端实例
18
def chat_with_model(model, prompt):
19
    resp = ollama.chat(model=model, messages=[
20
        {'role': 'user', 'content': prompt}
21
    ])
22
    return resp['message']['content']
23

24
# 使用不同模型
25
print("=== DeepSeek-Coder 回答===")
26
print(chat_with_model('deepseek-coder:6.7b', "写一个快速排序"))
27

28
print("\n=== Qwen 回答 ===")
29
print(chat_with_model('qwen2:7b', "解释量子计算"))
30

31
print("\n=== Llama 3 回答 ===")
32
print(chat_with_model('llama3:8b', "How to learn Rust?"))

7.2 模型微调与自定义 Modelfile#

1
# 基于现有模型创建专业助手
2
cat > Modelfile.product << 'EOF'
3
FROM qwen2:7b
4

5
SYSTEM """
6
你是一个产品专家，熟悉以下产品：
7
- 产品 A：规格、价格、特性
8
- 产品 B：规格、价格、特性
9
用户咨询时提供专业建议。
10
"""
11

12
PARAMETER temperature 0.5
13
PARAMETER top_p 0.8
14
PARAMETER num_ctx 8192
15
EOF
16

17
ollama create product-assistant -f Modelfile.product
18
ollama run product-assistant

7.3 模型性能对比#

1
import time
2
import ollama
3

4
models = ['deepseek-coder:6.7b', 'qwen2:7b', 'llama3:8b', 'mistral:7b']
5
test_prompt = "请用 200 字以内解释什么是人工智能？"
6

7
results = []
8
for model in models:
9
    start = time.time()
10
    response = ollama.chat(model=model, messages=[
11
        {'role': 'user', 'content': test_prompt}
12
    ])
13
    elapsed = time.time() - start
14
    tokens = len(response['message']['content'])
15

16
    results.append({
17
        'model': model,
18
        'time': f"{elapsed:.2f}s",
19
        'tokens': tokens,
20
        'speed': f"{tokens/elapsed:.0f} tokens/s"
21
    })
22

23
    print(f"{model}: {elapsed:.2f}s, {tokens} tokens, {tokens/elapsed:.0f} t/s")
24

25
# 输出:
26
# deepseek-coder:6.7b: 8.32s, 280 tokens, 34 t/s
27
# qwen2:7b: 7.18s, 320 tokens, 45 t/s
28
# llama3:8b: 9.05s, 265 tokens, 29 t/s
29
# mistral:7b: 6.82s, 290 tokens, 43 t/s

八、性能优化#

8.1 GPU 加速#

1
# 查看 GPU 使用情况
2
nvidia-smi
3

4
# 配置 GPU 层数（环境变量或 Modelfile）
5
export OLLAMA_GPU_LAYERS=50  # 越高越快（需足够显存）
6

7
# 或在 Modelfile 中设置
8
# PARAMETER num_gpu 50

8.2 内存优化#

1
# 使用量化版本（推荐普通用户）
2
ollama run deepseek-coder:6.7b  # Q4 量化版本
3

4
# 选择更小的模型
5
ollama run qwen2:1.5b  # 轻量模型，速度极快
6

7
# 调整上下文窗口
8
# PARAMETER num_ctx 2048  # 降低上下文减少内存

8.3 多线程与并发#

1
from concurrent.futures import ThreadPoolExecutor
2
import ollama
3

4
# 并发处理多个任务
5
def process_query(query):
6
    resp = ollama.chat(model='deepseek-coder:6.7b', messages=[
7
        {'role': 'user', 'content': query}
8
    ])
9
    return resp['message']['content']
10

11
queries = [
12
    "什么是快速排序？",
13
    "什么是二分查找？",
14
    "什么是哈希表？"
15
]
16

17
with ThreadPoolExecutor(max_workers=3) as executor:
18
    results = list(executor.map(process_query, queries))
19

20
for q, r in zip(queries, results):
21
    print(f"Q: {q}\nA: {r[:100]}...\n")

8.4 模型预热与缓存#

1
import ollama
2

3
# 预热模型（首次加载较慢，预热后速度提升）
4
ollama.chat(model='deepseek-coder:6.7b', messages=[
5
    {'role': 'user', 'content': '你好，请做自我介绍。'}
6
])
7

8
# 后续请求速度显著提升

九、常见问题排错#

Q1: 模型下载失败或中断#

1
# 重新下载
2
ollama pull deepseek-coder:6.7b
3

4
# 或手动下载 GGUF 文件后导入
5
# 从 https://huggingface.co 下载 .gguf 文件
6
ollama create my-model -f Modelfile  # 在 Modelfile 中引用本地文件

Q2: 显存不足（CUDA out of memory）#

1
# 解决方案：
2
# 1. 选择量化版本
3
ollama run qwen2:1.5b
4

5
# 2. 降低上下文窗口
6
# Modelfile 中设置
7
# PARAMETER num_ctx 2048
8

9
# 3. 使用 CPU 推理（较慢但稳定）
10
export OLLAMA_CUDA=0
11
ollama run deepseek-coder:6.7b
12

13
# 4. 减小 batch size
14
# PARAMETER num_batch 512

Q3: Web UI 无法连接 Ollama#

1
# 检查服务是否启动
2
ps aux | grep ollama
3

4
# 重启服务
5
ollama serve &
6

7
# 检查端口监听
8
netstat -tlnp | grep 11434
9

10
# 如果远程访问，设置允许来源
11
export OLLAMA_ORIGINS=*
12
export OLLAMA_HOST=0.0.0.0
13
ollama serve

Q4: 中文回答质量差#

1
# 选择中文优化的模型
2
ollama run qwen2:7b        # 通义千问（中文最佳）
3
ollama run deepseek-coder:6.7b  # 代码模型
4

5
# 使用中文提示词
6
prompt = "请用中文回答：什么是大模型？"

Q5: 模型生成速度太慢#

1
# 1. 检查是否启用 GPU
2
nvidia-smi
3

4
# 2. 优化模型参数
5
# PARAMETER num_gpu 100  # 全量 GPU 加速
6

7
# 3. 选择更小的模型
8
ollama run qwen2:1.5b
9

10
# 4. 使用 Apple Silicon（M 芯片）
11
# 通常比同价位 x86 更快
12

13
# 5. 增加 CPU 线程数
14
export OLLAMA_NUM_THREADS=8

Q6: Docker 容器无法连接本地 Ollama#

1
# Docker 内访问宿主机 Ollama
2
# macOS/Windows: 使用 host.docker.internal
3
docker run -d -p 3000:3000 \
4
  --add-host=host.docker.internal:host-gateway \
5
  ghcr.io/open-webui/open-webui:main
6

7
# Linux:
8
# 在 Docker 容器中使用宿主机 IP 或添加 --network=host
9
docker run -d --network=host \
10
  -v open-webui:/app/backend/data \
11
  ghcr.io/open-webui/open-webui:main

十、总结#

本地部署大模型是 2026 年每个开发者都应掌握的技能。借助 Ollama，你可以：

✅ 零成本运行 DeepSeek/Qwen/Llama 等顶级模型
✅ 搭建私有 AI 助手，保护数据隐私
✅ 构建企业级 RAG 知识库系统
✅ 通过 OpenAI 兼容 API 集成到任意应用
✅ 使用 Web UI 获得类 ChatGPT 的体验

最佳实践清单：

从 7B 量化模型起步，根据需要升级
使用 Open WebUI 获得最佳对话体验
通过 Modelfile 定制模型行为
RAG 知识库使用中文嵌入模型（如 bge-m3/mxbai-embed-large）
多模型管理，根据任务选择合适模型
定期更新 Ollama 与模型版本
关注硬件利用率，按需调整 GPU/CPU 参数