DeepSeek Ollama部署实战教程

# 1. 下载并运行模型（一行命令搞定下载 + 运行）
ollama run deepseek-r1:7b
# 2. 查看本地已有模型
ollama list
# 3. 通过 REST API 调用
curl http://localhost:11434/api/generate -d '{"model":"deepseek-r1:7b","prompt":"你好"}'

┌─────────────────────────────────────────────┐
│                 你的应用程序                    │
│   (curl / Python / LangChain / WebUI ...)    │
└──────────────────┬──────────────────────────┘
                   │ HTTP / REST  (默认端口 11434)
┌──────────────────▼──────────────────────────┐
│          Ollama 本地服务 (ollama serve)        │
│     - 模型管理、并发调度、上下文缓存             │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│        模型运行时 (基于 llama.cpp)             │
│     - GGUF 权重加载 / 量化推理                  │
│     - GPU 加速 (CUDA/ROCm/Metal) 或 CPU       │
└─────────────────────────────────────────────┘

第3步 安装 Ollama
   ↓
第4步 验证服务 (ollama serve + 11434 端口)
   ↓
第5步 拉取 DeepSeek 模型 (ollama pull deepseek-r1:7b)
   ↓
第6步 命令行对话 (ollama run deepseek-r1:7b)
   ↓
第7步 HTTP API 调用 (/api/generate / /api/chat)
   ↓
第8步 Python 程序化调用 (requests / ollama / openai / langchain)
   ↓
第9步 自定义模型 (Modelfile)
   ↓
第10步 局域网暴露 (OLLAMA_HOST)
   ↓
第11步 性能调优 + Docker 部署

# 查看版本号
ollama --version

ollama version is 0.x.x

# 使用 winget 安装
winget install Ollama.Ollama

# Ubuntu / Debian / CentOS 等通用
curl -fsSL https://ollama.com/install.sh | sh

# 查看版本
ollama --version
# 查看服务状态（systemd 方式）
systemctl status ollama

# 启动 ollama 服务
sudo systemctl start ollama
# 设置开机自启
sudo systemctl enable ollama

# 以下载 amd64 版本为例，arm64 请替换
curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o ollama.tgz
# 解压并安装到 /usr/local/bin
tar -C /usr -xzf ollama.tgz
# 前台启动服务（测试用）
ollama serve

brew install ollama

# 1. 确认版本
ollama --version
# 2. 确认服务运行（Windows 下服务已自动运行；Linux/macOS 需确保 ollama serve 在跑）
# 直接请求本地 API 测试
curl http://localhost:11434/api/version

{"version":"0.x.x"}

# PowerShell 中临时设置（当前会话有效）
$env:OLLAMA_MODELS = "D:\ollama\models"
# 永久设置：系统设置 -> 高级系统设置 -> 环境变量 -> 新建

# 临时设置
export OLLAMA_HOST="0.0.0.0:11434"
# 永久设置（写入用户配置文件）
echo 'export OLLAMA_HOST="0.0.0.0:11434"' >> ~/.bashrc
source ~/.bashrc

# 查看帮助
ollama help
# 查看版本
ollama --version
# 查看本地已下载的模型列表
ollama list
# 从模型库下载模型（示例：拉取 deepseek-r1:7b）
ollama pull deepseek-r1:7b
# 运行模型并进入交互对话
ollama run deepseek-r1:7b
# 查看当前已加载模型的资源占用
ollama ps
# 显示模型详细信息（参数量、量化、上下文等）
ollama show deepseek-r1:7b
# 删除本地模型
ollama rm deepseek-r1:7b
# 复制模型
ollama cp deepseek-r1:7b my-deepseek
# 从 Modelfile 创建自定义模型
ollama create my-model -f ./Modelfile

ollama pull deepseek-r1:7b

pulling manifest
pulling 6f1dc39c72f5... 100% ████████████████████████ 4.7 GB
verifying sha256 digest
writing manifest
success

# Linux/macOS
export HTTPS_PROXY=http://127.0.0.1:7890
ollama pull deepseek-r1:7b

ollama list

NAME                ID              SIZE    MODIFIED
deepseek-r1:7b      0a8c26691023    4.7 GB  2 minutes ago

ollama show deepseek-r1:7b

  Model
    architecture        qwen2
    parameters          7.6B
    context length      131072
    embedding length    3584
    quantization        Q4_K_M
  Capabilities
    completion          true
    chat                true
    vision              false
    tools               true
    ...

ollama rm deepseek-r1:7b

ollama ps

NAME              ID       PROCESSOR   UNTIL                MODEL      SIZE   CPU  GPU
deepseek-r1:7b    ...     100% GPU    4 minutes from now   7.6B       4.7GB  0%   4.7GB

ollama run deepseek-r1:7b

>>> 你好，请介绍一下你自己

<think>
用户询问我的身份，需要简洁介绍 DeepSeek 模型的基本信息...
</think>
你好！我是 DeepSeek，一个由深度求索公司开发的开源大语言模型。
我可以帮助你回答问题、编写代码、进行推理分析等。有什么可以帮你的？

>>> /set parameter temperature 0.3
Set parameter temperature to 0.3
>>> /bye

# 直接提问
ollama run deepseek-r1:7b "用 Python 写一个冒泡排序"
# 一次问答并输出流式结果
ollama run deepseek-r1:7b "1 + 1 等于多少？"

#!/bin/bash
# 批量测试模型
for question in "你好" "什么是大模型" "写一段 Hello World"; do
  echo "问题：$question"
  ollama run deepseek-r1:7b "$question"
  echo "=========================="
done

>>> 我今年 28 岁
>>> 根据刚才的信息，我多大了？
根据你刚才提到的信息，你今年 28 岁。

ollama run deepseek-r1:7b --system "你是一名资深的 Python 后端工程师，回答问题时给出简洁的代码示例"

>>> /set system 你是一名耐心的中文老师，回答要循序渐进
Set system message.

curl http://localhost:11434/api/version

{"version":"0.x.x"}

curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-r1:7b",
  "prompt": "请用一句话介绍什么是大语言模型",
  "stream": false
}'

{
  "model": "deepseek-r1:7b",
  "created_at": "2026-09-03T10:00:00.000Z",
  "response": "大语言模型是一种基于深度学习、在海量文本上训练的模型，能够理解和生成自然语言。",
  "done": true,
  "total_duration": 1234567890,
  "eval_count": 32,
  "eval_duration": 987654321
}

curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-r1:7b",
  "prompt": "写一首关于秋天的五言绝句",
  "stream": true
}'

{"model":"deepseek-r1:7b","response":"秋","done":false}
{"model":"deepseek-r1:7b","response":"风","done":false}
{"model":"deepseek-r1:7b","response":"起","done":false}
...
{"model":"deepseek-r1:7b","response":"","done":true,"total_duration":...}

curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1:7b",
  "messages": [
    {"role": "system", "content": "你是一个乐于助人的助手"},
    {"role": "user", "content": "你好，请介绍一下自己"},
    {"role": "assistant", "content": "你好！我是一个本地部署的大语言模型。"},
    {"role": "user", "content": "你刚才说你是本地部署的，请问本地部署有什么好处？"}
  ],
  "stream": false
}'

curl http://localhost:11434/api/tags

{
  "models": [
    {
      "name": "deepseek-r1:7b",
      "model": "deepseek-r1:7b",
      "size": 4989797124,
      "details": {
        "parameter_size": "7.6B",
        "quantization_level": "Q4_K_M"
      }
    }
  ]
}

curl http://localhost:11434/api/show -d '{"model": "deepseek-r1:7b"}'

curl http://localhost:11434/api/pull -d '{"model": "deepseek-r1:8b"}'

# 拉取一个嵌入模型
ollama pull nomic-embed-text
# 生成嵌入向量
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "今天天气真不错"
}'

python --version

# 基础 HTTP 请求库（一般已内置）
pip install requests
# Ollama 官方 Python 库
pip install ollama
# OpenAI 兼容 SDK
pip install openai
# LangChain 框架
pip install langchain-ollama

# -*- coding: utf-8 -*-
"""使用 requests 调用 Ollama /api/generate 接口（非流式）"""
import requests
import json
OLLAMA_URL = "http://localhost:11434"
MODEL_NAME = "deepseek-r1:7b"
def generate(prompt: str, stream: bool = False) -> str:
    """调用 generate 接口生成文本"""
    payload = {
        "model": MODEL_NAME,
        "prompt": prompt,
        "stream": stream,
        "options": {
            "temperature": 0.7,
            "num_predict": 512,   # 限制最大生成长度
        },
    }
    resp = requests.post(
        f"{OLLAMA_URL}/api/generate",
        json=payload,
        timeout=300,  # 大模型推理较慢，超时设长一些
    )
    resp.raise_for_status()
    data = resp.json()
    return data["response"]
if __name__ == "__main__":
    answer = generate("用 Python 写一个计算斐波那契数列的函数")
    print("回答：")
    print(answer)

# -*- coding: utf-8 -*-
"""使用 requests 流式调用 Ollama，实现打字机效果"""
import requests
import json
OLLAMA_URL = "http://localhost:11434"
MODEL_NAME = "deepseek-r1:7b"
def generate_stream(prompt: str):
    """流式生成，逐块 yield 文本"""
    payload = {
        "model": MODEL_NAME,
        "prompt": prompt,
        "stream": True,
    }
    with requests.post(
        f"{OLLAMA_URL}/api/generate",
        json=payload,
        stream=True,
        timeout=300,
    ) as resp:
        resp.raise_for_status()
        # SSE 格式：每行一个 JSON
        for line in resp.iter_lines():
            if not line:
                continue
            data = json.loads(line)
            chunk = data.get("response", "")
            yield chunk
            if data.get("done"):
                break
if __name__ == "__main__":
    print("开始生成：\n")
    for piece in generate_stream("请详细解释一下 OOP 的三大特性"):
        print(piece, end="", flush=True)
    print("\n\n生成完成。")

# -*- coding: utf-8 -*-
"""使用 requests 调用 /api/chat 实现多轮对话"""
import requests
OLLAMA_URL = "http://localhost:11434"
MODEL_NAME = "deepseek-r1:7b"
# 对话历史，按消息追加即可
messages = [
    {"role": "system", "content": "你是一个严谨的技术助手。"},
]
def chat(user_input: str) -> str:
    """发送用户消息并返回模型回复，同时维护历史"""
    global messages
    messages.append({"role": "user", "content": user_input})
    payload = {
        "model": MODEL_NAME,
        "messages": messages,
        "stream": False,
    }
    resp = requests.post(f"{OLLAMA_URL}/api/chat", json=payload, timeout=300)
    resp.raise_for_status()
    data = resp.json()
    # 把模型回复追加进历史，保持多轮上下文
    reply = data["message"]["content"]
    messages.append({"role": "assistant", "content": reply})
    return reply
if __name__ == "__main__":
    while True:
        user = input("我（输入 exit 退出）：")
        if user.strip().lower() == "exit":
            break
        print("DeepSeek：", chat(user))

# -*- coding: utf-8 -*-
"""使用 ollama 官方 Python 库"""
import ollama
MODEL_NAME = "deepseek-r1:7b"
# 1. 简单生成（同步）
response = ollama.generate(
    model=MODEL_NAME,
    prompt="介绍一下云原生技术",
)
print("生成结果：", response["response"])
print("耗时(ms)：", response["eval_count"])
# 2. 多轮对话
messages = [
    {"role": "system", "content": "你是一名数据库专家。"},
    {"role": "user", "content": "MySQL 和 PostgreSQL 有什么区别？"},
]
response = ollama.chat(model=MODEL_NAME, messages=messages)
print("对话回复：", response["message"]["content"])
# 3. 流式生成
print("\n流式输出：")
stream = ollama.generate(model=MODEL_NAME, prompt="写一首短诗", stream=True)
for chunk in stream:
    print(chunk["response"], end="", flush=True)
print()

# -*- coding: utf-8 -*-
"""使用 OpenAI SDK 调用本地 Ollama（DeepSeek）"""
from openai import OpenAI
# 指向本地 Ollama 服务
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Ollama 不校验 key，任意值即可
)
# 普通对话
response = client.chat.completions.create(
    model="deepseek-r1:7b",
    messages=[
        {"role": "system", "content": "你是一个 Python 专家"},
        {"role": "user", "content": "如何优化递归函数的性能？"},
    ],
    temperature=0.7,
)
print(response.choices[0].message.content)
# 流式对话
print("\n流式对话：")
stream = client.chat.completions.create(
    model="deepseek-r1:7b",
    messages=[{"role": "user", "content": "用三句话介绍 Kafka"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

# -*- coding: utf-8 -*-
"""使用 LangChain 集成 Ollama DeepSeek"""
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage
# 创建 Ollama 聊天模型
llm = ChatOllama(
    model="deepseek-r1:7b",
    base_url="http://localhost:11434",
    temperature=0.7,
    num_predict=512,
)
# 简单调用
response = llm.invoke("什么是依赖注入？")
print(response.content)
# 带系统提示词的多轮调用
messages = [
    SystemMessage(content="你是一个简洁的代码评审专家。"),
    HumanMessage(content="请评审下面这段代码：\n\ndef add(a,b):\n    return a+b"),
]
response = llm.invoke(messages)
print("\n代码评审结果：")
print(response.content)

# -*- coding: utf-8 -*-
"""异步调用 Ollama，适合高并发场景"""
import asyncio
import ollama
async def async_generate(prompt: str) -> str:
    """异步生成文本"""
    result = await ollama.AsyncClient().generate(
        model="deepseek-r1:7b",
        prompt=prompt,
    )
    return result["response"]
async def main():
    # 并发执行多个生成任务
    prompts = [
        "写一段 Python 代码",
        "解释什么是 HTTP 协议",
        "列出常见的排序算法",
    ]
    tasks = [async_generate(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    for i, r in enumerate(results):
        print(f"任务{i + 1}：{r[:100]}...\n")
if __name__ == "__main__":
    asyncio.run(main())

# Modelfile
# 基于 deepseek-r1:7b 定制一个中文代码助手
FROM deepseek-r1:7b
# 系统提示词
SYSTEM """你是一个专业的中文代码助手。
要求：
1. 所有回答一律使用中文；
2. 涉及代码时，必须给出完整可运行的代码块；
3. 优先给出简洁、高效的解决方案；
4. 回答末尾给出关键注意事项。"""
# 推理参数
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
PARAMETER stop "</s>"

# 在当前目录执行
ollama create my-deepseek-coder -f ./Modelfile

NAME                    ID       SIZE   MODIFIED
my-deepseek-coder       ...      4.7GB  1 second ago
deepseek-r1:7b          ...      4.7GB  3 minutes ago

ollama run my-deepseek-coder "帮我写一个快速排序"

FROM deepseek-r1:7b
SYSTEM """你是XX公司的智能客服小助手。
- 只回答与XX公司产品、服务相关的问题；
- 遇到不确定的问题，礼貌地告知用户会转接人工客服；
- 语气亲切、专业；
- 回复控制在200字以内。"""
PARAMETER temperature 0.5
PARAMETER num_ctx 4096

ollama create support-assistant -f ./Modelfile
ollama run support-assistant

# 使用本地 GGUF 文件
FROM ./deepseek-r1-7b.Q4_K_M.gguf
PARAMETER temperature 0.7

ollama create my-local-model -f ./Modelfile

# PowerShell 临时设置
$env:OLLAMA_HOST = "0.0.0.0:11434"

# 设置监听所有网卡
export OLLAMA_HOST="0.0.0.0:11434"
# 如果是 systemd 服务，编辑服务配置
sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

sudo systemctl daemon-reload
sudo systemctl restart ollama

# 允许所有来源（仅限可信环境）
export OLLAMA_ORIGINS="*"

sudo ufw allow 11434/tcp
sudo ufw reload

# 在另一台电脑上执行（把 IP 换成服务器 IP）
curl http://192.168.1.100:11434/api/version
curl http://192.168.1.100:11434/api/chat -d '{
  "model": "deepseek-r1:7b",
  "messages": [{"role":"user","content":"你好"}],
  "stream": false
}'

from openai import OpenAI
client = OpenAI(
    base_url="http://192.168.1.100:11434/v1",
    api_key="ollama",
)

# Modelfile 中设置
PARAMETER num_ctx 8192

# API 中设置
payload = {
    "model": "deepseek-r1:7b",
    "prompt": "你好",
    "options": {"num_ctx": 8192},
}

# 允许同时加载的模型数量
export OLLAMA_MAX_LOADED_MODELS=2
# 模型保持加载的时间（空闲多久后卸载），5m 表示 5 分钟
export OLLAMA_KEEP_ALIVE=5m
# 每个模型的并发请求数量
export OLLAMA_NUM_PARALLEL=4

# 拉取 Q4_K_M 版本（默认）
ollama pull deepseek-r1:7b
# 拉取 Q5 版本（需要该 tag 存在于模型库）
ollama pull deepseek-r1:7b-q5_K_M

NAME              ID       PROCESSOR   UNTIL                MODEL   SIZE   GPU
deepseek-r1:7b    ...     100% GPU     ...                 7.6B    4.7GB  4.7GB

# 查看 GPU 型号和显存
nvidia-smi
# 查看 CUDA 版本
nvcc --version

export OLLAMA_DEBUG=1
ollama serve

# 拉取 Ollama 官方镜像
docker pull ollama/ollama
# 运行容器并映射端口（CPU 模式）
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# 进入容器执行拉取
docker exec -it ollama ollama pull deepseek-r1:7b
# 运行模型（交互）
docker exec -it ollama ollama run deepseek-r1:7b
# 通过宿主机的 API 调用
curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1:7b",
  "messages": [{"role":"user","content":"你好"}],
  "stream": false
}'

# 使用 GPU 运行容器
docker run -d --gpus all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    # GPU 环境取消下面注释
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]
    environment:
      - OLLAMA_HOST=0.0.0.0:11434
      - OLLAMA_KEEP_ALIVE=5m
volumes:
  ollama_data:

docker compose up -d

Error: could not locate cudart

# 1. 更新 NVIDIA 驱动（>= 452.39）
# 2. 安装 CUDA Toolkit，或确认驱动已包含 CUDA 运行库
# 3. 确认环境变量
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH

Error: failed to load model ... cudaMalloc failed: out of memory

bind: address already in use

# 查看占用端口的进程
# Windows
netstat -ano | findstr 11434
# Linux
lsof -i :11434
# 杀掉占用进程，或修改 OLLAMA_HOST 换端口
export OLLAMA_HOST="127.0.0.1:11435"

curl: (7) Failed to connect to localhost port 11434: Connection refused

# 启动服务
ollama serve
# Linux systemd
sudo systemctl start ollama
# 确认服务运行后再请求
curl http://localhost:11434/api/version

Error: pull model manifest: Get "https://registry.ollama.ai/...": dial tcp: i/o timeout

export HTTPS_PROXY=http://127.0.0.1:7890
export HTTP_PROXY=http://127.0.0.1:7890
ollama pull deepseek-r1:7b

Error: model 'xxx' not found

# 先查看本地已有哪些模型
ollama list
# 确认官方模型库中的正确名称
ollama pull deepseek-r1:7b

# Linux：重新运行安装脚本
curl -fsSL https://ollama.com/install.sh | sh
# 确认二进制位置
which ollama
# 输出如 /usr/local/bin/ollama

                    ┌──────────────────────┐
   用户/前端  ────▶ │  反向代理 / 网关      │
                    │  (Nginx / API 网关)   │
                    └──────────┬───────────┘
                               │
                    ┌──────────▼───────────┐
                    │   Ollama 服务 (11434) │
                    └──────────────────────┘

# /etc/nginx/conf.d/ollama.conf
server {
    listen 80;
    server_name your-domain.com;
    # Basic Auth 认证
    auth_basic "Ollama Access";
    auth_basic_user_file /etc/nginx/.htpasswd;
    location / {
        proxy_pass http://127.0.0.1:11434;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_buffering off;   # 流式输出必须关闭缓冲
        proxy_read_timeout 300s;
    }
}

# 安装 htpasswd 工具
sudo apt install apache2-utils
# 创建用户和密码
sudo htpasswd -c /etc/nginx/.htpasswd admin

# -*- coding: utf-8 -*-
"""FastAPI 封装 Ollama 并做简易限流"""
import time
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests
app = FastAPI()
OLLAMA_URL = "http://localhost:11434"
# 简易令牌桶：每用户每分钟限制 N 次
RATE_LIMIT = {"window": 60, "max_requests": 10}
_user_records = {}
class ChatRequest(BaseModel):
    message: str
    model: str = "deepseek-r1:7b"
def check_rate_limit(user_id: str):
    """简易限流检查"""
    now = time.time()
    record = _user_records.get(user_id, [])
    # 清理过期记录
    record = [t for t in record if now - t < RATE_LIMIT["window"]]
    if len(record) >= RATE_LIMIT["max_requests"]:
        raise HTTPException(status_code=429, detail="请求过于频繁")
    record.append(now)
    _user_records[user_id] = record
@app.post("/chat")
def chat(req: ChatRequest, user_id: str = "anonymous"):
    check_rate_limit(user_id)
    payload = {
        "model": req.model,
        "messages": [{"role": "user", "content": req.message}],
        "stream": False,
    }
    resp = requests.post(f"{OLLAMA_URL}/api/chat", json=payload, timeout=300)
    resp.raise_for_status()
    return {"reply": resp.json()["message"]["content"]}
# 启动：uvicorn main:app --host 0.0.0.0 --port 8000

# 安装
# Windows: 官网安装包 / winget install Ollama.Ollama
# Linux:   curl -fsSL https://ollama.com/install.sh | sh
# macOS:   官网安装包 / brew install ollama
# 核心命令
ollama --version          # 版本
ollama pull <model>       # 拉取模型
ollama run <model>        # 运行并对话
ollama list               # 查看本地模型
ollama ps                 # 查看运行中模型
ollama show <model>       # 查看模型详情
ollama create -f Modelfile # 创建自定义模型
ollama rm <model>         # 删除模型
# API 调用
curl http://localhost:11434/api/version
curl http://localhost:11434/api/chat -d '{"model":"deepseek-r1:7b","messages":[{"role":"user","content":"你好"}],"stream":false}'

# 运行 Open WebUI（默认端口 3000）
docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

chat-service/
├── main.py          # FastAPI 服务入口
├── requirements.txt # 依赖
└── config.py        # 配置

fastapi==0.115.0
uvicorn==0.30.0
requests==2.32.0

# -*- coding: utf-8 -*-
"""服务配置"""
OLLAMA_BASE_URL = "http://localhost:11434"
DEFAULT_MODEL = "deepseek-r1:7b"
DEFAULT_TEMPERATURE = 0.7
MAX_CONTEXT_LEN = 4096

# -*- coding: utf-8 -*-
"""基于 FastAPI 的 DeepSeek 问答服务（流式 + 非流式）"""
import json
from typing import Optional
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field
import requests
from config import OLLAMA_BASE_URL, DEFAULT_MODEL, DEFAULT_TEMPERATURE
app = FastAPI(title="DeepSeek Chat Service", version="1.0.0")
class ChatMessage(BaseModel):
    role: str = Field(description="角色：system/user/assistant")
    content: str = Field(description="消息内容")
class ChatRequest(BaseModel):
    messages: list[ChatMessage]
    model: str = DEFAULT_MODEL
    temperature: float = DEFAULT_TEMPERATURE
    stream: bool = False
    max_tokens: Optional[int] = 512
@app.get("/health")
def health():
    """健康检查：确认 Ollama 服务是否可用"""
    try:
        resp = requests.get(f"{OLLAMA_BASE_URL}/api/version", timeout=5)
        resp.raise_for_status()
        return {"status": "ok", "ollama": resp.json()}
    except Exception as e:
        raise HTTPException(status_code=503, detail=f"Ollama 不可用: {e}")
@app.post("/v1/chat/completions")
def chat(req: ChatRequest):
    """对话接口，兼容 OpenAI 风格，支持流式输出"""
    payload = {
        "model": req.model,
        "messages": [m.model_dump() for m in req.messages],
        "stream": req.stream,
        "options": {
            "temperature": req.temperature,
            "num_predict": req.max_tokens,
        },
    }
    # 流式：使用 StreamingResponse 转发 SSE
    if req.stream:
        def event_stream():
            with requests.post(
                f"{OLLAMA_BASE_URL}/api/chat",
                json=payload,
                stream=True,
                timeout=300,
            ) as resp:
                resp.raise_for_status()
                for line in resp.iter_lines():
                    if not line:
                        continue
                    data = json.loads(line)
                    if data.get("done"):
                        yield "data: [DONE]\n\n"
                        break
                    content = data["message"]["content"]
                    yield f"data: {json.dumps({'content': content})}\n\n"
        return StreamingResponse(
            event_stream(),
            media_type="text/event-stream",
            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
        )
    # 非流式
    resp = requests.post(f"{OLLAMA_BASE_URL}/api/chat", json=payload, timeout=300)
    resp.raise_for_status()
    data = resp.json()
    return {
        "reply": data["message"]["content"],
        "usage": {"eval_count": data.get("eval_count", 0)},
    }
# 启动命令：
# uvicorn main:app --host 0.0.0.0 --port 8000

# 安装依赖
pip install -r requirements.txt
# 启动服务
uvicorn main:app --host 0.0.0.0 --port 8000
# 另开终端测试健康检查
curl http://localhost:8000/health
# 测试非流式对话
curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "messages": [{"role": "user", "content": "你好，介绍一下你自己"}],
  "stream": false
}'
# 测试流式对话
curl -N http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "messages": [{"role": "user", "content": "用三句话介绍 HTTP"}],
  "stream": true
}'

# 在有网络的机器上拉取模型
ollama pull deepseek-r1:7b
# 查看模型存储位置
# Linux/macOS: ~/.ollama/models
# Windows: %USERPROFILE%\.ollama\models

# 打包整个 models 目录（Linux 示例）
tar -czf deepseek-models.tar.gz ~/.ollama/models
# 拷贝到内网机器后解压
tar -xzf deepseek-models.tar.gz -C ~/.ollama
# 重启 Ollama 服务后即可使用
ollama list   # 应该能看到 deepseek-r1:7b

# 离线安装（手动解压二进制到 /usr/local/bin）
tar -C /usr -xzf ollama-linux-amd64.tgz
ollama serve &