不知道怎么回事，我的Ubuntu24.04经常时不时自动重启，这是让人难以接受的。不过一番寻找并没有找到这个重启是谁干的，所以并不能阻止它。但是每次还得我手动把服务开起来，这也太难受了，所以需要写一个脚本将服务在开机时自动开起来。一般来讲后台任务使用`screen`，开机自启动使用`systemd`是比较好的做法



# 启动screen的脚本
```sh
#!/bin/bash

# 定义一个函数来检查并创建 screen 会话
create_screen_if_not_exists() {
    local session_name="$1"
    local command="$2"
    
    # 检查 screen 会话是否存在
    if screen -list | grep -q "\.${session_name}\s"; then
        echo "Screen session '${session_name}' already exists. Skipping."
    else
        echo "Creating screen session '${session_name}'."
        screen -d -m -S "$session_name" bash -c "$command"
    fi
}

# 使用函数创建各个 screen 会话
create_screen_if_not_exists "<screen name>" '<command1 && command2 && ... && bash>'
...
```
`create_screen_if_not_exists`函数接受两个参数：名称和命令。命令可以有很多条，用`&&`连在一起。这里需要注意的是结尾的`&& bash`表示screen会话一直打开。如果希望执行命令后退出，则应使用`&& exit`

执行函数时会检查是否已经创建了screen，如果已经有了就不会执行相应的命令

写好脚本后需要赋予其可执行权限
```sh
chmod +x <path_to_the_script>
```

# 使用systemd管理开机自启动任务
首先创建systemd服务文件
```sh
sudo nano /etc/systemd/system/start-screens.service
```
其中`start-screens.service`是名字可以随意。如果没有`nano`可以装一个，然后输入
```ini
[Unit]
Description=<描述一下这个服务是干什么的>
After=network.target

[Service]
Type=oneshot
ExecStart=<要执行的脚本的路径>
RemainAfterExit=yes
User=<用户名>

[Install]
WantedBy=multi-user.target
```
其中`After=network.target`确保网络启动后再运行脚本（因为我这个脚本是为了启动网络服务）。按`Ctrl+S`保存文件，然后按`Ctrl+X`退出编辑

随后重新加载systemd配置
```sh
sudo systemctl daemon-reload
```

然后启用服务
```sh
sudo systemctl enable start-screens.service
```

可以执行下面的命令来执行一次脚本
```sh
sudo systemctl start start-screens.service
```

查看screen会话是否正常开启
```sh
screen -ls
```

使用systemd添加开机自启动screen后台任务

Gitea是一个安装便捷，轻量级的自建 Git 服务，通过Docker非常容易部署与迁移

本文参考自gitea的文档：[https://docs.gitea.com/zh-cn/](https://docs.gitea.com/zh-cn/)


# docker部署gitea
首先创建一个gitea的文件夹并进入
```sh
mkdir gitea-docker
cd gitea-docker
```
随后创建`docker-compose.yml`文件，并编辑之
```sh
touch docker-compose.yml
nano docker-compose.yml
```
编辑`docker-compose.yml`如下
```yml
version: "2"

services:
  server:
    image: docker.gitea.com/gitea:latest-rootless
    restart: always
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:2222"
```
按`Ctrl`+`S`保存，并按`Ctrl`+`X`退出编辑。随后创建两个文件夹`config`与`data`

```sh
mkdir config data
```
赋予它们权限
```sh
sudo chown 1000:1000 config/ data/
```
随后，启动容器
```
sudo docker-compose up -d
```

# nginx配置反向代理
如果将gitea配置到某个域名，应该如此配置nginx
```nginx
server {
    ...
    location / {
        client_max_body_size 512M;
        proxy_pass http://localhost:3000;
        proxy_set_header Connection $http_connection;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```
然后重启nginx
```sh
sudo nginx -s relaod
```

# nginx 将gitea反向代理到某个子路径
比如我想把gitea反向代理到`gbwater.icu/git`，那么首先应当编辑`config/app.ini`
```sh
nano config/app.ini
```
随后将`ROOT_URL`配置改为
```sh
ROOT_URL = https://gbwater.icu/git/
```
将nginx配置为
```nginx
server {
    ...
    location ~ ^/(gitea|v2)($|/) {
        client_max_body_size 512M;

        # 确保 nginx 使用未转义 URI， 按原样保持 "%2F"。 确保 nginx 去除 "/gitea" 子路径前缀， 按原样传递 "/v2"。
        rewrite ^ $request_uri;
        rewrite ^(/gitea)?(/.*) $2 break;
        proxy_pass http://127.0.0.1:3000$uri;

        # 其他的常规 HTTP 表头，见上面“使用 Nginx 作为反向代理服务”小节的配置
        proxy_set_header Connection $http_connection;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```
随后重启gitea与nginx
```sh
sudo docker stop gitea-docker-server-1
sudo docker-compose up -d
sudo nginx -s reload
```
这么做是不推荐的，已知的问题是，在本地使用git登录时会跳转到不带`/git/`的路径

私有代码库: 使用Docker部署Gitea

如果不清楚数据中到底包含几类，则聚类算法可以分为**层次聚类**和**密度聚类**。层次聚类不断将两类合并为一类，形成一棵聚类树，然后划分聚类树得到类别；密度聚类则按密度扩张类别，不形成聚类树。层次聚类可以自动进行，不需要人为设置参数；而密度聚类需要给定密度阈值参数，并且对不同密度的簇聚类效果不好

将层次聚类与密度聚类相结合就能得到HDBSCAN算法，它通过空间变换使得适应不同密度的簇，并且引入稳定度的概念自动划分聚类树，并获得对噪声的良好抵抗效果



# 空间变换：核心距离与互达距离

进行空间变换的目的是适应不同密度的簇。对于一个数据点，给定参数k，它的**核心距离**定义为

:::info{title="核心距离"}
一个样本点的核心距离是距离它最近的第k个样本点与它的距离
:::

如果取$k=5$，则核心距离的示意图如图（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

![image.png](/static/img/ab9d521015331991dc2a4837eef720b0.image.webp)

进一步，得到每个样本点的距离之后，就可以对距离矩阵（每两个样本点之间的距离）做变换，得到**互达距离**矩阵

:::info{title="互达距离"}
两个样本点的互达距离是以下三者的最大值
1. 它们之间的距离
2. 一个样本点的核心距离
3. 另一个样本点的核心距离
:::

如果取$k=5$，则互达距离的示意图如图（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

这种情况下互达距离是其中一个样本点的核心距离
![image.png](/static/img/ccad0e99e08c5f2ff453fb8bf869a85b.image.webp)

这种情况下互达距离是两个样本点的距离
![image.png](/static/img/6d5caf127251b77c33a1d4f1e490c24d.image.webp)


# 构造最小生成树，进行层次聚类

假定有一个二维样本点分布是这样的（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

![image.png](/static/img/b86c1051a3590eb5c808c5813ac628fa.image.webp)

记样本点数目为$n$，利用$n(n-1)/2$个互达距离作为边连接各个样本点形成一张图，在此图的基础上构造最小生成树。由于这是一个稠密图，利用Prim算法会取得较优的时间复杂度

构造得到的最小生成树如图（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

![image.png](/static/img/d45163b1d6d11fc50d30ddd031ea2626.image.webp)

这样就得到了连接$n$个样本点的$n-1$条边，任何一条边都可以将大树分为两棵子树，可以利用它们进行层次聚类

0. 初始化每一个样本点为一个初始簇
1. 取出长度最小的边，将两端的两个簇合并
2. 重复1，直到所有边都取出

这样，就得到了一颗聚类树（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

![image.png](/static/img/16c312804f44316e0ef1e4955acde2dc.image.webp)

图中每一个节点的高度代表合并它两个子簇的最小生成树的边的长度，它下面竖条的颜色代表它含有的样本点数目

# 稳定度与类选择

为了噪声过滤与选择类，定义一个参数：**最小簇大小**，不妨将其记为m。进行如下的噪声过滤过程

0. 初始考察根节点
1. 若当前节点所含的样本数目小于最小簇大小，将其标记为噪声，不再递归考察子节点，返回
2. 若当前节点的两个子节点存在一个小于最小簇大小，则将小的那个标记为噪声，考察大的子节点
3. 若两个子节点都大于最小簇大小，分别再考察两个子节点

这一步排除了所有的小簇，下一步是分配类标签

0. 为根节点分配类标签，考察根节点
1. 若当前节点是噪声，则认为它从属的类在此时消亡，不再递归考察，返回
2. 若两个子节点都不是噪声，则认为分裂有效，为两个子节点分别分配新的类标签，并考察两个子节点。认为当前节点从属的类在此时消亡，两个新的类在此时诞生
3. 若两个子节点存在一个是噪声，则另一个子节点继承当前节点的类标签，递归考察它

做完这一步后，就从聚类树得到了一颗类树（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）

![image.png](/static/img/cd2124dff56b10d6b150ef5665d646e1.image.webp)

从根类开始，类不断分裂为两个子类，直到消亡。至于左侧的 $\lambda$ 是什么，这就需要定义**生命周期**

定义一个聚类树中节点$\lambda$值为
$$
\lambda=\dfrac1{distance}
$$

其中$distance$是层级聚类过程中合并产生该节点的边的长度。$\lambda$可以看作时间，$\lambda$增大的过程看作是时间的演化。那么类树的分裂就可以看作是：随着时间的演化，不断有样本从大类中剥离，大类不断分裂为子类。由此定义类的生命周期

- $\lambda_{birth}$: 父类分裂诞生两个新类，分裂处节点的 $\lambda$ 值
- $\lambda_{death}$: 类消亡，消亡处节点的 $\lambda$ 值

对于一个类，对于它的包含的某个样本$p$，可以定义$\lambda_p$：在某个节点处，样本$p$被剥离出父类，该节点的$\lambda$值即为$\lambda_p$

随后，对于任意类$S$，可以计算它的稳定度
$$
stability=\sum_{p\in S} (\lambda_p-\lambda_{birth})
$$
直观上来看，一个类的稳定度就是类树中它下面的那一长条的面积。自然，稳定度越大的类是越好的，所以有这样的类选择规则

:::info{title="类选择规则"}
将所有叶子类设置为选择，自下而上地考察父类
- 若父类的稳定度小于两个子类的稳定度之和，那么不选择父类，并把父类的稳定度设置为两个子类的稳定度之和
- 若父类的稳定度大于两个子类的稳定度之和，则将父类设置为选择，将所有的子类设置为不选择
:::

这样，就从类树中选择了一系列的类（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）
![image.png](/static/img/eeff157f1410522403ac7c9f99be7a0d.image.webp)

最终的聚类结构就是（图源[hdbscan.readthedocs.io](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)）
![image.png](/static/img/cc7418f0dbdcaafd1ca272dfd1013205.image.webp)

HDBSCAN聚类算法

# searxng部署
首先需要克隆`searxng`的仓库
```bash
git clone https://github.com/searxng/searxng-docker.git
```
随后进入
```bash
cd searxng-docker
```



随后编辑`docker-compose.yaml`，将其中的`ports`部分替换为`0.0.0.0`，编辑好的文件应当是这样的

注意此处使用了[毫秒镜像](https://1ms.run/)提供的docker镜像服务
```yaml
version: "3.7"

services:
  redis:
    container_name: redis
    image: docker.1ms.run/valkey/valkey:8-alpine
    command: valkey-server --save 30 1 --loglevel warning
    restart: unless-stopped
    networks:
      - searxng
    volumes:
      - valkey-data2:/data
    cap_drop:
      - ALL
    cap_add:
      - SETGID
      - SETUID
      - DAC_OVERRIDE
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

  searxng:
    container_name: searxng
    image: docker.1ms.run/searxng/searxng:latest
    restart: unless-stopped
    networks:
      - searxng
    ports:
      - "0.0.0.0:8080:8080"
    volumes:
      - ./searxng:/etc/searxng:rw
    environment:
      - SEARXNG_BASE_URL=https://${SEARXNG_HOSTNAME:-localhost}/
      - UWSGI_WORKERS=${SEARXNG_UWSGI_WORKERS:-4}
      - UWSGI_THREADS=${SEARXNG_UWSGI_THREADS:-4}
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
      - DAC_OVERRIDE
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

networks:
  searxng:

volumes:
  caddy-data:
  caddy-config:
  valkey-data2:
```
然后在`.env`文件中增加一行配置url，注意该文件是隐藏的
```env
SEARXNG_HOSTNAME=localhost:8080/
```
随后编辑`searxng`文件夹下的`settings.yml`，在终端中进入`searxng`文件夹
```bash
cd searxng
```
随后创建一个密钥（命令来自于[Kaku的个人博客](https://www.kakunet.top/2024/12/04/SearchXNG%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97/)）
```bash
sed -i "s|ultrasecretkey|$(openssl rand -hex 32)|g" searxng/settings.yml
```
然后编辑`settings.yml`，使它应当是这个样子，这个配置只启用了必应搜索引擎
```yml
# see https://docs.searxng.org/admin/settings/settings.html#settings-use-default-settings
use_default_settings:
  engines:
    keep_only:
      - bing
server:
  # base_url is defined in the SEARXNG_BASE_URL environment variable, see .env and docker-compose.yml
  secret_key: "<这一行不要动>"  # change this!
  limiter: false  # can be disabled for a private instance
  image_proxy: true
ui:
  static_use_hash: true
redis:
  url: redis://redis:6379/0
search:
  formats:
    - html
    - json
engines:
  - name: bing
    disabled: false
```

使用`docker compose`命令启动容器
```
sudo docker compose up -d
```
这里目的是创建容器，创建成功后它是运行不起来的，把他关闭
```
sudo docker stop searxng
```
创建一个`uwsgi.ini`文件
```
touch uwsgi.ini
```
编辑它，内容为
```ini

[uwsgi]
# Who will run the code
uid = searxng
gid = searxng

# Number of workers (usually CPU count)
workers = %k
threads = 4

# The right granted on the created socket
chmod-socket = 666

# Plugin to use and interpreter config
single-interpreter = true
master = true
plugin = python3
lazy-apps = true
enable-threads = 4

# Module to import
module = searx.webapp

# Virtualenv and python path
pythonpath = /usr/local/searxng/
chdir = /usr/local/searxng/searx/

# automatically set processes name to something meaningful
auto-procname = true

# Disable request logging for privacy
disable-logging = true
log-5xx = true

# Set the max size of a request (request-body excluded)
buffer-size = 8192

# No keep alive
# See https://github.com/searx/searx-docker/issues/24
add-header = Connection: close

# uwsgi serves the static files
# expires set to one year since there are hashes
static-map = /static=/usr/local/searxng/searx/static
static-expires = /* 31557600
static-gzip-all = True
offload-threads = 4

# Cache
cache2 = name=searxngcache,items=2000,blocks=2000,blocksize=4096,bitmap=1
```

将它复制到docker容器内
```bash
sudo docker cp uwsgi.ini searxng:/etc/uwsgi
```
然后重新启动docker容器
```
sudo docker compose up -d
```
searxng 服务就运行成功了

# 在open-webui中连接searxng
来到管理员面版，转到`设置-联网搜索`，启用它，并选择联网搜索引擎为`searxng`

![image.png](/static/img/548b93ad93e80480bed488608f507914.image.webp)

将`Searxng搜索URL`设置为
```url
http://172.17.0.1:8080/search?safesearch=0&q=<query>&safesearch=0
```
其中的`172.17.0.1`是docker容器宿主机的默认IP地址。点击`保存`按钮后，转到`设置-界面`

![image.png](/static/img/1e71acc73fd83918e1c7b6c102366bf3.image.webp)

将这里的`外部模型`改为除了R1之外的其他模型。这个模型是用于生成搜索关键词的，生成速度需要比较快，所以R1是不合适的。这里选用了硅基流动的免费小模型，速度快还不收钱，任君选择

![image.png](/static/img/5556df34a0abad34046db0ea4f44d17d.image.webp)

再点击右下角的`保存`按钮，联网搜索就配置完成了。在主界面点亮`联网搜索`即可启用

![image.png](/static/img/8950e49de032f9d462a208a6291f11b2.image.webp)

部署searxng以启用open-webui的联网搜索

# 通过Docker安装open-webui
用Docker安装只需要一行命令
```bash
docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
```
其中的`3000`可以改成任何不冲突的端口



由于是部署在服务器上的，服务器自然没有浏览器，因此需要配置`nginx`启用反向代理，然后用浏览器访问
```nginx
server {
    listen 443 ssl;
    server_name <域名>;

    # SSL 证书配置（请确认证书包含子域名）
    ssl_certificate <SSL证书地址>;
    ssl_certificate_key <SSL私钥地址>;

    # SSL 安全配置
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers off;

    # 反向代理设置
    location / {
        proxy_pass http://127.0.0.1:<端口号，按照上文设置的话是3000>;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket支持
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';

        # 超时设置（可选）
        proxy_connect_timeout 6000s;
        proxy_send_timeout 6000s;
        proxy_read_timeout 6000s;
    }
}
```
随后访问`https://<上面设置的域名>`即可访问面板，初次使用需要注册，第一个账号自动成为管理员账户

需要注意的是，初次登录会存在“OI”结束后白屏的情况，这是因为默认的OpenAI API与LLama API处于开启状态。这时不能气馁，多次刷新页面，有小概率能成功进入。进入后来到管理员面版

![image.png](/static/img/89c8757cba20d540c2a663214cb64fa7.image.webp)

来到`设置-外部链接`，将两个API的按钮都关掉即可正常登录（这里打开是因为后面部署了模型）

![image.png](/static/img/31ada4bf5ffa8761439371aea8cb14a6.image.webp)

# 使用API访问DeepSeek R1
首先需要拿到一个API和密钥，此处不妨使用硅基流动的服务：[跳转硅基流动账户注册](https://cloud.siliconflow.cn/i/FngeZEAX)

使用我的邀请码`FngeZEAX`注册后可以获得14元的免费额度。注册完成后来到`API密钥`页面，点击新建密钥

![image.png](/static/img/ce82e0d7842f8cd1946f8f6fca1e8e7c.image.webp)

复制密钥，然后回到open-webui的管理员页面，转到`函数`，然后新建函数

![image.png](/static/img/d17ceea0d89da6e9fb0ae0f73ecdfb63.image.webp)

编辑函数文件（来自[open-webui社区](https://openwebui.com/f/zgccrui/deepseek_r1)）
```python
"""
title: DeepSeek R1
author: zgccrui
description: 在OpwenWebUI中显示DeepSeek R1模型的思维链 - 仅支持0.5.6及以上版本
version: 1.2.6
licence: MIT
"""

import json
import httpx
import re
from typing import AsyncGenerator, Callable, Awaitable
from pydantic import BaseModel, Field
import asyncio


class Pipe:
    class Valves(BaseModel):
        DEEPSEEK_API_BASE_URL: str = Field(
            default="https://api.siliconflow.cn/v1",
            description="DeepSeek API的基础请求地址",
        )
        DEEPSEEK_API_KEY: str = Field(
            default="<刚刚注册的API密钥>",
            description="用于身份验证的DeepSeek API密钥，可从控制台获取",
        )
        DEEPSEEK_API_MODEL: str = Field(
            default="deepseek-ai/DeepSeek-R1",
            description="API请求的模型名称，默认为 deepseek-reasoner ",
        )

    def __init__(self):
        self.valves = self.Valves()
        self.data_prefix = "data: "
        self.thinking = -1  # -1:未开始 0:思考中 1:已回答
        self.emitter = None

    def pipes(self):
        return [
            {
                "id": self.valves.DEEPSEEK_API_MODEL,
                "name": self.valves.DEEPSEEK_API_MODEL,
            }
        ]

    async def pipe(
        self, body: dict, __event_emitter__: Callable[[dict], Awaitable[None]] = None
    ) -> AsyncGenerator[str, None]:
        """主处理管道（已移除缓冲）"""
        self.thinking = -1
        self.emitter = __event_emitter__

        # 验证配置
        if not self.valves.DEEPSEEK_API_KEY:
            yield json.dumps({"error": "未配置API密钥"}, ensure_ascii=False)
            return

        # 准备请求参数
        headers = {
            "Authorization": f"Bearer {self.valves.DEEPSEEK_API_KEY}",
            "Content-Type": "application/json",
        }

        try:
            # 模型ID提取
            model_id = body["model"].split(".", 1)[-1]
            payload = {**body, "model": model_id}

            # 处理消息以防止连续的相同角色
            messages = payload["messages"]
            i = 0
            while i < len(messages) - 1:
                if messages[i]["role"] == messages[i + 1]["role"]:
                    # 插入具有替代角色的占位符消息
                    alternate_role = (
                        "assistant" if messages[i]["role"] == "user" else "user"
                    )
                    messages.insert(
                        i + 1,
                        {"role": alternate_role, "content": "[Unfinished thinking]"},
                    )
                i += 1

            # yield json.dumps(payload, ensure_ascii=False)

            # 发起API请求
            async with httpx.AsyncClient(http2=True) as client:
                async with client.stream(
                    "POST",
                    f"{self.valves.DEEPSEEK_API_BASE_URL}/chat/completions",
                    json=payload,
                    headers=headers,
                    timeout=300,
                ) as response:
                    # 错误处理
                    if response.status_code != 200:
                        error = await response.aread()
                        yield self._format_error(response.status_code, error)
                        return

                    # 流式处理响应
                    async for line in response.aiter_lines():
                        if not line.startswith(self.data_prefix):
                            continue

                        # 截取 JSON 字符串
                        json_str = line[len(self.data_prefix) :]

                        try:
                            data = json.loads(json_str)
                        except json.JSONDecodeError as e:
                            # 格式化错误信息，这里传入错误类型和详细原因（包括出错内容和异常信息）
                            error_detail = f"解析失败 - 内容：{json_str}，原因：{e}"
                            yield self._format_error("JSONDecodeError", error_detail)
                            return

                        choice = data.get("choices", [{}])[0]

                        # 结束条件判断
                        if choice.get("finish_reason"):
                            return

                        # 状态机处理
                        state_output = await self._update_thinking_state(
                            choice.get("delta", {})
                        )
                        if state_output:
                            yield state_output  # 直接发送状态标记
                            if state_output == "<think>":
                                yield "\n"

                        # 内容处理并立即发送
                        content = self._process_content(choice["delta"])
                        if content:
                            if content.startswith("<think>"):
                                match = re.match(r"^<think>", content)
                                if match:
                                    content = re.sub(r"^<think>", "", content)
                                    yield "<think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"

                            elif content.startswith("</think>"):
                                match = re.match(r"^</think>", content)
                                if match:
                                    content = re.sub(r"^</think>", "", content)
                                    yield "</think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"
                            yield content

        except Exception as e:
            yield self._format_exception(e)

    async def _update_thinking_state(self, delta: dict) -> str:
        """更新思考状态机（简化版）"""
        state_output = ""

        # 状态转换：未开始 -> 思考中
        if self.thinking == -1 and delta.get("reasoning_content"):
            self.thinking = 0
            state_output = "<think>"

        # 状态转换：思考中 -> 已回答
        elif (
            self.thinking == 0
            and not delta.get("reasoning_content")
            and delta.get("content")
        ):
            self.thinking = 1
            state_output = "\n</think>\n\n"

        return state_output

    def _process_content(self, delta: dict) -> str:
        """直接返回处理后的内容"""
        return delta.get("reasoning_content", "") or delta.get("content", "")

    def _format_error(self, status_code: int, error: bytes) -> str:
        """错误格式化保持不变"""
        try:
            err_msg = json.loads(error).get("message", error.decode(errors="ignore"))[
                :200
            ]
        except:
            err_msg = error.decode(errors="ignore")[:200]
        return json.dumps(
            {"error": f"HTTP {status_code}: {err_msg}"}, ensure_ascii=False
        )

    def _format_exception(self, e: Exception) -> str:
        """异常格式化保持不变"""
        err_type = type(e).__name__
        return json.dumps({"error": f"{err_type}: {str(e)}"}, ensure_ascii=False)
```

需要将`<刚刚注册的API密钥>`替换为刚刚注册的API密钥，然后点击`保存`，并启用函数

![image.png](/static/img/16a2ccefde3166be47d4e5328f800441.image.webp)

随后DeepSeek-R1就自动出现在`模型`页面中了，退出管理员面板即可与其正常对话