DeepSeek Ollama部署实战教程介绍

1

2

3

4

5

6

# 1. 下载并运行模型（一行命令搞定下载 + 运行）

ollama run deepseek-r1:7b

# 2. 查看本地已有模型

ollama list

# 3. 通过 REST API 调用

curl http://localhost:11434/api/generate -d '{"model":"deepseek-r1:7b","prompt":"你好"}'

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

┌─────────────────────────────────────────────┐

│                 你的应用程序                    │

│   (curl / Python / LangChain / WebUI ...)    │

└──────────────────┬──────────────────────────┘

                   │ HTTP / REST  (默认端口 11434)

┌──────────────────▼──────────────────────────┐

│          Ollama 本地服务 (ollama serve)        │

│     - 模型管理、并发调度、上下文缓存             │

└──────────────────┬──────────────────────────┘

                   │

┌──────────────────▼──────────────────────────┐

│        模型运行时 (基于 llama.cpp)             │

│     - GGUF 权重加载 / 量化推理                  │

│     - GPU 加速 (CUDA/ROCm/Metal) 或 CPU       │

└─────────────────────────────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

第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 部署

1

2

# 查看版本号

ollama --version

1

ollama version is 0.x.x

1

2

# 使用 winget 安装

winget install Ollama.Ollama

1

2

# Ubuntu / Debian / CentOS 等通用

curl -fsSL https://ollama.com/install.sh | sh

1

2

3

4

# 查看版本

ollama --version

# 查看服务状态（systemd 方式）

systemctl status ollama

1

2

3

4

# 启动 ollama 服务

sudo systemctl start ollama

# 设置开机自启

sudo systemctl enable ollama

1

2

3

4

5

6

# 以下载 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

1

brew install ollama

1

2

3

4

5

# 1. 确认版本

ollama --version

# 2. 确认服务运行（Windows 下服务已自动运行；Linux/macOS 需确保 ollama serve 在跑）

# 直接请求本地 API 测试

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

1

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

1

2

3

# PowerShell 中临时设置（当前会话有效）

$env:OLLAMA_MODELS = "D:\ollama\models"

# 永久设置：系统设置 -> 高级系统设置 -> 环境变量 -> 新建

1

2

3

4

5

# 临时设置

export OLLAMA_HOST="0.0.0.0:11434"

# 永久设置（写入用户配置文件）

echo 'export OLLAMA_HOST="0.0.0.0:11434"' >> ~/.bashrc

source ~/.bashrc

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

# 查看帮助

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

1

ollama pull deepseek-r1:7b

1

2

3

4

5

pulling manifest

pulling 6f1dc39c72f5... 100% ████████████████████████ 4.7 GB

verifying sha256 digest

writing manifest

success

1

2

3

# Linux/macOS

export HTTPS_PROXY=http://127.0.0.1:7890

ollama pull deepseek-r1:7b

1

ollama list

1

2

NAME                ID              SIZE    MODIFIED

deepseek-r1:7b      0a8c26691023    4.7 GB  2 minutes ago

1

ollama show deepseek-r1:7b

1

2

3

4

5

6

7

8

9

10

11

12

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

  ...

1

ollama rm deepseek-r1:7b

1

ollama ps

1

2

NAME              ID       PROCESSOR   UNTIL                MODEL      SIZE   CPU  GPU

deepseek-r1:7b    ...     100% GPU    4 minutes from now   7.6B       4.7GB  0%   4.7GB

1

ollama run deepseek-r1:7b

1

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

1

2

3

4

5

<think>

用户询问我的身份，需要简洁介绍 DeepSeek 模型的基本信息...

</think>

你好！我是 DeepSeek，一个由深度求索公司开发的开源大语言模型。

我可以帮助你回答问题、编写代码、进行推理分析等。有什么可以帮你的？

1

2

3

>>> /set parameter temperature 0.3

Set parameter temperature to 0.3

>>> /bye

1

2

3

4

# 直接提问

ollama run deepseek-r1:7b "用 Python 写一个冒泡排序"

# 一次问答并输出流式结果

ollama run deepseek-r1:7b "1 + 1 等于多少？"

1

2

3

4

5

6

7

#!/bin/bash

# 批量测试模型

for question in "你好" "什么是大模型" "写一段 Hello World"; do

  echo "问题：$question"

  ollama run deepseek-r1:7b "$question"

  echo "=========================="

done

1

2

3

>>> 我今年 28 岁

>>> 根据刚才的信息，我多大了？

根据你刚才提到的信息，你今年 28 岁。

1

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

1

2

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

Set system message.

1

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

1

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

1

2

3

4

5

curl http://localhost:11434/api/generate -d '{

  "model": "deepseek-r1:7b",

  "prompt": "请用一句话介绍什么是大语言模型",

  "stream": false

}'

1

2

3

4

5

6

7

8

9

{

  "model": "deepseek-r1:7b",

  "created_at": "2026-09-03T10:00:00.000Z",

  "response": "大语言模型是一种基于深度学习、在海量文本上训练的模型，能够理解和生成自然语言。",

  "done": true,

  "total_duration": 1234567890,

  "eval_count": 32,

  "eval_duration": 987654321

}

1

2

3

4

5

curl http://localhost:11434/api/generate -d '{

  "model": "deepseek-r1:7b",

  "prompt": "写一首关于秋天的五言绝句",

  "stream": true

}'

1

2

3

4

5

{"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":...}

1

2

3

4

5

6

7

8

9

10

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

}'

1

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

1

2

3

4

5

6

7

8

9

10

11

12

13

{

  "models": [

    {

      "name": "deepseek-r1:7b",

      "model": "deepseek-r1:7b",

      "size": 4989797124,

      "details": {

        "parameter_size": "7.6B",

        "quantization_level": "Q4_K_M"

      }

    }

  ]

}

1

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

1

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

1

2

3

4

5

6

7

# 拉取一个嵌入模型

ollama pull nomic-embed-text

# 生成嵌入向量

curl http://localhost:11434/api/embed -d '{

  "model": "nomic-embed-text",

  "input": "今天天气真不错"

}'

1

python --version

1

2

3

4

5

6

7

8

# 基础 HTTP 请求库（一般已内置）

pip install requests

# Ollama 官方 Python 库

pip install ollama

# OpenAI 兼容 SDK

pip install openai

# LangChain 框架

pip install langchain-ollama

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

# -*- 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)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

# -*- 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生成完成。")

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

# -*- 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))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

# -*- 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()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

# -*- 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()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

# -*- 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)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

# -*- 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())

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

# 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>"

1

2

# 在当前目录执行

ollama create my-deepseek-coder -f ./Modelfile

1

2

3

NAME                    ID       SIZE   MODIFIED

my-deepseek-coder       ...      4.7GB  1 second ago

deepseek-r1:7b          ...      4.7GB  3 minutes ago

1

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

1

2

3

4

5

6

7

8

FROM deepseek-r1:7b

SYSTEM """你是XX公司的智能客服小助手。

- 只回答与XX公司产品、服务相关的问题；

- 遇到不确定的问题，礼貌地告知用户会转接人工客服；

- 语气亲切、专业；

- 回复控制在200字以内。"""

PARAMETER temperature 0.5

PARAMETER num_ctx 4096

1

2

ollama create support-assistant -f ./Modelfile

ollama run support-assistant

1

2

3

# 使用本地 GGUF 文件

FROM ./deepseek-r1-7b.Q4_K_M.gguf

PARAMETER temperature 0.7

1

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

1

2

# PowerShell 临时设置

$env:OLLAMA_HOST = "0.0.0.0:11434"

1

2

3

4

# 设置监听所有网卡

export OLLAMA_HOST="0.0.0.0:11434"

# 如果是 systemd 服务，编辑服务配置

sudo systemctl edit ollama

1

2

[Service]

Environment="OLLAMA_HOST=0.0.0.0:11434"

1

2

sudo systemctl daemon-reload

sudo systemctl restart ollama

1

2

# 允许所有来源（仅限可信环境）

export OLLAMA_ORIGINS="*"

1

2

sudo ufw allow 11434/tcp

sudo ufw reload

1

2

3

4

5

6

7

# 在另一台电脑上执行（把 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

}'

1

2

3

4

5

from openai import OpenAI

client = OpenAI(

    base_url="http://192.168.1.100:11434/v1",

    api_key="ollama",

)

1

2

# Modelfile 中设置

PARAMETER num_ctx 8192

1

2

3

4

5

6

# API 中设置

payload = {

    "model": "deepseek-r1:7b",

    "prompt": "你好",

    "options": {"num_ctx": 8192},

}

1

2

3

4

5

6

# 允许同时加载的模型数量

export OLLAMA_MAX_LOADED_MODELS=2

# 模型保持加载的时间（空闲多久后卸载），5m 表示 5 分钟

export OLLAMA_KEEP_ALIVE=5m

# 每个模型的并发请求数量

export OLLAMA_NUM_PARALLEL=4

1

2

3

4

# 拉取 Q4_K_M 版本（默认）

ollama pull deepseek-r1:7b

# 拉取 Q5 版本（需要该 tag 存在于模型库）

ollama pull deepseek-r1:7b-q5_K_M

1

2

NAME              ID       PROCESSOR   UNTIL                MODEL   SIZE   GPU

deepseek-r1:7b    ...     100% GPU     ...                 7.6B    4.7GB  4.7GB

1

2

3

4

# 查看 GPU 型号和显存

nvidia-smi

# 查看 CUDA 版本

nvcc --version

1

2

export OLLAMA_DEBUG=1

ollama serve

1

2

3

4

# 拉取 Ollama 官方镜像

docker pull ollama/ollama

# 运行容器并映射端口（CPU 模式）

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

1

2

3

4

5

6

7

8

9

10

# 进入容器执行拉取

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

}'

1

2

3

4

5

6

# 使用 GPU 运行容器

docker run -d --gpus all \

  -v ollama:/root/.ollama \

  -p 11434:11434 \

  --name ollama \

  ollama/ollama

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

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:

1

docker compose up -d

1

Error: could not locate cudart

1

2

3

4

5

# 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

1

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

1

bind: address already in use

1

2

3

4

5

6

7

# 查看占用端口的进程

# Windows

netstat -ano | findstr 11434

# Linux

lsof -i :11434

# 杀掉占用进程，或修改 OLLAMA_HOST 换端口

export OLLAMA_HOST="127.0.0.1:11435"

1

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

1

2

3

4

5

6

# 启动服务

ollama serve

# Linux systemd

sudo systemctl start ollama

# 确认服务运行后再请求

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

1

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

1

2

3

export HTTPS_PROXY=http://127.0.0.1:7890

export HTTP_PROXY=http://127.0.0.1:7890

ollama pull deepseek-r1:7b

1

Error: model 'xxx' not found

1

2

3

4

# 先查看本地已有哪些模型

ollama list

# 确认官方模型库中的正确名称

ollama pull deepseek-r1:7b

1

2

3

4

5

# Linux：重新运行安装脚本

curl -fsSL https://ollama.com/install.sh | sh

# 确认二进制位置

which ollama

# 输出如 /usr/local/bin/ollama

1

2

3

4

5

6

7

8

                 ┌──────────────────────┐

用户/前端  ────? │  反向代理 / 网关      │

                 │  (Nginx / API 网关)   │

                 └──────────┬───────────┘

                            │

                 ┌──────────▼───────────┐

                 │   Ollama 服务 (11434) │

                 └──────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

# /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;

    }

}

1

2

3

4

# 安装 htpasswd 工具

sudo apt install apache2-utils

# 创建用户和密码

sudo htpasswd -c /etc/nginx/.htpasswd admin

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

# -*- 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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# 安装

# 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}'

1

2

3

4

5

6

7

8

# 运行 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

1

2

3

4

chat-service/

├── main.py          # FastAPI 服务入口

├── requirements.txt # 依赖

└── config.py        # 配置

1

2

3

fastapi==0.115.0

uvicorn==0.30.0

requests==2.32.0

1

2

3

4

5

6

# -*- coding: utf-8 -*-

"""服务配置"""

OLLAMA_BASE_URL = "http://localhost:11434"

DEFAULT_MODEL = "deepseek-r1:7b"

DEFAULT_TEMPERATURE = 0.7

MAX_CONTEXT_LEN = 4096

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

# -*- 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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# 安装依赖

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

}'

1

2

3

4

5

# 在有网络的机器上拉取模型

ollama pull deepseek-r1:7b

# 查看模型存储位置

# Linux/macOS: ~/.ollama/models

# Windows: %USERPROFILE%\.ollama\models

1

2

3

4

5

6

# 打包整个 models 目录（Linux 示例）

tar -czf deepseek-models.tar.gz ~/.ollama/models

# 拷贝到内网机器后解压

tar -xzf deepseek-models.tar.gz -C ~/.ollama

# 重启 Ollama 服务后即可使用

ollama list   # 应该能看到 deepseek-r1:7b

1

2

3

# 离线安装（手动解压二进制到 /usr/local/bin）

tar -C /usr -xzf ollama-linux-amd64.tgz

ollama serve &