Ollama本地大模型部署与实战指南：从模型管理到私有化API服务与多模型编排全流程解析

引言

Ollama是2026年最受欢迎的本地大模型运行工具，它让开发者能够在个人电脑上一键运行开源大语言模型，无需复杂的GPU配置和环境依赖。Ollama的设计理念是"Docker for LLMs"——用类似Docker的命令行体验来管理LLM的拉取、运行和管理。它支持Llama、Qwen、Mistral、DeepSeek、Gemma等主流开源模型，自动处理模型量化、GPU/CPU推理切换、上下文管理等底层细节。本文将从Ollama的安装配置开始，系统性地讲解模型管理、API服务、自定义模型创建、多模型编排、与RAG框架集成、性能优化以及生产部署等核心内容，通过大量可运行的代码示例帮助读者构建本地LLM应用。

一、Ollama安装与核心架构

1.1 安装

# macOS安装
brew install ollama

# Linux一键安装
curl -fsSL https://ollama.com/install.sh | sh

# 验证安装
ollama --version

# 查看运行状态
ollama list

安装完成后，Ollama服务会自动在后台启动（默认端口11434）。在macOS上，Ollama以应用形式运行；在Linux上，以systemd服务形式运行。以下是服务管理命令：

# Linux systemd管理
sudo systemctl status ollama
sudo systemctl restart ollama

# 查看服务日志
journalctl -u ollama -f

# 修改服务配置（如监听地址、模型存储路径）
sudo systemctl edit ollama
# 添加：
# [Service]
# Environment="OLLAMA_HOST=0.0.0.0:11434"
# Environment="OLLAMA_MODELS=/data/ollama/models"

1.2 核心架构

Ollama的架构由以下核心组件构成。Model Registry是模型注册表，存储可用模型的元数据和下载地址，类似于Docker Hub的镜像仓库。llama.cpp是底层推理引擎，Ollama基于llama.cpp构建，支持GGUF格式的量化模型。Model Runner是模型运行器，负责加载模型到GPU或CPU，管理推理会话和上下文。API Server是HTTP API服务器，提供与OpenAI兼容的REST API。Modelfile系统类似Dockerfile，允许用户自定义模型配置、系统提示和参数。以下是架构的概念表示：

┌─────────────────────────────────────────────────┐
│                   Ollama CLI / API               │
├─────────────────────────────────────────────────┤
│  Model Manager  │  API Server (:11434)          │
│  - pull/run/rm  │  - /api/generate              │
│  - Modelfile    │  - /api/chat                  │
│  - Model Store  │  - /api/embeddings            │
├─────────────────────────────────────────────────┤
│              Model Runner / Scheduler            │
│  - GPU/CPU detection  │  - Context management    │
│  - Memory management  │  - Concurrent sessions   │
├─────────────────────────────────────────────────┤
│              llama.cpp (GGUF inference)          │
│  - Quantization (Q4/Q5/Q8/FP16)                 │
│  - KV Cache  │  - Attention (Flash/standard)    │
└─────────────────────────────────────────────────┘

二、模型管理实战

2.1 拉取与运行模型

# 拉取模型（会自动选择适合硬件的量化版本）
ollama pull qwen2.5:72b
ollama pull qwen2.5:7b
ollama pull llama3.2:3b
ollama pull deepseek-r1:14b
ollama pull nomic-embed-text  # 嵌入模型

# 列出已安装模型
ollama list

# 查看模型信息
ollama show qwen2.5:7b

# 运行模型（交互式）
ollama run qwen2.5:7b

# 运行模型（单次查询）
ollama run qwen2.5:7b "解释什么是PagedAttention"

# 删除模型
ollama rm qwen2.5:7b

2.2 模型选择指南

不同模型在显存需求、推理速度和能力上有显著差异。以下是一个模型选择参考脚本：

import subprocess
import json

def get_gpu_info():
    """获取GPU信息。"""
    try:
        result = subprocess.run(
            ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
            capture_output=True, text=True
        )
        return result.stdout.strip()
    except Exception:
        return "No NVIDIA GPU detected"

def recommend_model(vram_gb: float, use_case: str = "general"):
    """根据显存大小推荐模型。"""
    models = [
        {"name": "qwen2.5:0.5b", "vram": 1, "speed": "极快", "quality": "基础"},
        {"name": "qwen2.5:1.5b", "vram": 2, "speed": "很快", "quality": "一般"},
        {"name": "qwen2.5:3b", "vram": 3, "speed": "快", "quality": "较好"},
        {"name": "qwen2.5:7b", "vram": 6, "speed": "中等", "quality": "好"},
        {"name": "qwen2.5:14b", "vram": 10, "speed": "中等", "quality": "很好"},
        {"name": "qwen2.5:32b", "vram": 22, "speed": "较慢", "quality": "优秀"},
        {"name": "qwen2.5:72b", "vram": 48, "speed": "慢", "quality": "卓越"},
    ]

    print(f"\nGPU显存: {vram_gb:.1f} GB")
    print(f"使用场景: {use_case}\n")
    print(f"{'模型':25s} {'显存需求':>8s} {'速度':>6s} {'质量':>6s} {'推荐':>6s}")
    print("-" * 60)

    for m in models:
        can_run = m["vram"] <= vram_gb
        # 留20%余量
        recommended = can_run and m["vram"] <= vram_gb * 0.8
        mark = "✓ 推荐" if recommended else ("○ 可用" if can_run else "✗ 超限")
        print(f"{m['name']:25s} {m['vram']:>6d}GB {m['speed']:>6s} {m['quality']:>6s} {mark:>10s}")

# 示例
gpu_info = get_gpu_info()
print(f"GPU信息: {gpu_info}")
recommend_model(vram_gb=24, use_case="代码生成")

三、API服务与编程集成

3.1 REST API

Ollama提供完整的REST API，默认监听11434端口：

import requests
import json

OLLAMA_URL = "http://localhost:11434"

# 1. 生成补全（非对话模式）
response = requests.post(f"{OLLAMA_URL}/api/generate", json={
    "model": "qwen2.5:7b",
    "prompt": "写一个Python快速排序函数",
    "stream": False,
    "options": {
        "temperature": 0.7,
        "top_p": 0.9,
        "num_predict": 512,
    },
})
print(response.json()["response"])

# 2. 对话模式
response = requests.post(f"{OLLAMA_URL}/api/chat", json={
    "model": "qwen2.5:7b",
    "messages": [
        {"role": "system", "content": "你是一个Python专家。"},
        {"role": "user", "content": "如何优化asyncio性能？"},
    ],
    "stream": False,
    "options": {"temperature": 0.3, "num_predict": 1024},
})
print(response.json()["message"]["content"])

# 3. 流式输出
response = requests.post(f"{OLLAMA_URL}/api/chat", json={
    "model": "qwen2.5:7b",
    "messages": [{"role": "user", "content": "写一首关于编程的诗"}],
    "stream": True,
}, stream=True)
for line in response.iter_lines():
    if line:
        data = json.loads(line)
        if "message" in data:
            print(data["message"]["content"], end="", flush=True)

# 4. 生成嵌入
response = requests.post(f"{OLLAMA_URL}/api/embeddings", json={
    "model": "nomic-embed-text",
    "prompt": "vLLM是一个高性能LLM推理引擎",
})
embedding = response.json()["embedding"]
print(f"Embedding维度: {len(embedding)}")

# 5. 查看运行中的模型
response = requests.get(f"{OLLAMA_URL}/api/ps")
print(f"运行中的模型: {response.json()}")

3.2 Python SDK

# 使用ollama Python SDK
import ollama

# 对话
response = ollama.chat(
    model="qwen2.5:7b",
    messages=[
        {"role": "system", "content": "你是一个技术文档助手。"},
        {"role": "user", "content": "解释Docker网络模式。"},
    ],
    options={"temperature": 0.3},
)
print(response["message"]["content"])

# 流式对话
for chunk in ollama.chat(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "写一个Go语言的HTTP服务器"}],
    stream=True,
):
    print(chunk["message"]["content"], end="", flush=True)

# 生成嵌入
embed = ollama.embeddings(
    model="nomic-embed-text",
    prompt="PostgreSQL是一个强大的开源关系数据库",
)
print(f"嵌入维度: {len(embed['embedding'])}")

# 模型管理
ollama.pull("qwen2.5:14b")  # 拉取模型
ollama.list()                # 列出模型
ollama.show("qwen2.5:7b")    # 模型信息

3.3 OpenAI兼容API

Ollama提供OpenAI兼容的API端点，可以直接使用OpenAI SDK：

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # 任意值即可
)

# 完全兼容OpenAI API
response = client.chat.completions.create(
    model="qwen2.5:7b",
    messages=[
        {"role": "system", "content": "你是一个代码审查专家。"},
        {"role": "user", "content": "审查以下代码的安全性：\n```python\ndef query(user_input):\n    cursor.execute(f'SELECT * FROM users WHERE name={user_input}')\n```"},
    ],
    temperature=0.2,
)
print(response.choices[0].message.content)

# 嵌入
embed = client.embeddings.create(
    model="nomic-embed-text",
    input="Docker是一种容器化技术",
)
print(f"维度: {len(embed.data[0].embedding)}")

四、自定义模型（Modelfile）

4.1 创建自定义模型

Modelfile类似Dockerfile，允许自定义模型的行为：

# Modelfile - 技术文档助手模型
FROM qwen2.5:7b

# 系统提示
SYSTEM """
你是一个专业的技术文档撰写助手。你的任务是帮助开发者编写清晰、准确的技术文档。
规则：
1. 使用Markdown格式
2. 包含代码示例
3. 语言简洁专业
4. 中文回答，代码和术语保持英文
"""

# 参数
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
PARAMETER stop "<|im_end|>"
PARAMETER repeat_penalty 1.1

# 模板
TEMPLATE """
{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
{{ .Response }}<|im_end|>
"""

# 构建自定义模型
ollama create tech-doc-assistant -f Modelfile

# 运行自定义模型
ollama run tech-doc-assistant "为FastAPI写一份API文档模板"

# 查看自定义模型信息
ollama show tech-doc-assistant --modelfile

4.2 多种自定义模型

# Modelfile.code-reviewer - 代码审查专家
FROM qwen2.5:14b
SYSTEM """
你是资深代码审查员。审查代码时关注：
1. 安全漏洞（SQL注入、XSS、路径遍历）
2. 性能问题（N+1查询、内存泄漏）
3. 错误处理缺失
4. 代码可维护性
输出格式：
## 严重问题（必须修复）
## 建议改进
## 良好实践
## 总评
"""
PARAMETER temperature 0.1
PARAMETER num_ctx 16384

# Modelfile.sql-expert - SQL专家
FROM qwen2.5:7b
SYSTEM """
你是PostgreSQL专家。帮助用户：
1. 编写高效的SQL查询
2. 设计数据库schema
3. 优化查询性能
4. 解决数据建模问题
"""
PARAMETER temperature 0.2
PARAMETER num_ctx 8192

# 构建所有自定义模型
ollama create code-reviewer -f Modelfile.code-reviewer
ollama create sql-expert -f Modelfile.sql-expert

五、多模型编排

5.1 模型路由服务

以下是一个根据查询类型自动路由到不同模型的编排服务：

from fastapi import FastAPI
from pydantic import BaseModel
import ollama
import re
from typing import Optional

app = FastAPI(title="Multi-Model Router")

class QueryRequest(BaseModel):
    query: str
    model: Optional[str] = None  # 手动指定模型
    context: Optional[str] = None

class QueryResponse(BaseModel):
    answer: str
    model_used: str
    routing_reason: str

def route_query(query: str) -> tuple[str, str]:
    """根据查询内容自动路由到最合适的模型。"""
    query_lower = query.lower()

    # 代码审查
    if any(kw in query_lower for kw in ["审查", "review", "代码质量", "安全漏洞"]):
        return "code-reviewer", "检测到代码审查相关关键词"

    # SQL相关
    if any(kw in query_lower for kw in ["sql", "查询", "数据库", "表结构", "索引"]):
        return "sql-expert", "检测到数据库相关关键词"

    # 代码生成
    if any(kw in query_lower for kw in ["写", "实现", "函数", "代码", "code", "implement"]):
        return "qwen2.5:14b", "代码生成任务需要更强模型"

    # 日常对话
    return "qwen2.5:7b", "通用对话使用轻量模型"

@app.post("/query", response_model=QueryResponse)
async def query(req: QueryRequest):
    # 路由
    if req.model:
        model = req.model
        reason = "用户手动指定"
    else:
        model, reason = route_query(req.query)

    # 构建消息
    messages = []
    if req.context:
        messages.append({"role": "system", "content": f"上下文：{req.context}"})
    messages.append({"role": "user", "content": req.query})

    # 调用Ollama
    response = ollama.chat(
        model=model,
        messages=messages,
        options={"temperature": 0.3, "num_predict": 2048},
    )

    return QueryResponse(
        answer=response["message"]["content"],
        model_used=model,
        routing_reason=reason,
    )

@app.get("/models")
async def list_models():
    """列出可用模型及其用途。"""
    return {
        "models": [
            {"name": "qwen2.5:7b", "purpose": "通用对话", "speed": "快"},
            {"name": "qwen2.5:14b", "purpose": "代码生成", "speed": "中等"},
            {"name": "code-reviewer", "purpose": "代码审查", "speed": "中等"},
            {"name": "sql-expert", "purpose": "SQL专家", "speed": "快"},
            {"name": "tech-doc-assistant", "purpose": "技术文档", "speed": "快"},
        ]
    }

5.2 流水线编排

以下是一个多模型流水线编排示例，实现从需求到代码到测试的完整开发流程：

import ollama
from typing import Dict, List

class DevPipeline:
    """多模型开发流水线。"""

    def __init__(self):
        self.steps: List[Dict] = []

    def add_step(self, name: str, model: str, system_prompt: str, extract_fn=None):
        """添加流水线步骤。"""
        self.steps.append({
            "name": name,
            "model": model,
            "system_prompt": system_prompt,
            "extract_fn": extract_fn,
        })
        return self

    def run(self, task: str) -> Dict:
        """执行完整流水线。"""
        results = {}
        current_input = task

        for step in self.steps:
            print(f"\n=== Step: {step['name']} (model: {step['model']}) ===")

            response = ollama.chat(
                model=step["model"],
                messages=[
                    {"role": "system", "content": step["system_prompt"]},
                    {"role": "user", "content": current_input},
                ],
                options={"temperature": 0.3, "num_predict": 2048},
                stream=True,
            )

            output = ""
            for chunk in response:
                content = chunk["message"]["content"]
                print(content, end="", flush=True)
                output += content

            # 提取关键内容传递给下一步
            if step["extract_fn"]:
                current_input = step["extract_fn"](output)
            else:
                current_input = output

            results[step["name"]] = output

        return results


# 使用示例
pipeline = DevPipeline()

# 步骤1: 需求分析
pipeline.add_step(
    name="requirements",
    model="qwen2.5:7b",
    system_prompt="你是产品经理。分析用户需求，输出结构化的功能需求列表和非功能需求。格式：用Markdown列表。",
)

# 步骤2: 架构设计
pipeline.add_step(
    name="architecture",
    model="qwen2.5:14b",
    system_prompt="你是架构师。基于需求设计系统架构，包括技术选型、模块划分和数据流。输出Markdown格式。",
    extract_fn=lambda x: f"需求分析：{x}\n\n请基于以上需求设计架构。",
)

# 步骤3: 代码实现
pipeline.add_step(
    name="implementation",
    model="qwen2.5:14b",
    system_prompt="你是资深开发者。基于架构设计，实现核心代码。输出完整的代码，包含类型注解和错误处理。",
    extract_fn=lambda x: f"架构设计：{x}\n\n请基于以上架构实现核心代码。",
)

# 步骤4: 测试用例
pipeline.add_step(
    name="testing",
    model="qwen2.5:7b",
    system_prompt="你是测试工程师。为代码编写单元测试，覆盖正常路径和边界条件。",
    extract_fn=lambda x: f"代码实现：{x}\n\n请为以上代码编写测试。",
)

# 执行流水线
results = pipeline.run("实现一个用户注册API，支持邮箱验证、密码强度检查和防止重复注册")

六、Ollama与RAG集成

6.1 完整本地RAG系统

以下是一个完全基于Ollama的本地RAG系统，不依赖任何外部API：

import ollama
import chromadb
from typing import List, Dict
import re
import hashlib

class LocalRAG:
    """完全本地的RAG系统，使用Ollama进行嵌入和生成。"""

    def __init__(self, embedding_model: str = "nomic-embed-text", llm_model: str = "qwen2.5:7b"):
        self.embedding_model = embedding_model
        self.llm_model = llm_model
        self.chroma = chromadb.PersistentClient(path="./chroma_db")
        self.collection = self.chroma.get_or_create_collection(
            name="documents",
            metadata={"hnsw:space": "cosine"},
        )

    def embed(self, text: str) -> List[float]:
        """使用Ollama生成嵌入。"""
        response = ollama.embeddings(model=self.embedding_model, prompt=text)
        return response["embedding"]

    def add_documents(self, texts: List[str], metadatas: List[Dict] = None):
        """添加文档到知识库。"""
        metadatas = metadatas or [{} for _ in texts]

        # 分块
        all_chunks = []
        all_embeddings = []
        all_ids = []
        all_metadatas = []

        for i, text in enumerate(texts):
            chunks = self._split_text(text, chunk_size=500, overlap=50)
            for j, chunk in enumerate(chunks):
                content_hash = hashlib.md5(chunk.encode()).hexdigest()
                all_chunks.append(chunk)
                all_embeddings.append(self.embed(chunk))
                all_ids.append(f"doc_{i}_chunk_{j}_{content_hash[:8]}")
                all_metadatas.append({
                    **metadatas[i],
                    "chunk_index": j,
                    "total_chunks": len(chunks),
                })

        # 存入ChromaDB
        self.collection.upsert(
            ids=all_ids,
            documents=all_chunks,
            embeddings=all_embeddings,
            metadatas=all_metadatas,
        )
        print(f"添加 {len(texts)} 个文档，共 {len(all_chunks)} 个块")

    def _split_text(self, text: str, chunk_size: int = 500, overlap: int = 50) -> List[str]:
        """文本分块。"""
        sentences = re.split(r'(?<=[。！？.!?])\s+', text)
        chunks = []
        current = ""
        for sent in sentences:
            if len(current) + len(sent) > chunk_size and current:
                chunks.append(current)
                current = sent
            else:
                current = f"{current} {sent}" if current else sent
        if current:
            chunks.append(current)
        return chunks

    def retrieve(self, query: str, top_k: int = 5) -> List[Dict]:
        """检索相关文档。"""
        query_embedding = self.embed(query)
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k,
        )

        docs = []
        for i in range(len(results["documents"][0])):
            docs.append({
                "text": results["documents"][0][i],
                "score": 1 - results["distances"][0][i],  # 转换距离为相似度
                "metadata": results["metadatas"][0][i],
            })
        return docs

    def generate(self, query: str, retrieved_docs: List[Dict]) -> str:
        """基于检索结果生成答案。"""
        context = "\n\n".join([
            f"[文档{i+1}] (相关度: {d['score']:.2f})\n{d['text']}"
            for i, d in enumerate(retrieved_docs)
        ])

        response = ollama.chat(
            model=self.llm_model,
            messages=[
                {"role": "system", "content": f"""你是一个专业的问答助手。
基于以下检索到的文档上下文回答问题。
如果文档中没有相关信息，说明"根据现有文档无法回答"。

文档上下文：
{context}"""},
                {"role": "user", "content": query},
            ],
            options={"temperature": 0.1, "num_predict": 1024},
        )
        return response["message"]["content"]

    def query(self, question: str) -> Dict:
        """完整RAG查询。"""
        retrieved = self.retrieve(question, top_k=5)
        answer = self.generate(question, retrieved)
        return {
            "answer": answer,
            "sources": [
                {"text": d["text"][:200], "score": d["score"], "metadata": d["metadata"]}
                for d in retrieved
            ],
        }


# 使用示例
rag = LocalRAG(embedding_model="nomic-embed-text", llm_model="qwen2.5:7b")

# 添加文档
rag.add_documents([
    """FastAPI是一个现代的Python Web框架，基于ASGI标准构建。
    它使用Python类型提示进行数据验证和序列化，支持async/await异步编程。
    FastAPI的性能接近NodeJS和Go，是Python中最快的Web框架之一。

    核心特性：
    1. 基于Starlette的ASGI框架
    2. 使用Pydantic进行数据验证
    3. 自动生成OpenAPI文档
    4. 依赖注入系统
    5. WebSocket支持""",

    """Django是一个全功能的Python Web框架，遵循"内置一切"的理念。
    包含ORM、认证系统、admin后台、表单处理、模板引擎等。

    Django的优势：
    1. 完善的ORM支持多种数据库
    2. 内置admin后台
    3. 成熟的安全机制
    4. 丰富的第三方包生态
    5. 适合快速开发内容管理系统""",

    """Flask是一个轻量级Python Web框架，提供最小核心功能。
    通过扩展添加数据库、认证、表单等功能。

    Flask的特点：
    1. 微框架设计，核心简洁
    2. 高度可定制
    3. Jinja2模板引擎
    4. 适合小型项目和微服务
    5. 学习曲线平缓""",
])

# 查询
result = rag.query("哪个Python Web框架适合快速开发CMS？")
print(f"答案: {result['answer']}")
print(f"\n来源: {len(result['sources'])} 个文档")

七、Ollama与LangChain/LlamaIndex集成

7.1 LangChain集成

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 使用Ollama作为LLM
llm = Ollama(model="qwen2.5:7b", temperature=0.3)
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# 构建链
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个Python技术专家。"),
    ("user", "{input}"),
])
chain = prompt | llm | StrOutputParser()

result = chain.invoke({"input": "如何使用asyncio实现并发HTTP请求？"})
print(result)

7.2 LlamaIndex集成

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, Settings, SimpleDirectoryReader

# 配置LlamaIndex使用Ollama
Settings.llm = Ollama(model="qwen2.5:7b", temperature=0.3)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text")

# 加载文档
documents = SimpleDirectoryReader("./docs").load_data()

# 构建索引
index = VectorStoreIndex.from_documents(documents)

# 查询
query_engine = index.as_query_engine(similarity_top_k=3)
response = query_engine.query("什么是PagedAttention？")
print(response.response)

八、性能优化与生产部署

8.1 并发处理

Ollama默认串行处理请求。对于高并发场景，需要配置并发数：

# 设置环境变量
export OLLAMA_NUM_PARALLEL=4  # 同时处理的请求数
export OLLAMA_MAX_LOADED_MODELS=2  # 同时加载的模型数
export OLLAMA_KEEP_ALIVE=10m  # 模型在内存中保持的时间

# 重启服务
sudo systemctl restart ollama

8.2 上下文窗口优化

import ollama

# 增大上下文窗口
response = ollama.chat(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "总结这篇长文档"}],
    options={
        "num_ctx": 8192,       # 上下文窗口大小
        "num_predict": 2048,   # 最大生成token数
        "temperature": 0.3,
        "top_p": 0.9,
        "repeat_penalty": 1.1,
    },
)

8.3 Docker部署

# docker-compose.yml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    environment:
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_KEEP_ALIVE=10m

  ollama-webui:  # 可选：Open WebUI前端
    image: ghcr.io/open-webui/open-webui:main
    container_name: ollama-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - webui_data:/app/backend/data
    depends_on:
      - ollama

volumes:
  ollama_data:
  webui_data:

8.4 负载均衡

# 多节点Ollama负载均衡
import requests
from itertools import cycle
from typing import List

class OllamaLoadBalancer:
    """多节点Ollama负载均衡器。"""

    def __init__(self, nodes: List[str]):
        self.nodes = cycle(nodes)
        self.node_health = {node: True for node in nodes}

    def chat(self, model: str, messages: list, **kwargs) -> dict:
        """负载均衡的chat调用。"""
        attempts = 0
        max_attempts = len(self.node_health)

        while attempts < max_attempts:
            node = next(self.nodes)
            if not self.node_health.get(node, False):
                attempts += 1
                continue

            try:
                response = requests.post(
                    f"http://{node}/api/chat",
                    json={"model": model, "messages": messages, **kwargs},
                    timeout=60,
                )
                response.raise_for_status()
                return response.json()
            except requests.exceptions.RequestException as e:
                print(f"Node {node} failed: {e}")
                self.node_health[node] = False
                attempts += 1

        raise RuntimeError("All nodes failed")

    def health_check(self):
        """检查所有节点健康状态。"""
        for node in list(self.node_health.keys()):
            try:
                r = requests.get(f"http://{node}/api/tags", timeout=5)
                self.node_health[node] = r.status_code == 200
            except:
                self.node_health[node] = False
        return self.node_health

# 使用
lb = OllamaLoadBalancer([
    "gpu-node-1:11434",
    "gpu-node-2:11434",
    "gpu-node-3:11434",
])

response = lb.chat(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "Hello"}],
)

总结

Ollama作为本地大模型运行工具，凭借极简的使用体验（ollama pull/run）、广泛的模型支持、OpenAI兼容API和Modelfile自定义能力，成为本地LLM部署的事实标准。本文系统性地覆盖了安装配置、模型管理、API服务、自定义模型、多模型编排、RAG集成和性能优化等核心内容。关键要点包括：根据GPU显存选择合适大小的模型；使用Modelfile创建领域专用模型；通过模型路由和流水线编排实现多模型协作；结合ChromaDB等向量数据库构建完全本地的RAG系统；生产部署需要配置并发参数和负载均衡。对于数据敏感场景、开发测试环境或成本控制需求，Ollama提供了最简单的本地LLM运行方案。随着开源模型能力的持续提升，Ollama在企业AI基础设施中的角色将愈发重要。