init

.env.example

@@ -0,0 +1,42 @@
+# 客户端请求时允许通过请求的 API KEY，无需在当前环境变量当中手动添加 Bearer，目前只支持一个，未来可以升级为数组/toml/yaml 或专门的管理工具
+ALLOW_API_KEY=your_api_key 
+
+# 服务端跨域配置
+# 允许访问的域名，多个域名使用逗号分隔(中间不能有空格)，例如：http://localhost:3000,https://chat.example.com
+# 如果允许所有域名访问，则填写 *
+ALLOW_ORIGINS=*
+
+# DeepSeek API KEY，默认为 DeepSeek 官方 API，只支持 r1 系列模型（包括基于 llama 和 qwen 的密集模型，1.5b、7b、8b、14b、32b、70b、671b）
+# 除了采用官网的 DeepSeek r1 外，还推荐以下：
+# 1.SiliconFlow 的 deepseek-ai/DeepSeek-R1 获取 API KEY 的链接：https://cloud.siliconflow.cn/i/RXikvHE2 (点击此链接可以获得到 2000 万免费 tokens)
+# 2.Groq 托管的 deepseek-r1-distill-llama-70b 获取 API KEY 的链接：https://console.groq.com/docs/models
+# 3.本地 Ollama 运行的 DeepSeek r1 , 可以根据自己电脑的内存和显存大小而定，推荐 7b、8b、14b 最佳，获取链接：https://ollama.com
+DEEPSEEK_API_KEY=your_deepseek_api_key
+DEEPSEEK_API_URL=https://api.deepseek.com/v1/chat/completions #如果是siliconflow，则使用 https://api.siliconflow.cn/v1/chat/completions
+DEEPSEEK_MODEL=deepseek-reasoner #如果是siliconflow，则使用 deepseek-ai/DeepSeek-R1
+
+# DeepSeek推理过程格式配置
+# 该变量用于区别返回体中推理过程的格式
+# 目前支持两种格式：
+# 1. Origin_Reasoning (支持 reasoning_content 字段返回) (DeepSeek官方 deepseek-reasoner 模型、 SiliconFlow 的 deepseek-ai/DeepSeek-R1 模型、火山云的 DeepSeek R1 模型均支持)
+# 2. <think></think> 标签格式（通常是通过 deepseek r1 蒸馏过的模型采用这种格式，包括各个平台托管的基于 llama 和 qwen 的密集模型，比如 7b、8b、14b、32b、70b 的版本）
+# 填写true表示使用 Origin_Reasoning 格式，填写false表示使用 <think></think> 标签格式
+IS_ORIGIN_REASONING=true
+
+# Claude API KEY，默认为 Claude 官方 API，只推荐 Claude 3.5 Sonnet 模型，不推荐其他模型
+CLAUDE_API_KEY=your_claude_api_key
+CLAUDE_MODEL=claude-3-5-sonnet-20241022
+
+# Claude Provider
+# 若使用官方则填 anthropic
+# 若使用中转平台如 OpenRouter 或国内基于 OneAPI 的中转平台则填oneapi
+CLAUDE_PROVIDER=anthropic
+
+# 如果使用 OpenRouter，这里填写 OpenRouter 的 API URL https://openrouter.ai/api/v1/chat/completions, 
+# 如果使用中转平台则填写相应的 API URL: 例如 https://api.oneapi.com/v1/chat/completions
+# 默认为 Anthropic 的 API URL https://api.anthropic.com/v1/messages
+CLAUDE_API_URL=https://api.anthropic.com/v1/messages
+
+# 日志配置
+# 可选值：DEBUG, INFO, WARNING, ERROR, CRITICAL
+LOG_LEVEL=INFO

.github/workflows/docker-build.yml

@@ -0,0 +1,61 @@
+name: Docker Build
+
+on:
+  push:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  check-repository:
+    runs-on: ubuntu-latest
+    outputs:
+      is_original: ${{ steps.check.outputs.is_original }}
+    steps:
+      - id: check
+        run: |
+          if [ "${{ github.repository }}" = "ErlichLiu/DeepClaude" ]; then
+            echo "is_original=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_original=false" >> $GITHUB_OUTPUT
+          fi
+
+  build:
+    needs: check-repository
+    if: needs.check-repository.outputs.is_original == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set lowercase variables
+        run: |
+          OWNER_LOWER=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
+          REPO_NAME_LOWER=$(echo "${{ github.event.repository.name }}" | tr '[:upper:]' '[:lower:]')
+          echo "OWNER_LOWER=$OWNER_LOWER" >> $GITHUB_ENV
+          echo "REPO_NAME_LOWER=$REPO_NAME_LOWER" >> $GITHUB_ENV
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            ghcr.io/${{ env.OWNER_LOWER }}/${{ env.REPO_NAME_LOWER }}:latest
+            ghcr.io/${{ env.OWNER_LOWER }}/${{ env.REPO_NAME_LOWER }}:${{ github.sha }}

.github/workflows/security-scan.yml

@@ -0,0 +1,43 @@
+name: Security Scan
+
+on:
+  schedule:
+    - cron: '0 0 * * 0'  # 每周运行一次
+  workflow_dispatch:
+
+jobs:
+  check-repository:
+    runs-on: ubuntu-latest
+    outputs:
+      is_original: ${{ steps.check.outputs.is_original }}
+    steps:
+      - id: check
+        run: |
+          if [ "${{ github.repository }}" = "ErlichLiu/DeepClaude" ]; then
+            echo "is_original=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_original=false" >> $GITHUB_OUTPUT
+          fi
+
+  scan:
+    needs: check-repository
+    if: needs.check-repository.outputs.is_original == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set lowercase variables
+        run: |
+          OWNER_LOWER=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
+          REPO_NAME_LOWER=$(echo "${{ github.event.repository.name }}" | tr '[:upper:]' '[:lower:]')
+          echo "OWNER_LOWER=$OWNER_LOWER" >> $GITHUB_ENV
+          echo "REPO_NAME_LOWER=$REPO_NAME_LOWER" >> $GITHUB_ENV
+
+      - name: Run Trivy vulnerability scanner
+        uses: aquasecurity/trivy-action@master
+        with:
+          image-ref: ghcr.io/${{ env.OWNER_LOWER }}/${{ env.REPO_NAME_LOWER }}:latest
+          format: 'table'
+          exit-code: '1'
+          ignore-unfixed: true
+          severity: 'CRITICAL'

.github/workflows/sync.yml

@@ -0,0 +1,60 @@
+name: Upstream Sync
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  # 检查是否为 fork 仓库
+  check-repository:
+    name: Check Repository Type
+    runs-on: ubuntu-latest
+    outputs:
+      is_fork: ${{ steps.check.outputs.is_fork }}
+    steps:
+      - id: check
+        run: |
+          if [ "${{ github.repository }}" != "ErlichLiu/DeepClaude" ]; then
+            echo "is_fork=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_fork=false" >> $GITHUB_OUTPUT
+          fi
+
+  # 同步上游更改
+  sync:
+    needs: check-repository
+    if: needs.check-repository.outputs.is_fork == 'true'
+    name: Sync Latest From Upstream
+    runs-on: ubuntu-latest
+    steps:
+      # 标准签出
+      - name: Checkout target repo
+        uses: actions/checkout@v4
+        # 如果上游仓库有对.github/workflows/下的文件进行变更，则需要使用有workflow权限的token
+        # with:
+        #   token: ${{ secrets.ACTION_TOKEN }}
+      
+      # 获取分支名（区分 PR 和普通提交场景）
+      - name: Get branch name (merge)
+        if: github.event_name != 'pull_request'
+        shell: bash
+        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/} | tr / -)" >> $GITHUB_ENV
+        
+      - name: Get branch name (pull request)
+        if: github.event_name == 'pull_request'
+        shell: bash
+        run: echo "BRANCH_NAME=$(echo ${GITHUB_HEAD_REF} | tr / -)" >> $GITHUB_ENV
+      
+      # 运行同步动作
+      - name: Sync upstream changes
+        id: sync
+        uses: aormsby/[email protected]
+        with:
+          upstream_sync_repo: ErlichLiu/DeepClaude
+          upstream_sync_branch: ${{ env.BRANCH_NAME }}
+          target_sync_branch: ${{ env.BRANCH_NAME }}
+          target_repo_token: ${{ secrets.GITHUB_TOKEN }}
+          upstream_pull_args: --allow-unrelated-histories --no-edit
+          shallow_since: '1 days ago'
+          test_mode: false

.gitignore

@@ -0,0 +1,20 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Virtual environments
+.venv
+
+# Windsurf
+.windsurfrules
+
+docker-compose.yml

.python-version

@@ -0,0 +1 @@
+3.11

Dockerfile

@@ -0,0 +1,27 @@
+# 使用 Python 3.11 slim 版本作为基础镜像
+FROM python:3.11-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# 安装依赖
+RUN pip install --no-cache-dir \
+    aiohttp==3.11.11 \
+    colorlog==6.9.0 \
+    fastapi==0.115.8 \
+    python-dotenv==1.0.1 \
+    tiktoken==0.8.0 \
+    "uvicorn[standard]"
+
+# 复制项目文件
+COPY ./app ./app
+
+# 暴露端口
+EXPOSE 8000
+
+# 启动命令
+CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,279 @@
+<div>
+<h1>DeepClaude 🐬🧠 - OpenAI Compatible</h1>
+
+<a href="https://github.com/getasterisk/deepclaude"> Inspiration from getasterisk/deepclaude</a>
+
+[![GitHub license](https://img.erlich.fun/personal-blog/uPic/deepclaude.svg)](#)
+[![Compatible with](https://img.shields.io/badge/-ChatGPT-412991?style=flat-square&logo=openai&logoColor=FFFFFF)](https://openai.com)
+
+</div>
+
+<div>
+<h3 style="color: #FF9909"> 特别说明：对于不太会部署，只是希望使用上最强 DeepClaude 组合的朋友，请直接联系 Erlich（微信：geekthings）购买按量付费的 API 即可，国内可以直接访问 </h3>
+</div>
+
+---
+
+<details>
+<summary><strong>更新日志：</strong></summary> 
+<div>
+2025-02-08.2: 支持非流式请求，支持 OpenAI 兼容的 models 接口返回。（⚠️ 当前暂未实现正确的 tokens 消耗统计，稍后更新）
+
+2025-02-08.1: 添加 Github Actions，支持 fork 自动同步、支持自动构建 Docker 最新镜像、支持 docker-compose 部署
+
+2025-02-07.2: 修复 Claude temperature 参数可能会超过范围导致的请求失败的 bug
+
+2025-02-07.1: 支持 Claude temputerature 等参数；添加更详细的 .env.example 说明
+
+2025-02-06.1：修复非原生推理模型无法获得到推理内容的 bug
+
+2025-02-05.1: 支持通过环境变量配置是否是原生支持推理字段的模型，满血版本通常支持
+
+2025-02-04.2: 支持跨域配置，可在 .env 中配置
+
+2025-02-04.1: 支持 Openrouter 以及 OneAPI 等中转服务商作为 Claude 部分的供应商
+
+2025-02-03.3: 支持 OpenRouter 作为 Claude 的供应商，详见 .env.example 说明
+
+2025-02-03.2: 由于 deepseek r1 在某种程度上已经开启了一个规范，所以我们也遵循推理标注的这种规范，更好适配支持的更好的 Cherry Studio 等软件。
+
+2025-02-03.1: Siliconflow 的 DeepSeek R1 返回结构变更，支持新的返回结构
+
+</div>
+</details>
+
+# Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [Introduction](#introduction)
+- [Implementation](#implementation)
+- [How to run](#how-to-run)
+  - [1. 获得运行所需的 API](#1-获得运行所需的-api)
+  - [2. 开始运行（本地运行）](#2-开始运行本地运行)
+- [Deployment](#deployment)
+  - [Railway 一键部署（推荐）](#railway-一键部署推荐)
+  - [Zeabur 一键部署(一定概率下会遇到 Domain 生成问题，需要重新创建 project 部署)](#zeabur-一键部署一定概率下会遇到-domain-生成问题需要重新创建-project-部署)
+  - [使用 docker-compose 部署（Docker 镜像将随着 main 分支自动更新到最新）](#使用-docker-compose-部署docker-镜像将随着-main-分支自动更新到最新)
+  - [Docker 部署（自行 Build）](#docker-部署自行-build)
+- [Automatic fork sync](#automatic-fork-sync)
+- [Technology Stack](#technology-stack)
+- [Star History](#star-history)
+- [Buy me a coffee](#buy-me-a-coffee)
+- [About Me](#about-me)
+
+# Introduction
+最近 DeepSeek 推出了 [DeepSeek R1 模型](https://platform.deepseek.com)，在推理能力上已经达到了第一梯队。但是 DeepSeek R1 在一些日常任务的输出上可能仍然无法匹敌 Claude 3.5 Sonnet。Aider 团队最近有一篇研究，表示通过[采用 DeepSeek R1 + Claude 3.5 Sonnet 可以实现最好的效果](https://aider.chat/2025/01/24/r1-sonnet.html)。
+
+<img src="https://img.erlich.fun/personal-blog/uPic/heiQYX.png" alt="deepseek r1 and sonnet benchmark" style="width=400px;"/>
+
+> **R1 as architect with Sonnet as editor has set a new SOTA of 64.0%** on the [aider polyglot benchmark](https://aider.chat/2024/12/21/polyglot.html). They achieve this at **14X less cost** compared to the previous o1 SOTA result.
+
+并且 Aider 还 [开源了 Demo](https://github.com/getasterisk/deepclaude)，你可以直接在他们的项目上进行在线体验。
+
+
+
+本项目受到该项目的启发，通过 fastAPI 完全重写，并支持 OpenAI 兼容格式，支持 DeepSeek 官方 API 以及第三方托管的 API。
+
+用户可以自行运行在自己的服务器，并对外提供开放 API 接口，接入 [OneAPI](https://github.com/songquanpeng/one-api) 等实现统一分发（token 消耗部分仍需开发）。也可以接入你的日常 ChatBox  软件以及 接入 [Cursor](https://www.cursor.com/) 等软件实现更好的编程效果（Claude 的流式输出+ Tool use 仍需开发）。
+
+# Implementation
+⚠️Notice: 目前只支持流式输出模式（因为这是效率最高的模式，不会浪费时间）；接下来会实现第一段 DeepSeek 推理阶段流式，Claude 输出非流式的模式（处于节省时间的考虑）。
+
+![image-20250201212456050](https://img.erlich.fun/personal-blog/uPic/image-20250201212456050.png)
+
+# How to run
+
+> 项目支持本地运行和服务器运行，本地运行可与 Ollama 搭配，实现用本地的 DeepSeek R1 与 Claude 组合输出
+
+
+## 1. 获得运行所需的 API
+
+1. 获取 DeepSeek API，因为最近 DeepSeek 还在遭受攻击，所以经常无法使用，推荐使用 Siliconflow 的效果更好（也可以本地 Ollama 的）: https://cloud.siliconflow.cn/i/RXikvHE2 (点击此链接可以获得到 2000 万免费 tokens)
+2. 获取 Claude 的 API KEY （目前还没有做中转模式，以及对 Google 和 AWS 托管的版本的兼容支持，欢迎 PR）：https://console.anthropic.com
+
+## 2. 开始运行（本地运行）
+Step 1. 克隆本项目到适合的文件夹并进入项目
+
+```bash
+git clone [email protected]:ErlichLiu/DeepClaude.git
+cd DeepClaude
+```
+
+Step 2. 通过 uv 安装依赖（如果你还没有安装 uv，请看下方注解）
+
+```bash
+# 通过 uv 在本地创建虚拟环境，并安装依赖
+uv sync
+# macOS 激活虚拟环境
+source .venv/bin/activate
+# Windows 激活虚拟环境
+.venv\Scripts\activate
+```
+
+Step 3. 配置环境变量
+
+```bash
+# 复制 .env 环境变量到本地
+cp .env.example .env
+```
+
+Step 4. 按照环境变量当中的注释依次填写配置信息（在此步骤可以配置 Ollama）
+
+Step 5. 本地运行程序
+
+```bash
+# 本地运行
+uvicorn app.main:app
+```
+
+Step 6. 配置程序到你的 Chatbox（推荐 [NextChat](https://nextchat.dev/)、[ChatBox](https://chatboxai.app/zh)、[LobeChat](https://lobechat.com/)）
+
+```bash
+# 通常 baseUrl 为：http://127.0.0.1:8000/v1
+```
+
+**注：本项目采用 uv 作为包管理器，这是一个更快速更现代的管理方式，用于替代 pip，你可以[在此了解更多](https://docs.astral.sh/uv/)**
+
+
+
+# Deployment
+
+> 项目支持 Docker 服务器部署，可自行调用接入常用的 Chatbox，也可以作为渠道一直，将其视为一个特殊的 `DeepClaude`模型接入到 [OneAPI](https://github.com/songquanpeng/one-api) 等产品使用。
+
+## Railway 一键部署（推荐）
+<details>
+<summary><strong>一键部署到 Railway</strong></summary> 
+
+<div>
+1. 首先 fork 一份代码。
+
+2. 点击打开 Railway 主页：https://railway.com?referralCode=RNTGCA
+   
+3. 点击 `Deploy a new project`
+![image-20250209164454358](https://img.erlich.fun/personal-blog/uPic/image-20250209164454358.png)
+
+4. 点击 `Deploy from GitHub repo`
+![image-20250209164638713](https://img.erlich.fun/personal-blog/uPic/image-20250209164638713.png)
+
+5. 点击 `Login with GitHub`
+![image-20250209164843566](https://img.erlich.fun/personal-blog/uPic/image-20250209164843566.png)
+
+6. 选择升级，选择只需 5 美金的 Hobby Plan 即可 
+![image-20250209165034070](https://img.erlich.fun/personal-blog/uPic/image-20250209165034070.png)
+![image-20250209165108355](https://img.erlich.fun/personal-blog/uPic/image-20250209165108355.png)
+
+1. 点击 `Create a New Project`
+![create-a-new-project](https://img.erlich.fun/personal-blog/uPic/rvfGTE.png)
+
+1. 继续选择 `Deploy from GitHub repo`
+![image-20250209164638713](https://img.erlich.fun/personal-blog/uPic/image-20250209164638713.png)
+
+1. 输入框内搜索`DeepClaude`，选中后点击。
+![deploy-from-github-repo](https://img.erlich.fun/personal-blog/uPic/ihOzXU.png)
+
+1.  选择`Variable`，并点击`New Variable` 按钮，按照环境变量内的键值对进行填写
+![variable](https://img.erlich.fun/personal-blog/uPic/VrZgxp.png)
+
+1.  填写完成后重新点击 `Deploy` 按钮，等待数秒后即可完成部署
+![deploy](https://img.erlich.fun/personal-blog/uPic/5kvkLI.png)
+
+1.  部署完成后，点击 `Settings` 按钮，然后向下查看到 `Networking` 区域，然后选择 `Generate Domain`，并输入 `8000` 作为端口号
+![networking](https://img.erlich.fun/personal-blog/uPic/PQyAtG.png)
+![generate-domain](https://img.erlich.fun/personal-blog/uPic/i5JnX8.png)
+![port](https://img.erlich.fun/personal-blog/uPic/ZEwxRm.png)
+
+1.  接下来就可以在你喜欢的 Chatbox 内配置使用或作为 API 使用了
+![using](https://img.erlich.fun/personal-blog/uPic/hD8V6e.png)
+
+</div>
+</details>
+
+## Zeabur 一键部署(一定概率下会遇到 Domain 生成问题，需要重新创建 project 部署)
+<details>
+<summary><strong>一键部署到 Zeabur</strong></summary> 
+<div>
+
+
+[![Deployed on Zeabur](https://zeabur.com/deployed-on-zeabur-dark.svg)](https://zeabur.com?referralCode=ErlichLiu&utm_source=ErlichLiu)
+
+ 1. 首先 fork 一份代码。
+ 2. 进入 [Zeabur](https://zeabur.com?referralCode=ErlichLiu&utm_source=ErlichLiu)，登录。
+ 3. 选择 Create New Project，选择地区为新加坡或日本区域。
+ 4. 选择项目来源为 Github，搜索框搜索 DeepClaude 后确认，然后点击右下角的 Config。
+ 5. 在 Environment Variables 区域点击 Add Environment Variables，逐个填写 .env.example 当中的配置，等号左右对应的就是 Environment Variables 里的 Key 和 Value。（注意：ALLOW_API_KEY 是你自己规定的外部访问你的服务时需要填写的 API KEY，可以随意填写，不要有空格）
+ 6. 全部编辑完成后点击 Next，然后点击 Deploy，静待片刻即可完成部署。
+ 7. 完成部署后点击当前面板上部的 Networking，点击 Public 区域的 Generate Domain（也可以配置自己的域名），然后输入一个你想要的域名即可（这个完整的 xxx.zeabur.app 将是你接下来在任何开源对话框、Cursor、Roo Code 等产品内填写的 baseUrl）
+ 8. 接下来就可以去上述所说的任何的项目里去配置使用你的 API 了，也可以配置到 One API，作为一个 OpenAI 渠道使用。（晚点会补充这部分的配置方法）
+</div>
+</details>
+
+## 使用 docker-compose 部署（Docker 镜像将随着 main 分支自动更新到最新）
+
+   推荐可以使用 `docker-compose.yml` 文件进行部署，更加方便快捷。
+
+   1. 确保已安装 Docker Compose。
+   2. 复制 `docker-compose.yml` 文件到项目根目录。
+   3. 修改 `docker-compose.yml` 文件中的环境变量配置，将 `your_allow_api_key`，`your_allow_origins`，`your_deepseek_api_key` 和 `your_claude_api_key` 替换为你的实际配置。
+   4. 在项目根目录下运行 Docker Compose 命令启动服务：
+
+      ```bash
+      docker-compose up -d
+      ```
+
+   服务启动后，DeepClaude API 将在 `http://宿主机IP:8000/v1/chat/completions` 上进行访问。
+
+
+## Docker 部署（自行 Build）
+
+1. **构建 Docker 镜像**
+
+   在项目根目录下，使用 Dockerfile 构建镜像。请确保已经安装 Docker 环境。
+
+   ```bash
+   docker build -t deepclaude:latest .
+   ```
+
+2. **运行 Docker 容器**
+
+   运行构建好的 Docker 镜像，将容器的 8000 端口映射到宿主机的 8000 端口。同时，通过 `-e` 参数设置必要的环境变量，包括 API 密钥、允许的域名等。请根据 `.env.example` 文件中的说明配置环境变量。
+
+   ```bash
+   docker run -d \
+       -p 8000:8000 \
+       -e ALLOW_API_KEY=your_allow_api_key \
+       -e ALLOW_ORIGINS="*" \
+       -e DEEPSEEK_API_KEY=your_deepseek_api_key \
+       -e DEEPSEEK_API_URL=https://api.deepseek.com/v1/chat/completions \
+       -e DEEPSEEK_MODEL=deepseek-reasoner \
+       -e IS_ORIGIN_REASONING=true \
+       -e CLAUDE_API_KEY=your_claude_api_key \
+       -e CLAUDE_MODEL=claude-3-5-sonnet-20241022 \
+       -e CLAUDE_PROVIDER=anthropic \
+       -e CLAUDE_API_URL=https://api.anthropic.com/v1/messages \
+       -e LOG_LEVEL=INFO \
+       --restart always \
+       deepclaude:latest
+   ```
+
+   请替换上述命令中的 `your_allow_api_key`，`your_allow_origins`，`your_deepseek_api_key` 和 `your_claude_api_key` 为你实际的 API 密钥和配置。`ALLOW_ORIGINS` 请设置为允许访问的域名，如 `"http://localhost:3000,https://chat.example.com"` 或 `"*"` 表示允许所有来源。
+
+
+# Automatic fork sync
+项目已经支持 Github Actions 自动更新 fork 项目的代码，保持你的 fork 版本与当前 main 分支保持一致。如需开启，请 frok 后在 Settings 中开启 Actions 权限即可。
+
+
+# Technology Stack
+- [FastAPI](https://fastapi.tiangolo.com/)
+- [UV as package manager](https://docs.astral.sh/uv/#project-management)
+- [Docker](https://www.docker.com/)
+
+# Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ErlichLiu/DeepClaude&type=Date)](https://star-history.com/#ErlichLiu/DeepClaude&Date)
+
+# Buy me a coffee
+<img src="https://img.erlich.fun/personal-blog/uPic/IMG_3625.JPG" alt="微信赞赏码" style="width: 400px;"/>
+
+# About Me
+- Email: [email protected]
+- Website: [Erlichliu](https://erlich.fun)

app/clients/__init__.py

@@ -0,0 +1,5 @@
+from .base_client import BaseClient
+from .deepseek_client import DeepSeekClient
+from .claude_client import ClaudeClient
+
+__all__ = ['BaseClient', 'DeepSeekClient', 'ClaudeClient']

app/clients/base_client.py

@@ -0,0 +1,54 @@
+"""基础客户端类，定义通用接口"""
+from typing import AsyncGenerator, Any
+import aiohttp
+from app.utils.logger import logger
+from abc import ABC, abstractmethod
+
+
+class BaseClient(ABC):
+    def __init__(self, api_key: str, api_url: str):
+        """初始化基础客户端
+        
+        Args:
+            api_key: API密钥
+            api_url: API地址
+        """
+        self.api_key = api_key
+        self.api_url = api_url
+        
+    async def _make_request(self, headers: dict, data: dict) -> AsyncGenerator[bytes, None]:
+        """发送请求并处理响应
+        
+        Args:
+            headers: 请求头
+            data: 请求数据
+            
+        Yields:
+            bytes: 原始响应数据
+        """
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(self.api_url, headers=headers, json=data) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        logger.error(f"API 请求失败: {error_text}")
+                        return
+                        
+                    async for chunk in response.content.iter_any():
+                        yield chunk
+                        
+        except Exception as e:
+            logger.error(f"请求 API 时发生错误: {e}")
+            
+    @abstractmethod
+    async def stream_chat(self, messages: list, model: str) -> AsyncGenerator[tuple[str, str], None]:
+        """流式对话，由子类实现
+        
+        Args:
+            messages: 消息列表
+            model: 模型名称
+            
+        Yields:
+            tuple[str, str]: (内容类型, 内容)
+        """
+        pass

app/clients/claude_client.py

@@ -0,0 +1,142 @@
+"""Claude API 客户端"""
+import json
+from typing import AsyncGenerator
+from app.utils.logger import logger
+from .base_client import BaseClient
+
+
+class ClaudeClient(BaseClient):
+    def __init__(self, api_key: str, api_url: str = "https://api.anthropic.com/v1/messages", provider: str = "anthropic"):
+        """初始化 Claude 客户端
+        
+        Args:
+            api_key: Claude API密钥
+            api_url: Claude API地址
+            is_openrouter: 是否使用 OpenRouter API
+        """
+        super().__init__(api_key, api_url)
+        self.provider = provider
+
+    async def stream_chat(
+        self,
+        messages: list,
+        model_arg: tuple[float, float, float, float],
+        model: str,
+        stream: bool = True
+    ) -> AsyncGenerator[tuple[str, str], None]:
+        """流式或非流式对话
+        
+        Args:
+            messages: 消息列表
+            model_arg: 模型参数元组[temperature, top_p, presence_penalty, frequency_penalty]
+            model: 模型名称。如果是 OpenRouter, 会自动转换为 'anthropic/claude-3.5-sonnet' 格式
+            stream: 是否使用流式输出，默认为 True
+            
+        Yields:
+            tuple[str, str]: (内容类型, 内容)
+                内容类型: "answer"
+                内容: 实际的文本内容
+        """
+
+        if self.provider == "openrouter":
+            # 转换模型名称为 OpenRouter 格式
+            model = "anthropic/claude-3.5-sonnet"
+                
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://github.com/ErlichLiu/DeepClaude",  # OpenRouter 需要
+                "X-Title": "DeepClaude"  # OpenRouter 需要
+            }
+
+            data = {
+                "model": model,  # OpenRouter 使用 anthropic/claude-3.5-sonnet 格式
+                "messages": messages,
+                "stream": stream,
+                "temperature": 1 if model_arg[0] < 0 or model_arg[0] > 1 else model_arg[0],
+                "top_p": model_arg[1],
+                "presence_penalty": model_arg[2],
+                "frequency_penalty": model_arg[3]
+            }
+        elif self.provider == "oneapi":
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+
+            data = {
+                "model": model,
+                "messages": messages,
+                "stream": stream,
+                "temperature": 1 if model_arg[0] < 0 or model_arg[0] > 1 else model_arg[0],
+                "top_p": model_arg[1],
+                "presence_penalty": model_arg[2],
+                "frequency_penalty": model_arg[3]
+            }
+        elif self.provider == "anthropic":
+            headers = {
+                "x-api-key": self.api_key,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+                "accept": "text/event-stream" if stream else "application/json",
+            }
+
+            data = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": 8192,
+                "stream": stream,
+                "temperature": 1 if model_arg[0] < 0 or model_arg[0] > 1 else model_arg[0], # Claude仅支持temperature与top_p
+                "top_p": model_arg[1]
+            }
+        else:
+            raise ValueError(f"不支持的Claude Provider: {self.provider}")
+
+        logger.debug(f"开始对话：{data}")
+
+        if stream:
+            async for chunk in self._make_request(headers, data):
+                chunk_str = chunk.decode('utf-8')
+                if not chunk_str.strip():
+                    continue
+                    
+                for line in chunk_str.split('\n'):
+                    if line.startswith('data: '):
+                        json_str = line[6:]  # 去掉 'data: ' 前缀
+                        if json_str.strip() == '[DONE]':
+                            return
+                            
+                        try:
+                            data = json.loads(json_str)
+                            if self.provider in ("openrouter", "oneapi"):
+                                # OpenRouter/OneApi 格式
+                                content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                                if content:
+                                    yield "answer", content
+                            elif self.provider == "anthropic":
+                                # Anthropic 格式
+                                if data.get('type') == 'content_block_delta':
+                                    content = data.get('delta', {}).get('text', '')
+                                    if content:
+                                        yield "answer", content
+                            else:
+                                raise ValueError(f"不支持的Claude Provider: {self.provider}")
+                        except json.JSONDecodeError:
+                            continue
+        else:
+            # 非流式输出
+            async for chunk in self._make_request(headers, data):
+                try:
+                    response = json.loads(chunk.decode('utf-8'))
+                    if self.provider in ("openrouter", "oneapi"):
+                        content = response.get('choices', [{}])[0].get('message', {}).get('content', '')
+                        if content:
+                            yield "answer", content
+                    elif self.provider == "anthropic":
+                        content = response.get('content', [{}])[0].get('text', '')
+                        if content:
+                            yield "answer", content
+                    else:
+                        raise ValueError(f"不支持的Claude Provider: {self.provider}")
+                except json.JSONDecodeError:
+                    continue

app/clients/deepseek_client.py

@@ -0,0 +1,133 @@
+"""DeepSeek API 客户端"""
+import json
+from typing import AsyncGenerator
+from app.utils.logger import logger
+from .base_client import BaseClient
+
+
+class DeepSeekClient(BaseClient):
+    def __init__(self, api_key: str, api_url: str = "https://api.siliconflow.cn/v1/chat/completions", provider: str = "deepseek"):
+        """初始化 DeepSeek 客户端
+        
+        Args:
+            api_key: DeepSeek API密钥
+            api_url: DeepSeek API地址
+        """
+        super().__init__(api_key, api_url)
+        self.provider = provider
+        
+    def _process_think_tag_content(self, content: str) -> tuple[bool, str]:
+        """处理包含 think 标签的内容
+        
+        Args:
+            content: 需要处理的内容字符串
+            
+        Returns:
+            tuple[bool, str]: 
+                bool: 是否检测到完整的 think 标签对
+                str: 处理后的内容
+        """
+        has_start = "<think>" in content
+        has_end = "</think>" in content
+        
+        if has_start and has_end:
+            return True, content
+        elif has_start:
+            return False, content
+        elif not has_start and not has_end:
+            return False, content
+        else:
+            return True, content
+            
+    async def stream_chat(self, messages: list, model: str = "deepseek-ai/DeepSeek-R1", is_origin_reasoning: bool = True) -> AsyncGenerator[tuple[str, str], None]:
+        """流式对话
+        
+        Args:
+            messages: 消息列表
+            model: 模型名称
+            
+        Yields:
+            tuple[str, str]: (内容类型, 内容)
+                内容类型: "reasoning" 或 "content"
+                内容: 实际的文本内容
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+        data = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+        }
+        
+        logger.debug(f"开始流式对话：{data}")
+
+        accumulated_content = ""
+        is_collecting_think = False
+        
+        async for chunk in self._make_request(headers, data):
+            chunk_str = chunk.decode('utf-8')
+            
+            try:
+                lines = chunk_str.splitlines()
+                for line in lines:
+                    if line.startswith("data: "):
+                        json_str = line[len("data: "):]
+                        if json_str == "[DONE]":
+                            return
+                        
+                        data = json.loads(json_str)
+                        if data and data.get("choices") and data["choices"][0].get("delta"):
+                            delta = data["choices"][0]["delta"]
+                            
+                            if is_origin_reasoning:
+                                # 处理 reasoning_content
+                                if delta.get("reasoning_content"):
+                                    content = delta["reasoning_content"]
+                                    logger.debug(f"提取推理内容：{content}")
+                                    yield "reasoning", content
+                                
+                                if delta.get("reasoning_content") is None and delta.get("content"):
+                                    content = delta["content"]
+                                    logger.info(f"提取内容信息，推理阶段结束: {content}")
+                                    yield "content", content
+                            else:
+                                # 处理其他模型的输出
+                                if delta.get("content"):
+                                    content = delta["content"]
+                                    if content == "":  # 只跳过完全空的字符串
+                                        continue
+                                    logger.debug(f"非原生推理内容：{content}")
+                                    accumulated_content += content
+                                    
+                                    # 检查累积的内容是否包含完整的 think 标签对
+                                    is_complete, processed_content = self._process_think_tag_content(accumulated_content)
+                                    
+                                    if "<think>" in content and not is_collecting_think:
+                                        # 开始收集推理内容
+                                        logger.debug(f"开始收集推理内容：{content}")
+                                        is_collecting_think = True
+                                        yield "reasoning", content
+                                    elif is_collecting_think:
+                                        if "</think>" in content:
+                                            # 推理内��结束
+                                            logger.debug(f"推理内容结束：{content}")
+                                            is_collecting_think = False
+                                            yield "reasoning", content
+                                            # 输出空的 content 来触发 Claude 处理
+                                            yield "content", ""
+                                            # 重置累积内容
+                                            accumulated_content = ""
+                                        else:
+                                            # 继续收集推理内容
+                                            yield "reasoning", content
+                                    else:
+                                        # 普通内容
+                                        yield "content", content
+                                        
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON 解析错误: {e}")
+            except Exception as e:
+                logger.error(f"处理 chunk 时发生错误: {e}")

app/deepclaude/deepclaude.py

@@ -0,0 +1,268 @@
+"""DeepClaude 服务，用于协调 DeepSeek 和 Claude API 的调用"""
+import json
+import time
+import tiktoken
+import asyncio
+from typing import AsyncGenerator
+from app.utils.logger import logger
+from app.clients import DeepSeekClient, ClaudeClient
+
+
+class DeepClaude:
+    """处理 DeepSeek 和 Claude API 的流式输出衔接"""
+
+    def __init__(self, deepseek_api_key: str, claude_api_key: str, 
+                 deepseek_api_url: str = "https://api.deepseek.com/v1/chat/completions", 
+                 claude_api_url: str = "https://api.anthropic.com/v1/messages",
+                 claude_provider: str = "anthropic",
+                 is_origin_reasoning: bool = True):
+        """初始化 API 客户端
+        
+        Args:
+            deepseek_api_key: DeepSeek API密钥
+            claude_api_key: Claude API密钥
+        """
+        self.deepseek_client = DeepSeekClient(deepseek_api_key, deepseek_api_url)
+        self.claude_client = ClaudeClient(claude_api_key, claude_api_url, claude_provider)
+        self.is_origin_reasoning = is_origin_reasoning
+
+    async def chat_completions_with_stream(
+        self,
+        messages: list,
+        model_arg: tuple[float, float, float, float],
+        deepseek_model: str = "deepseek-reasoner",
+        claude_model: str = "claude-3-5-sonnet-20241022"
+    ) -> AsyncGenerator[bytes, None]:
+        """处理完整的流式输出过程
+        
+        Args:
+            messages: 初始消息列表
+            model_arg: 模型参数
+            deepseek_model: DeepSeek 模型名称
+            claude_model: Claude 模型名称
+            
+        Yields:
+            字节流数据，格式如下：
+            {
+                "id": "chatcmpl-xxx",
+                "object": "chat.completion.chunk",
+                "created": timestamp,
+                "model": model_name,
+                "choices": [{
+                    "index": 0,
+                    "delta": {
+                        "role": "assistant",
+                        "reasoning_content": reasoning_content,
+                        "content": content
+                    }
+                }]
+            }
+        """
+        # 生成唯一的会话ID和时间戳
+        chat_id = f"chatcmpl-{hex(int(time.time() * 1000))[2:]}"
+        created_time = int(time.time())
+
+        # 创建队列，用于收集输出数据
+        output_queue = asyncio.Queue()
+        # 队列，用于传递 DeepSeek 推理内容给 Claude
+        claude_queue = asyncio.Queue()
+
+        # 用于存储 DeepSeek 的推理累积内容
+        reasoning_content = []
+
+        async def process_deepseek():
+            logger.info(f"开始处理 DeepSeek 流，使用模型：{deepseek_model}, 提供商: {self.deepseek_client.provider}")
+            try:
+                async for content_type, content in self.deepseek_client.stream_chat(messages, deepseek_model, self.is_origin_reasoning):
+                    if content_type == "reasoning":
+                        reasoning_content.append(content)
+                        response = {
+                            "id": chat_id,
+                            "object": "chat.completion.chunk",
+                            "created": created_time,
+                            "model": deepseek_model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "role": "assistant",
+                                    "reasoning_content": content,
+                                    "content": ""
+                                }
+                            }]
+                        }
+                        await output_queue.put(f"data: {json.dumps(response)}\n\n".encode('utf-8'))
+                    elif content_type == "content":
+                        # 当收到 content 类型时，将完整的推理内容发送到 claude_queue，并结束 DeepSeek 流处理
+                        logger.info(f"DeepSeek 推理完成，收集到的推理内容长度：{len(''.join(reasoning_content))}")
+                        await claude_queue.put("".join(reasoning_content))
+                        break
+            except Exception as e:
+                logger.error(f"处理 DeepSeek 流时发生错误: {e}")
+                await claude_queue.put("")
+            # 用 None 标记 DeepSeek 任务结束
+            logger.info("DeepSeek 任务处理完成，标记结束")
+            await output_queue.put(None)
+
+        async def process_claude():
+            try:
+                logger.info("等待获取 DeepSeek 的推理内容...")
+                reasoning = await claude_queue.get()
+                logger.debug(f"获取到推理内容，内容长度：{len(reasoning) if reasoning else 0}")
+                if not reasoning:
+                    logger.warning("未能获取到有效的推理内容，将使用默认提示继续")
+                    reasoning = "获取推理内容失败"
+                # 构造 Claude 的输入消息
+                claude_messages = messages.copy()
+                combined_content = f"""
+                Here's my another model's reasoning process:\n{reasoning}\n\n
+                Based on this reasoning, provide your response directly to me:"""
+                
+                # 改造最后一个消息对象，判断消息对象是 role = user，然后在这个对象的 content 后追加新的 String
+                last_message = claude_messages[-1]
+                if last_message.get("role", "") == "user":
+                    original_content = last_message["content"]
+                    fixed_content = f"Here's my original input:\n{original_content}\n\n{combined_content}"
+                    last_message["content"] = fixed_content
+                # 处理可能 messages 内存在 role = system 的情况，如果有，则去掉当前这一条的消息对象
+                claude_messages = [message for message in claude_messages if message.get("role", "") != "system"]
+
+                logger.info(f"开始处理 Claude 流，使用模型: {claude_model}, 提供商: {self.claude_client.provider}")
+
+                async for content_type, content in self.claude_client.stream_chat(
+                    messages=claude_messages,
+                    model_arg=model_arg,
+                    model=claude_model,
+                ):
+                    if content_type == "answer":
+                        response = {
+                            "id": chat_id,
+                            "object": "chat.completion.chunk",
+                            "created": created_time,
+                            "model": claude_model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "role": "assistant",
+                                    "content": content
+                                }
+                            }]
+                        }
+                        await output_queue.put(f"data: {json.dumps(response)}\n\n".encode('utf-8'))
+            except Exception as e:
+                logger.error(f"处理 Claude 流时发生错误: {e}")
+            # 用 None 标记 Claude 任务结束
+            logger.info("Claude 任务处理完成，标记结束")
+            await output_queue.put(None)
+        
+        # 创建并发任务
+        deepseek_task = asyncio.create_task(process_deepseek())
+        claude_task = asyncio.create_task(process_claude())
+        
+        # 等待两个任务完成，通过计数判断
+        finished_tasks = 0
+        while finished_tasks < 2:
+            item = await output_queue.get()
+            if item is None:
+                finished_tasks += 1
+            else:
+                yield item
+        
+        # 发送结束标记
+        yield b'data: [DONE]\n\n'
+
+    async def chat_completions_without_stream(
+        self,
+        messages: list,
+        model_arg: tuple[float, float, float, float],
+        deepseek_model: str = "deepseek-reasoner",
+        claude_model: str = "claude-3-5-sonnet-20241022"
+    ) -> dict:
+        """处理非流式输出过程
+        
+        Args:
+            messages: 初始消息列表
+            model_arg: 模型参数
+            deepseek_model: DeepSeek 模型名称
+            claude_model: Claude 模型名称
+            
+        Returns:
+            dict: OpenAI 格式的完整响应
+        """
+        chat_id = f"chatcmpl-{hex(int(time.time() * 1000))[2:]}"
+        created_time = int(time.time())
+        reasoning_content = []
+
+        # 1. 获取 DeepSeek 的推理内容（仍然使用流式）
+        try:
+            async for content_type, content in self.deepseek_client.stream_chat(messages, deepseek_model, self.is_origin_reasoning):
+                if content_type == "reasoning":
+                    reasoning_content.append(content)
+                elif content_type == "content":
+                    break
+        except Exception as e:
+            logger.error(f"获取 DeepSeek 推理内容时发生错误: {e}")
+            reasoning_content = ["获取推理内容失败"]
+
+        # 2. 构造 Claude 的输入消息
+        reasoning = "".join(reasoning_content)
+        claude_messages = messages.copy()
+
+        combined_content = f"""
+        Here's my another model's reasoning process:\n{reasoning}\n\n
+        Based on this reasoning, provide your response directly to me:"""
+        
+        # 改造最后一个消息对象，判断消息对象是 role = user，然后在这个对象的 content 后追加新的 String
+        last_message = claude_messages[-1]
+        if last_message.get("role", "") == "user":
+            original_content = last_message["content"]
+            fixed_content = f"Here's my original input:\n{original_content}\n\n{combined_content}"
+            last_message["content"] = fixed_content
+
+        # 处理可能 messages 内存在 role = system 的情况
+        claude_messages = [message for message in claude_messages if message.get("role", "") != "system"]
+
+        # 拼接所有 content 为一个字符串，计算 token
+        token_content = "\n".join([message.get("content", "") for message in claude_messages])
+        encoding = tiktoken.encoding_for_model("gpt-4o")
+        input_tokens = encoding.encode(token_content)
+        logger.debug(f"输入 Tokens: {len(input_tokens)}")
+
+        logger.debug("claude messages: " + str(claude_messages))
+        # 3. 获取 Claude 的非流式响应
+        try:
+            answer = ""
+            async for content_type, content in self.claude_client.stream_chat(
+                messages=claude_messages,
+                model_arg=model_arg,
+                model=claude_model,
+                stream=False
+            ):
+                if content_type == "answer":
+                    answer += content
+                output_tokens = encoding.encode(answer)
+                logger.debug(f"输出 Tokens: {len(output_tokens)}")
+
+            # 4. 构造 OpenAI 格式的响应
+            return {
+                "id": chat_id,
+                "object": "chat.completion",
+                "created": created_time,
+                "model": claude_model,
+                "choices": [{
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": answer,
+                        "reasoning_content": reasoning
+                    },
+                    "finish_reason": "stop"
+                }],
+                "usage": {
+                    "prompt_tokens": len(input_tokens),
+                    "completion_tokens": len(output_tokens),
+                    "total_tokens": len(input_tokens + output_tokens)
+                }
+            }
+        except Exception as e:
+            logger.error(f"获取 Claude 响应时发生错误: {e}")
+            raise e

app/main.py

@@ -0,0 +1,160 @@
+import os
+import sys
+from dotenv import load_dotenv
+
+# 加载环境变量
+load_dotenv()
+
+from fastapi import FastAPI, Depends, Request
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from app.utils.logger import logger
+from app.utils.auth import verify_api_key
+from app.deepclaude.deepclaude import DeepClaude
+
+app = FastAPI(title="DeepClaude API")
+
+# 从环境变量获取 CORS配置, API 密钥、地址以及模型名称
+ALLOW_ORIGINS = os.getenv("ALLOW_ORIGINS", "*")
+
+CLAUDE_API_KEY = os.getenv("CLAUDE_API_KEY")
+CLAUDE_MODEL = os.getenv("CLAUDE_MODEL")
+CLAUDE_PROVIDER = os.getenv("CLAUDE_PROVIDER", "anthropic") # Claude模型提供商, 默认为anthropic
+CLAUDE_API_URL = os.getenv("CLAUDE_API_URL", "https://api.anthropic.com/v1/messages")
+
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+DEEPSEEK_API_URL = os.getenv("DEEPSEEK_API_URL")
+DEEPSEEK_MODEL = os.getenv("DEEPSEEK_MODEL")
+
+IS_ORIGIN_REASONING = os.getenv("IS_ORIGIN_REASONING", "True").lower() == "true"
+
+# CORS设置
+allow_origins_list = ALLOW_ORIGINS.split(",") if ALLOW_ORIGINS else [] # 将逗号分隔的字符串转换为列表
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allow_origins_list,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 创建 DeepClaude 实例, 提出为Global变量
+if not DEEPSEEK_API_KEY or not CLAUDE_API_KEY:
+    logger.critical("请设置环境变量 CLAUDE_API_KEY 和 DEEPSEEK_API_KEY")
+    sys.exit(1)
+
+deep_claude = DeepClaude(
+    DEEPSEEK_API_KEY,
+    CLAUDE_API_KEY,
+    DEEPSEEK_API_URL,
+    CLAUDE_API_URL,
+    CLAUDE_PROVIDER,
+    IS_ORIGIN_REASONING
+)
+
+# 验证日志级别
+logger.debug("当前日志级别为 DEBUG")
+logger.info("开始请求")
+
+@app.get("/", dependencies=[Depends(verify_api_key)])
+async def root():
+    logger.info("访问了根路径")
+    return {"message": "Welcome to DeepClaude API"}
+
+@app.get("/v1/models")
+async def list_models():
+    """
+    获取可用模型列表
+    返回格式遵循 OpenAI API 标准
+    """
+    models = [{
+        "id": "deepclaude",
+        "object": "model",
+        "created": 1677610602,
+        "owned_by": "deepclaude",
+        "permission": [{
+            "id": "modelperm-deepclaude",
+            "object": "model_permission",
+            "created": 1677610602,
+            "allow_create_engine": False,
+            "allow_sampling": True,
+            "allow_logprobs": True,
+            "allow_search_indices": False,
+            "allow_view": True,
+            "allow_fine_tuning": False,
+            "organization": "*",
+            "group": None,
+            "is_blocking": False
+        }],
+        "root": "deepclaude",
+        "parent": None
+    }]
+    
+    return {"object": "list", "data": models}
+
+@app.post("/v1/chat/completions", dependencies=[Depends(verify_api_key)])
+async def chat_completions(request: Request):
+    """处理聊天完成请求，支持流式和非流式输出
+    
+    请求体格式应与 OpenAI API 保持一致，包含：
+    - messages: 消息列表
+    - model: 模型名称（可选）
+    - stream: 是否使用流式输出（可选，默认为 True)
+    - temperature: 随机性 (可选)
+    - top_p: top_p (可选)
+    - presence_penalty: 话题新鲜度（可选）
+    - frequency_penalty: 频率惩罚度（可选）
+    """
+
+    try:
+        # 1. 获取基础信息
+        body = await request.json()
+        messages = body.get("messages")
+
+        # 2. 获取并验证参数
+        model_arg = (
+            get_and_validate_params(body)
+        )
+        stream = model_arg[4]  # 获取 stream 参数
+
+        # 3. 根据 stream 参数返回相应的响应
+        if stream:
+            return StreamingResponse(
+                deep_claude.chat_completions_with_stream(
+                    messages=messages,
+                    model_arg=model_arg[:4],  # 不传递 stream 参数
+                    deepseek_model=DEEPSEEK_MODEL,
+                    claude_model=CLAUDE_MODEL
+                ),
+                media_type="text/event-stream"
+            )
+        else:
+            # 非流式输出
+            response = await deep_claude.chat_completions_without_stream(
+                messages=messages,
+                model_arg=model_arg[:4],  # 不传递 stream 参数
+                deepseek_model=DEEPSEEK_MODEL,
+                claude_model=CLAUDE_MODEL
+            )
+            return response
+
+    except Exception as e:
+        logger.error(f"处理请求时发生错误: {e}")
+        return {"error": str(e)}
+
+
+def get_and_validate_params(body):
+    """提取获取和验证请求参数的函数"""
+    # TODO: 默认值设定允许自定义
+    temperature: float = body.get("temperature", 0.5)
+    top_p: float = body.get("top_p", 0.9)
+    presence_penalty: float = body.get("presence_penalty", 0.0)
+    frequency_penalty: float = body.get("frequency_penalty", 0.0)
+    stream: bool = body.get("stream", True)
+
+    if "sonnet" in body.get("model", ""): # Only Sonnet 设定 temperature 必须在 0 到 1 之间
+        if not isinstance(temperature, (float)) or temperature < 0.0 or temperature > 1.0:
+            raise ValueError("Sonnet 设定 temperature 必须在 0 到 1 之间")
+
+    return (temperature, top_p, presence_penalty, frequency_penalty, stream)

app/utils/auth.py

@@ -0,0 +1,47 @@
+from fastapi import HTTPException, Header
+from typing import Optional
+import os
+from dotenv import load_dotenv
+from app.utils.logger import logger
+
+# 加载 .env 文件
+logger.info(f"当前工作目录: {os.getcwd()}")
+logger.info("尝试加载.env文件...")
+load_dotenv(override=True)  # 添加override=True强制覆盖已存在的环境变量
+
+# 获取环境变量
+ALLOW_API_KEY = os.getenv("ALLOW_API_KEY")
+logger.info(f"ALLOW_API_KEY环境变量状态: {'已设置' if ALLOW_API_KEY else '未设置'}")
+
+if not ALLOW_API_KEY:
+    raise ValueError("ALLOW_API_KEY environment variable is not set")
+
+# 打印API密钥的前4位用于调试
+logger.info(f"Loaded API key starting with: {ALLOW_API_KEY[:4] if len(ALLOW_API_KEY) >= 4 else ALLOW_API_KEY}")
+
+
+async def verify_api_key(authorization: Optional[str] = Header(None)) -> None:
+    """验证API密钥
+
+    Args:
+        authorization (Optional[str], optional): Authorization header中的API密钥. Defaults to Header(None).
+
+    Raises:
+        HTTPException: 当Authorization header缺失或API密钥无效时抛出401错误
+    """
+    if authorization is None:
+        logger.warning("请求缺少Authorization header")
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization header"
+        )
+    
+    api_key = authorization.replace("Bearer ", "").strip()
+    if api_key != ALLOW_API_KEY:
+        logger.warning(f"无效的API密钥: {api_key}")
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+    
+    logger.info("API密钥验证通过")

app/utils/logger.py

@@ -0,0 +1,70 @@
+import logging
+import colorlog
+import sys
+import os
+from dotenv import load_dotenv
+
+# 确保环境变量被加载
+load_dotenv()
+
+def get_log_level() -> int:
+    """从环境变量获取日志级别
+    
+    Returns:
+        int: logging 模块定义的日志级别
+    """
+    level_map = {
+        'DEBUG': logging.DEBUG,
+        'INFO': logging.INFO,
+        'WARNING': logging.WARNING,
+        'ERROR': logging.ERROR,
+        'CRITICAL': logging.CRITICAL
+    }
+    
+    level = os.getenv('LOG_LEVEL', 'INFO').upper()
+    return level_map.get(level, logging.INFO)
+
+def setup_logger(name: str = "DeepClaude") -> logging.Logger:
+    """设置一个彩色的logger
+
+    Args:
+        name (str, optional): logger的名称. Defaults to "DeepClaude".
+
+    Returns:
+        logging.Logger: 配置好的logger实例
+    """
+    logger = colorlog.getLogger(name)
+    
+    if logger.handlers:
+        return logger
+    
+    # 从环境变量获取日志级别
+    log_level = get_log_level()
+    
+    # 设置日志级别
+    logger.setLevel(log_level)
+    
+    # 创建控制台处理器
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+    
+    # 设置彩色日志格式
+    formatter = colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        log_colors={
+            'DEBUG':    'cyan',
+            'INFO':     'green',
+            'WARNING':  'yellow',
+            'ERROR':    'red',
+            'CRITICAL': 'red,bg_white',
+        }
+    )
+    
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    return logger
+
+# 创建一个默认的logger实例
+logger = setup_logger()

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "deepclaude"
+version = "0.1.0"
+description = "This is a project for combining DeepSeek and Claude into one api call. Full unleash the power of AI."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "aiohttp>=3.11.11",
+    "colorlog>=6.9.0",
+    "fastapi>=0.115.8",
+    "python-dotenv>=1.0.1",
+    "tiktoken>=0.8.0",
+    "uvicorn>=0.34.0",
+]