📖 Docs: Update the documentation, add an English README.

README.md

@@ -1,71 +1,72 @@
 # uni-api
 
 <p align="center">
-  <a href="https://t.me/uni_api">
+<a href="https://t.me/uni_api">
     <img src="https://img.shields.io/badge/Join Telegram Group-blue?&logo=telegram">
   </a>
-   <a href="https://hub.docker.com/repository/docker/yym68686/uni-api">
+<a href="https://hub.docker.com/repository/docker/yym68686/uni-api">
     <img src="https://img.shields.io/docker/pulls/yym68686/uni-api?color=blue" alt="docker pull">
   </a>
 </p>
 
+[English](./README.md) | [Chinese](./README_CN.md)
 
 ## Introduction
 
-如果个人使用的话，one/new-api 过于复杂，有很多个人不需要使用的商用功能，如果你不想要复杂的前端界面，有想要支持的模型多一点，可以试试 uni-api。这是一个统一管理大模型API的项目，可以通过一个统一的API接口调用多个后端服务，统一转换为 OpenAI 格式，支持负载均衡。目前支持的后端服务有：OpenAI、Anthropic、Gemini、Vertex、DeepBricks、OpenRouter 等。
+If used personally, one/new-api is too complex and has many commercial features that individuals do not need. If you don't want a complicated frontend interface and want to support more models, you can try uni-api. This is a project that manages large model APIs uniformly. It allows you to call multiple backend services through a unified API interface, converting them uniformly to OpenAI format and supporting load balancing. The currently supported backend services include: OpenAI, Anthropic, Gemini, Vertex, DeepBricks, OpenRouter, etc.
 
 ## Features
 
-- 无前端，纯配置文件配置 API 渠道。只要写一个文件就能运行起一个属于自己的 API 站，文档有详细的配置指南，小白友好。
-- 统一管理多个后端服务，支持 OpenAI、Deepseek、DeepBricks、OpenRouter 等其他API 是 OpenAI 格式的提供商。支持 OpenAI Dalle-3 图像生成。
-- 同时支持 Anthropic、Gemini、Vertex API。Vertex 同时支持 Claude 和 Gemini API。
-- 支持 OpenAI、 Anthropic、Gemini、Vertex 原生 tool use 函数调用。
-- 支持 OpenAI、Anthropic、Gemini、Vertex 原生识图 API。
-- 支持四种负载均衡。
-  1. 支持渠道级加权负载均衡，可以根据不同的渠道权重分配请求。默认不开启，需要配置渠道权重。
-  2. 支持 Vertex 区域级负载均衡，支持 Vertex 高并发，最高可将 Gemini，Claude 并发提高 （API数量 * 区域数量） 倍。自动开启不需要额外配置。
-  3. 除了 Vertex 区域级负载均衡，所有 API 均支持渠道级顺序负载均衡，提高沉浸式翻译体验。自动开启不需要额外配置。
-  4. 支持单个渠道多个 API Key 自动开启 API key 级别的轮训负载均衡。
-- 支持自动重试，当一个 API 渠道响应失败时，自动重试下一个 API 渠道。
-- 支持细粒度的权限控制。支持使用通配符设置 API key 可用渠道的特定模型。
-- 支持限流，可以设置每分钟最多请求次数，可以设置为整数，如 2/min，2 次每分钟、5/hour，5 次每小时、10/day，10 次每天，10/month，10 次每月，10/year，10 次每年。默认60/min。
+- No front-end, purely configuration file to set up API channels. You can run your own API site just by writing a file. The documentation has detailed configuration guidelines, friendly for beginners.
+- Unified management of multiple backend services, supporting OpenAI, Deepseek, DeepBricks, OpenRouter, and other API providers in the OpenAI format. Supports OpenAI Dalle-3 image generation.
+- Supports Anthropic, Gemini, Vertex API simultaneously. Vertex supports both Claude and Gemini API.
+- Support native tool use function calls for OpenAI, Anthropic, Gemini, Vertex.
+- Supports OpenAI, Anthropic, Gemini, Vertex native image recognition API.
+- Supports four types of load balancing.
+  1. Supports channel-level weighted load balancing, which can allocate requests based on different channel weights. By default, it is not enabled and requires channel weight configuration.
+  2. Supports Vertex region-level load balancing, supports Vertex high concurrency, and can increase Gemini and Claude concurrency by up to (number of APIs * number of regions) times. Automatically enabled without additional configuration.
+  3. Except for Vertex region-level load balancing, all APIs support channel-level sequential load balancing, enhancing the immersive translation experience. Automatically enabled without additional configuration.
+  4. Support automatic API key-level polling load balancing for multiple API Keys in a single channel.
+- Supports automatic retry. When an API channel response fails, automatically retry the next API channel.
+- Supports fine-grained access control. Supports using wildcards to set specific models available for API key channels.
+- Supports rate limiting, can set the maximum number of requests per minute, can be set as an integer, such as 2/min, 2 times per minute, 5/hour, 5 times per hour, 10/day, 10 times per day, 10/month, 10 times per month, 10/year, 10 times per year. Default is 60/min.
 
 ## Configuration
 
-使用 api.yaml 配置文件，可以配置多个模型，每个模型可以配置多个后端服务，支持负载均衡。下面是 api.yaml 配置文件的示例：
+Using the api.yaml configuration file, you can configure multiple models, and each model can configure multiple backend services, supporting load balancing. Below is an example of the api.yaml configuration file:
 
 ```yaml
 providers:
-  - provider: provider_name # 服务提供商名称, 如 openai、anthropic、gemini、openrouter、deepbricks，随便取名字，必填
-    base_url: https://api.your.com/v1/chat/completions # 后端服务的API地址，必填
-    api: sk-YgS6GTi0b4bEabc4C # 提供商的API Key，必填
-    model: # 至少填一个模型
-      - gpt-4o # 可以使用的模型名称，必填
-      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # 重命名模型，claude-3-5-sonnet-20240620 是服务商的模型名称，claude-3-5-sonnet 是重命名后的名字，可以使用简洁的名字代替原来复杂的名称，选填
+  - provider: provider_name # Service provider name, such as openai, anthropic, gemini, openrouter, deepbricks, arbitrary name, required
+    base_url: https://api.your.com/v1/chat/completions # Backend service API address, required
+    api: sk-YgS6GTi0b4bEabc4C # Provider's API Key, required
+    model: # At least one model
+      - gpt-4o # Usable model name, required
+      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # Rename model, claude-3-5-sonnet-20240620 is the provider's model name, claude-3-5-sonnet is the renamed name, can use a short name instead of the original complex name, optional
       - dall-e-3
 
   - provider: anthropic
     base_url: https://api.anthropic.com/v1/messages
-    api: # 支持多个 API Key，多个 key 自动开启轮训负载均衡，至少一个 key，必填
+    api: # Supports multiple API Keys, multiple keys automatically enable polling load balancing, at least one key, required
       - sk-ant-api03-bNnAOJyA-xQw_twAA
       - sk-ant-api02-bNnxxxx
     model:
-      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # 重命名模型，claude-3-5-sonnet-20240620 是服务商的模型名称，claude-3-5-sonnet 是重命名后的名字，可以使用简洁的名字代替原来复杂的名称，选填
-    tools: true # 是否支持工具，如生成代码、生成文档等，默认是 true，选填
+      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # Rename model, claude-3-5-sonnet-20240620 is the provider's model name, claude-3-5-sonnet is the renamed name, can use a short name instead of the original complex name, optional
+    tools: true # Whether to support tools, such as generating code, generating documents, etc., default is true, optional
 
   - provider: gemini
-    base_url: https://generativelanguage.googleapis.com/v1beta # base_url 支持 v1beta/v1, 仅供 Gemini 模型使用，必填
+    base_url: https://generativelanguage.googleapis.com/v1beta # base_url supports v1beta/v1, only for Gemini models, required
     api: AIzaSyAN2k6IRdgw
     model:
       - gemini-1.5-pro
-      - gemini-1.5-flash-exp-0827: gemini-1.5-flash # 重命名后，原来的模型名字 gemini-1.5-flash-exp-0827 无法使用，如果要使用原来的名字，可以在 model 中添加原来的名字，只要加上下面一行就可以使用原来的名字了
-      - gemini-1.5-flash-exp-0827 # 加上这一行，gemini-1.5-flash-exp-0827 和 gemini-1.5-flash 都可以被请求
+      - gemini-1.5-flash-exp-0827: gemini-1.5-flash # After renaming, the original model name gemini-1.5-flash-exp-0827 cannot be used, if you want to use the original name, you can add the original name in the model, just add the following line to use the original name
+      - gemini-1.5-flash-exp-0827 # Add this line, both gemini-1.5-flash-exp-0827 and gemini-1.5-flash can be requested
     tools: true
 
   - provider: vertex
-    project_id: gen-lang-client-xxxxxxxxxxxxxx #    描述： 您的Google Cloud项目ID。格式： 字符串，通常由小写字母、数字和连字符组成。获取方式： 在Google Cloud Console的项目选择器中可以找到您的项目ID。
-    private_key: "-----BEGIN PRIVATE KEY-----\nxxxxx\n-----END PRIVATE" # 描述： Google Cloud Vertex AI服务账号的私钥。格式： 一个JSON格式的字符串，包含服务账号的私钥信息。获取方式： 在Google Cloud Console中创建服务账号，生成JSON格式的密钥文件，然后将其内容设置为此环境变量的值。
-    client_email: [email protected] # 描述： Google Cloud Vertex AI服务账号的电子邮件地址。格式： 通常是形如 "[email protected]" 的字符串。获取方式： 在创建服务账号时生成，也可以在Google Cloud Console的"IAM与管理"部分查看服务账号详情获得。
+    project_id: gen-lang-client-xxxxxxxxxxxxxx # Description: Your Google Cloud project ID. Format: String, usually composed of lowercase letters, numbers, and hyphens. How to obtain: You can find your project ID in the project selector of the Google Cloud Console.
+    private_key: "-----BEGIN PRIVATE KEY-----\nxxxxx\n-----END PRIVATE" # Description: The private key of the Google Cloud Vertex AI service account. Format: A JSON formatted string containing the private key information of the service account. How to obtain: Create a service account in the Google Cloud Console, generate a JSON formatted key file, and then set its content as the value of this environment variable.
+    client_email: [email protected] # Description: The email address of the Google Cloud Vertex AI service account. Format: Usually a string like "[email protected]". How to obtain: Generated when creating the service account, you can also view the service account details in the "IAM & Admin" section of the Google Cloud Console.
     model:
       - gemini-1.5-pro
       - gemini-1.5-flash
@@ -74,7 +75,7 @@ providers:
       - claude-3-sonnet@20240229: claude-3-sonnet
       - claude-3-haiku@20240307: claude-3-haiku
     tools: true
-    notes: https://xxxxx.com/ # 可以放服务商的网址，备注信息，官方文档，选填
+    notes: https://xxxxx.com/ # Can put the provider's website, notes, official documentation, optional
 
   - provider: other-provider
     base_url: https://api.xxx.com/v1/messages
@@ -82,40 +83,40 @@ providers:
     model:
       - causallm-35b-beta2ep-q6k: causallm-35b
     tools: false
-    engine: openrouter # 强制使用某个消息格式，目前支持 gpt，claude，gemini，openrouter 原生格式，选填
+    engine: openrouter # Force the use of a specific message format, currently supports gpt, claude, gemini, openrouter native format, optional
 
 api_keys:
-  - api: sk-KjjI60Yf0JFWtfgRmXqFWyGtWUd9GZnmi3KlvowmRWpWpQRo # API Key，用户使用本服务需要 API key，必填
-    model: # 该 API Key 可以使用的模型，必填
-      - gpt-4o # 可以使用的模型名称，可以使用所有提供商提供的 gpt-4o 模型
-      - claude-3-5-sonnet # 可以使用的模型名称，可以使用所有提供商提供的 claude-3-5-sonnet 模型
-      - gemini/* # 可以使用的模型名称，仅可以使用名为 gemini 提供商提供的所有模型，其中 gemini 是 provider 名称，* 代表所有模型
+  - api: sk-KjjI60Yf0JFWtfgRmXqFWyGtWUd9GZnmi3KlvowmRWpWpQRo # API Key, required for users to use this service
+    model: # Models that this API Key can use, required
+      - gpt-4o # Usable model name, can use all gpt-4o models provided by providers
+      - claude-3-5-sonnet # Usable model name, can use all claude-3-5-sonnet models provided by providers
+      - gemini/* # Usable model name, can only use all models provided by the provider named gemini, where gemini is the provider name, * represents all models
     role: admin
 
   - api: sk-pkhf60Yf0JGyJygRmXqFQyTgWUd9GZnmi3KlvowmRWpWqrhy
     model:
-      - anthropic/claude-3-5-sonnet # 可以使用的模型名称，仅可以使用名为 anthropic 提供商提供的 claude-3-5-sonnet 模型。其他提供商的 claude-3-5-sonnet 模型不可以使用。
+      - anthropic/claude-3-5-sonnet # Usable model name, can only use the claude-3-5-sonnet model provided by the provider named anthropic. Models of other providers' claude-3-5-sonnet cannot be used.
     preferences:
-      USE_ROUND_ROBIN: true # 是否使用轮询负载均衡，true 为使用，false 为不使用，默认为 true。开启轮训后每次请求模型按照 model 配置的顺序依次请求。与 providers 里面原始的渠道顺序无关。因此你可以设置每个 API key 请求顺序不一样。
-      AUTO_RETRY: true # 是否自动重试，自动重试下一个提供商，true 为自动重试，false 为不自动重试，默认为 true
-      RATE_LIMIT: 2/min # 支持限流，每分钟最多请求次数，可以设置为整数，如 2/min，2 次每分钟、5/hour，5 次每小时、10/day，10 次每天，10/month，10 次每月，10/year，10 次每年。默认60/min，选填
+      USE_ROUND_ROBIN: true # Whether to use polling load balancing, true to use, false to not use, default is true. When polling is enabled, each request model is requested in the order configured in the model. It is not related to the original channel order in providers. Therefore, you can set different request sequences for each API key.
+      AUTO_RETRY: true # Whether to automatically retry, automatically retry the next provider, true to automatically retry, false to not automatically retry, default is true
+      RATE_LIMIT: 2/min # Supports rate limiting, maximum number of requests per minute, can be set to an integer, such as 2/min, 2 times per minute, 5/hour, 5 times per hour, 10/day, 10 times per day, 10/month, 10 times per month, 10/year, 10 times per year. Default is 60/min, optional
 
-  # 渠道级加权负载均衡配置示例
+  # Channel-level weighted load balancing configuration example
   - api: sk-KjjI60Yf0JFWtxxxxxxxxxxxxxxwmRWpWpQRo
     model:
-      - gcp1/*: 5 # 冒号后面就是权重，权���仅支持正整数。
-      - gcp2/*: 3 # 数字的大小代表权重，数字越大，请求的概率越大。
-      - gcp3/*: 2 # 在该示例中，所有渠道加起来一共有 10 个权重，及 10 个请求里面有 5 个请求会请求 gcp1/* 模型，2 个请求会请求 gcp2/* 模型，3 个请求会请求 gcp3/* 模型。
+      - gcp1/*: 5 # The number after the colon is the weight, weights only support positive integers.
+      - gcp2/*: 3 # The larger the number, the greater the probability of being requested.
+      - gcp3/*: 2 # In this example, there are a total of 10 weights for all channels, and 5 out of 10 requests will request the gcp1/* model, 2 requests will request the gcp2/* model, and 3 requests will request the gcp3/* model.
 
     preferences:
-      USE_ROUND_ROBIN: true # 当 USE_ROUND_ROBIN 必须为 true 并且上面的渠道后面没有权重时，会按照原始的渠道顺序请求，如果有权重，会按照加权后的顺序请求。
+      USE_ROUND_ROBIN: true # When USE_ROUND_ROBIN must be true and there is no weight after the channels above, it will request in the original channel order, if there is weight, it will request in the weighted order.
       AUTO_RETRY: true
 ```
 
-## 环境变量
+## Environment variables
 
-- CONFIG_URL: 配置文件的下载地址，可以是本地文件，也可以是远程文件，选填
-- TIMEOUT: 请求超时时间，默认为 20 秒，超时时间可以控制当一个渠道没有响应时，切换下一个渠道需要的时间。选填
+- CONFIG_URL: The download address of the configuration file, it can be a local file or a remote file, optional
+- TIMEOUT: Request timeout, default is 20 seconds. The timeout can control the time needed to switch to the next channel when a channel does not respond. Optional
 
 ## Docker Local Deployment
 
@@ -142,7 +143,7 @@ services:
       - ./api.yaml:/home/api.yaml
 ```
 
-CONFIG_URL 就是可以自动下载远程的配置文件。比如你在某个平台不方便修改配置文件，可以把配置文件传到某个托管服务，可以提供直链给 uni-api 下载，CONFIG_URL 就是这个直链。
+CONFIG_URL is a direct link that can automatically download remote configuration files. For example, if you find it inconvenient to modify configuration files on a certain platform, you can upload the configuration file to a hosting service and provide a direct link for uni-api to download. CONFIG_URL is this direct link.
 
 Run Docker Compose container in the background
 

README_CN.md

@@ -0,0 +1,190 @@
+# uni-api
+
+<p align="center">
+  <a href="https://t.me/uni_api">
+    <img src="https://img.shields.io/badge/Join Telegram Group-blue?&logo=telegram">
+  </a>
+   <a href="https://hub.docker.com/repository/docker/yym68686/uni-api">
+    <img src="https://img.shields.io/docker/pulls/yym68686/uni-api?color=blue" alt="docker pull">
+  </a>
+</p>
+
+[英文](./README.md) | [中文](./README_CN.md)
+
+## Introduction
+
+如果个人使用的话，one/new-api 过于复杂，有很多个人不需要使用的商用功能，如果你不想要复杂的前端界面，有想要支持的模型多一点，可以试试 uni-api。这是一个统一管理大模型API的项目，可以通过一个统一的API接口调用多个后端服务，统一转换为 OpenAI 格式，支持负载均衡。目前支持的后端服务有：OpenAI、Anthropic、Gemini、Vertex、DeepBricks、OpenRouter 等。
+
+## Features
+
+- 无前端，纯配置文件配置 API 渠道。只要写一个文件就能运行起一个属于自己的 API 站，文档有详细的配置指南，小白友好。
+- 统一管理多个后端服务，支持 OpenAI、Deepseek、DeepBricks、OpenRouter 等其他API 是 OpenAI 格式的提供商。支持 OpenAI Dalle-3 图像生成。
+- 同时支持 Anthropic、Gemini、Vertex API。Vertex 同时支持 Claude 和 Gemini API。
+- 支持 OpenAI、 Anthropic、Gemini、Vertex 原生 tool use 函数调用。
+- 支持 OpenAI、Anthropic、Gemini、Vertex 原生识图 API。
+- 支持四种负载均衡。
+  1. 支持渠道级加权负载均衡，可以根据不同的渠道权重分配请求。默认不开启，需要配置渠道权重。
+  2. 支持 Vertex 区域级负载均衡，支持 Vertex 高并发，最高可将 Gemini，Claude 并发提高 （API数量 * 区域数量） 倍。自动开启不需要额外配置。
+  3. 除了 Vertex 区域级负载均衡，所有 API 均支持渠道级顺序负载均衡，提高沉浸式翻译体验。自动开启不需要额外配置。
+  4. 支持单个渠道多个 API Key 自动开启 API key 级别的轮训负载均衡。
+- 支持自动重试，当一个 API 渠道响应失败时，自动重试下一个 API 渠道。
+- 支持细粒度的权限控制。支持使用通配符设置 API key 可用渠道的特定模型。
+- 支持限流，可以设置每分钟最多请求次数，可以设置为整数，如 2/min，2 次每分钟、5/hour，5 次每小时、10/day，10 次每天，10/month，10 次每月，10/year，10 次每年。默认60/min。
+
+## Configuration
+
+使用 api.yaml 配置文件，可以配置多个模型，每个模型可以配置多个后端服务，支持负载均衡。下面是 api.yaml 配置文件的示例：
+
+```yaml
+providers:
+  - provider: provider_name # 服务提供商名称, 如 openai、anthropic、gemini、openrouter、deepbricks，随便取名字，必填
+    base_url: https://api.your.com/v1/chat/completions # 后端服务的API地址，必填
+    api: sk-YgS6GTi0b4bEabc4C # 提供商的API Key，必填
+    model: # 至少填一个模型
+      - gpt-4o # 可以使用的模型名称，必填
+      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # 重命名模型，claude-3-5-sonnet-20240620 是服务商的模型名称，claude-3-5-sonnet 是重命名后的名字，可以使用简洁的名字代替原来复杂的名称，选填
+      - dall-e-3
+
+  - provider: anthropic
+    base_url: https://api.anthropic.com/v1/messages
+    api: # 支持多个 API Key，多个 key 自动开启轮训负载均衡，至少一个 key，必填
+      - sk-ant-api03-bNnAOJyA-xQw_twAA
+      - sk-ant-api02-bNnxxxx
+    model:
+      - claude-3-5-sonnet-20240620: claude-3-5-sonnet # 重命名模型，claude-3-5-sonnet-20240620 是服务商的模型名称，claude-3-5-sonnet 是重命名后的名字，可以使用简洁的名字代替原来复杂的名称，选填
+    tools: true # 是否支持工具，如生成代码、生成文档等，默认是 true，选填
+
+  - provider: gemini
+    base_url: https://generativelanguage.googleapis.com/v1beta # base_url 支持 v1beta/v1, 仅供 Gemini 模型使用，必填
+    api: AIzaSyAN2k6IRdgw
+    model:
+      - gemini-1.5-pro
+      - gemini-1.5-flash-exp-0827: gemini-1.5-flash # 重命名后，原来的模型名字 gemini-1.5-flash-exp-0827 无法使用，如果要使用原来的名字，可以在 model 中添加原来的名字，只要加上下面一行就可以使用原来的名字了
+      - gemini-1.5-flash-exp-0827 # 加上这一行，gemini-1.5-flash-exp-0827 和 gemini-1.5-flash 都可以被请求
+    tools: true
+
+  - provider: vertex
+    project_id: gen-lang-client-xxxxxxxxxxxxxx #    描述： 您的Google Cloud项目ID。格式： 字符串，通常由小写字母、数字和连字符组成。获取方式： 在Google Cloud Console的项目选择器中可以找到您的项目ID。
+    private_key: "-----BEGIN PRIVATE KEY-----\nxxxxx\n-----END PRIVATE" # 描述： Google Cloud Vertex AI服务账号的私钥。格式： 一个JSON格式的字符串，包含服务账号的私钥信息。获��方式： 在Google Cloud Console中创建服务账号，生成JSON格式的密钥文件，然后将其内容设置为此环境变量的值。
+    client_email: [email protected] # 描述： Google Cloud Vertex AI服务账号的电子邮件地址。格式： 通常是形如 "[email protected]" 的字符串。获取方式： 在创建服务账号时生成，也可以在Google Cloud Console的"IAM与管理"部分查看服务账号详情获得。
+    model:
+      - gemini-1.5-pro
+      - gemini-1.5-flash
+      - claude-3-5-sonnet@20240620: claude-3-5-sonnet
+      - claude-3-opus@20240229: claude-3-opus
+      - claude-3-sonnet@20240229: claude-3-sonnet
+      - claude-3-haiku@20240307: claude-3-haiku
+    tools: true
+    notes: https://xxxxx.com/ # 可以放服务商的网址，备注信息，官方文档，选填
+
+  - provider: other-provider
+    base_url: https://api.xxx.com/v1/messages
+    api: sk-bNnAOJyA-xQw_twAA
+    model:
+      - causallm-35b-beta2ep-q6k: causallm-35b
+    tools: false
+    engine: openrouter # 强制使用某个消息格式，目前支持 gpt，claude，gemini，openrouter 原生格式，选填
+
+api_keys:
+  - api: sk-KjjI60Yf0JFWtfgRmXqFWyGtWUd9GZnmi3KlvowmRWpWpQRo # API Key，用户使用本服务需要 API key，必填
+    model: # 该 API Key 可以使用的模型，必填
+      - gpt-4o # 可以使用的模型名称，可以使用所有提供商提供的 gpt-4o 模型
+      - claude-3-5-sonnet # 可以使用的模型名称，可以使用所有提供商提供的 claude-3-5-sonnet 模型
+      - gemini/* # 可以使用的模型名称，仅可以使用名为 gemini 提供商提供的所有模型，其中 gemini 是 provider 名称，* 代表所有模型
+    role: admin
+
+  - api: sk-pkhf60Yf0JGyJygRmXqFQyTgWUd9GZnmi3KlvowmRWpWqrhy
+    model:
+      - anthropic/claude-3-5-sonnet # 可以使用的模型名称，仅可以使用名为 anthropic 提供商提供的 claude-3-5-sonnet 模型。其他提供商的 claude-3-5-sonnet 模型不可以使用。
+    preferences:
+      USE_ROUND_ROBIN: true # 是否使用轮询负载均衡，true 为使用，false 为不使用，默认为 true。开启轮训后每次请求模型按照 model 配置的顺序依次请求。与 providers 里面原始的渠道顺序无关。因此你可以设置每个 API key 请求顺序不一样。
+      AUTO_RETRY: true # 是否自动重试，自动重试下一个提供商，true 为自动重试，false 为不自动重试，默认为 true
+      RATE_LIMIT: 2/min # 支持限流，每分钟最多请求次数，可以设置为整数，如 2/min，2 次每分钟、5/hour，5 次每小时、10/day，10 次每天，10/month，10 次每月，10/year，10 次每年。默认60/min，选填
+
+  # 渠道级加权负载均衡配置示例
+  - api: sk-KjjI60Yf0JFWtxxxxxxxxxxxxxxwmRWpWpQRo
+    model:
+      - gcp1/*: 5 # 冒号后面就是权重，权重仅支持正整数。
+      - gcp2/*: 3 # 数字的大小代表权重，数字越大，请求的概率越大。
+      - gcp3/*: 2 # 在该示例中，所有渠道加起来一共有 10 个权重，及 10 个请求里面有 5 个请求会请求 gcp1/* 模型，2 个请求会请求 gcp2/* 模型，3 个请求会请求 gcp3/* 模型。
+
+    preferences:
+      USE_ROUND_ROBIN: true # 当 USE_ROUND_ROBIN 必须为 true 并且上面的渠道后面没有权重时，会按照原始的渠道顺序请求，如果有权重，会按照加权后的顺序请求。
+      AUTO_RETRY: true
+```
+
+## 环境变量
+
+- CONFIG_URL: 配置文件的下载地址，可以是本地文件，也可以是远程文件，选填
+- TIMEOUT: 请求超时时间，默认为 20 秒，超时时间可以控制当一个渠道没有响应时，切换下一个渠道需要的时间。选填
+
+## Docker Local Deployment
+
+Start the container
+
+```bash
+docker run --user root -p 8001:8000 --name uni-api -dit \
+-v ./api.yaml:/home/api.yaml \
+yym68686/uni-api:latest
+```
+
+Or if you want to use Docker Compose, here is a docker-compose.yml example:
+
+```yaml
+services:
+  uni-api:
+    container_name: uni-api
+    image: yym68686/uni-api:latest
+    environment:
+      - CONFIG_URL=http://file_url/api.yaml
+    ports:
+      - 8001:8000
+    volumes:
+      - ./api.yaml:/home/api.yaml
+```
+
+CONFIG_URL 就是可以自动下载远程的配置文件。比如你在某个平台不方便修改配置文件，可以把配置文件传到某个托管服务，可以提供直链给 uni-api 下载，CONFIG_URL 就是这个直链。
+
+Run Docker Compose container in the background
+
+```bash
+docker-compose pull
+docker-compose up -d
+```
+
+Docker build
+
+```bash
+docker build --no-cache -t uni-api:latest -f Dockerfile --platform linux/amd64 .
+docker tag uni-api:latest yym68686/uni-api:latest
+docker push yym68686/uni-api:latest
+```
+
+One-Click Restart Docker Image
+
+```bash
+set -eu
+docker pull yym68686/uni-api:latest
+docker rm -f uni-api
+docker run --user root -p 8001:8000 -dit --name uni-api \
+-e CONFIG_URL=http://file_url/api.yaml \
+-v ./api.yaml:/home/api.yaml \
+yym68686/uni-api:latest
+docker logs -f uni-api
+```
+
+RESTful curl test
+
+```bash
+curl -X POST http://127.0.0.1:8000/v1/chat/completions \
+-H "Content-Type: application/json" \
+-H "Authorization: Bearer ${API}" \
+-d '{"model": "gpt-4o","messages": [{"role": "user", "content": "Hello"}],"stream": true}'
+```
+
+
+## Star History
+
+<a href="https://github.com/yym68686/uni-api/stargazers">
+        <img width="500" alt="Star History Chart" src="https://api.star-history.com/svg?repos=yym68686/uni-api&type=Date">
+</a>

test/parse_markdown.py

@@ -0,0 +1,159 @@
+class MarkdownEntity:
+    def __init__(self, content: str, entity_type: str):
+        self.content = content
+        self.entity_type = entity_type
+
+    def __repr__(self):
+        return f'<{self.entity_type}: {self.content}>'
+
+class Title(MarkdownEntity):
+    def __init__(self, content: str, level: int):
+        super().__init__(content, 'Title')
+        self.level = level
+
+class CodeBlock(MarkdownEntity):
+    def __init__(self, content: str, language: str = 'python'):
+        super().__init__(content, 'CodeBlock')
+        self.language = language
+
+class ListItem(MarkdownEntity):
+    def __init__(self, content: str):
+        super().__init__(content, 'ListItem')
+
+class Link(MarkdownEntity):
+    def __init__(self, content: str, url: str):
+        super().__init__(content, 'Link')
+        self.url = url
+
+class EmptyLine(MarkdownEntity):
+    def __init__(self, content: str):
+        super().__init__(content, 'EmptyLine')
+
+class Paragraph(MarkdownEntity):
+    def __init__(self, content: str):
+        super().__init__(content, 'Paragraph')
+
+def parse_markdown(lines, delimiter='\n\n'):
+    entities = []
+    current_code_block = []
+    in_code_block = False
+    language = None
+
+    for line in lines:
+        # line = line.strip()
+
+        if line.startswith('#'):
+            level = line.count('#')
+            title_content = line[level:].strip()
+            entities.append(Title(title_content, level))
+
+        elif line.startswith('```'):
+            if in_code_block and language:
+                entities.append(CodeBlock(''.join(current_code_block), language))
+                current_code_block = []
+                in_code_block = False
+                language = None
+            else:
+                in_code_block = True
+                language = line.lstrip('`').strip()
+
+        elif in_code_block:
+            current_code_block.append(line)
+
+        elif '[' in line and ']' in line and '(' in line and ')' in line and line.count('[') == 1:
+            start = line.index('[') + 1
+            end = line.index(']')
+            url_start = line.index('(') + 1
+            url_end = line.index(')')
+            link_text = line[start:end].strip()
+            link_url = line[url_start:url_end].strip()
+            entities.append(Link(link_text, link_url))
+
+        elif line == delimiter:
+            entities.append(EmptyLine(line))
+
+        elif line:
+            entities.append(Paragraph(line))
+
+    return entities
+
+def convert_entities_to_text(entities):
+    result = []
+    for entity in entities:
+        if isinstance(entity, Title):
+            result.append(f"{'#' * entity.level} {entity.content}")
+        elif isinstance(entity, CodeBlock):
+            code = entity.content.lstrip('\n').rstrip('\n')
+            result.append(f"```{entity.language}\n{code}\n```")
+        elif isinstance(entity, ListItem):
+            result.append(f"- {entity.content}")
+        elif isinstance(entity, Link):
+            result.append(f"[{entity.content}]({entity.url})")
+        elif isinstance(entity, EmptyLine):
+            result.append(f"{entity.content}")
+        elif isinstance(entity, Paragraph):
+            result.append(f"{entity.content}")
+    return ''.join(result)
+
+def save_text_to_file(text: str, file_path: str):
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(text)
+
+def process_markdown_entities_and_save(entities, file_path, raw_text=None):
+    # Step 1: Convert entities to text
+    text_output = convert_entities_to_text(entities)
+    if raw_text and raw_text != text_output:
+        raise ValueError("The text output does not match the raw text input.")
+    # Step 2: Save to file
+    save_text_to_file(text_output, file_path)
+
+def read_markdown_file(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        return file.read()
+
+def split_markdown(text, delimiter='\n\n'):
+    # 使用两个换行符作为分割标记，分割段落
+    # 创建一个新的列表来存储结果
+    paragraphs = text.split(delimiter)
+    result = []
+
+    # 遍历分割后的段落，在它们之间插入空行实体
+    for i, paragraph in enumerate(paragraphs):
+        if i > 0:
+            # 在非第一段之前插入空行实体
+            result.append(delimiter)
+
+        # 添加当前段落
+        result.append(paragraph)
+
+    return result
+
+def get_entities_from_markdown_file(file_path, delimiter='\n\n'):
+    # 读取 Markdown 文件
+    markdown_text = read_markdown_file(file_path)
+
+    # 分割 Markdown 文档
+    paragraphs = split_markdown(markdown_text, delimiter=delimiter)
+
+    # 解析 Markdown 文档
+    return parse_markdown(paragraphs, delimiter=delimiter)
+
+if __name__ == '__main__':
+    markdown_file_path = "README_CN.md"  # 替换为你的 Markdown 文件路径
+
+    # 读取 Markdown 文件
+    delimiter = '\n'
+    markdown_text = read_markdown_file(markdown_file_path)
+    paragraphs = split_markdown(markdown_text, delimiter=delimiter)
+    parsed_entities = parse_markdown(paragraphs, delimiter=delimiter)
+
+    # # 显示解析结果
+    # result = [str(entity) for entity in parsed_entities]
+    # for idx, entity in enumerate(result):
+    #     print(f"段落 {idx + 1} 解析：{entity}\n")
+
+    # 保存到文件
+    output_file_path = "output.md"
+    process_markdown_entities_and_save(parsed_entities, output_file_path, raw_text=markdown_text)
+
+    print(f"Markdown 文档已保存到 {output_file_path}")

test/translate_md.py

@@ -0,0 +1,50 @@
+import os
+from ModelMerge import chatgpt
+from parse_markdown import get_entities_from_markdown_file, process_markdown_entities_and_save
+
+def translate_text(text, agent):
+    result = agent.ask(text)
+    return result
+
+def translate(input_file_path, output_file_path="output.md", language="English", api_key=None, api_url="https://api.openai.com/v1/chat/completions", engine="gpt-4o"):
+    if not api_key:
+        raise ValueError("API key is required for translation.")
+    translator_prompt = (
+        "You are a translation engine, you can only translate text and cannot interpret it, and do not explain. "
+        "Translate the text to {}, please do not explain any sentences, just translate or leave them as they are. "
+        "Retain all spaces and line breaks in the original text. "
+        "Please do not wrap the code in code blocks, I will handle it myself. "
+        "If the code has comments, you should translate the comments as well. "
+        "This is the content you need to translate: "
+    ).format(language)
+
+    agent = chatgpt(
+        api_key=api_key,
+        api_url=api_url,
+        engine=engine,
+        system_prompt=translator_prompt,
+        use_plugins=False
+    )
+
+    # 读取 Markdown 文件
+    raw_paragraphs = get_entities_from_markdown_file(input_file_path, delimiter='\n')
+    target_paragraphs = raw_paragraphs
+
+    # 逐段翻译
+    for index, paragraph in enumerate(raw_paragraphs):
+        if paragraph.content and paragraph.content.strip() != "":
+            translated_text = translate_text(paragraph.content, agent)
+            if translated_text:
+                target_paragraphs[index].content = translated_text
+
+    # 输出翻译结果
+    process_markdown_entities_and_save(target_paragraphs, output_file_path)
+
+if __name__ == "__main__":
+    input_file_path = "README_CN.md"
+    output_file_path = "README.md"
+    language = "English"
+    api_key = os.getenv("API")
+    api_url = os.getenv("API_URL")
+    engine = "gpt-4o"
+    translate(input_file_path, output_file_path, language, api_key, api_url, engine)