13 |
15 |
16 | 
23 |
24 |
25 | 支持 DeepSeek R1 & GPT 4 · 基于文件问答 · LLM本地部署 · 联网搜索 · Agent 助理 · 支持 Fine-tune 26 |
27 | 视频教程 28 | · 29 | 2.0介绍视频 30 | || 31 | 在线体验 32 | · 33 | 一键部署 34 | 35 | 36 |
196 |
197 | 
198 |
--------------------------------------------------------------------------------
/config_example.json:
--------------------------------------------------------------------------------
1 | {
2 | // 各配置具体说明，见 [https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用教程#配置-configjson]
3 |
4 | //== API 配置 ==
5 | "openai_api_key": "", // 你的 OpenAI API Key，一般必填，若空缺则需在图形界面中填入API Key
6 | "deepseek_api_key": "", // 你的 DeepSeek API Key，用于 DeepSeek Chat 和 Reasoner(R1) 对话模型
7 | "google_genai_api_key": "", // 你的 Google Gemini API Key ，用于 Google Gemini 对话模型
8 | "google_genai_api_host": "generativelanguage.googleapis.com", // 你的 Google Gemini API Host 地址，一般无需更改
9 | "xmchat_api_key": "", // 你的 xmchat API Key，用于 XMChat 对话模型
10 | "minimax_api_key": "", // 你的 MiniMax API Key，用于 MiniMax 对话模型
11 | "minimax_group_id": "", // 你的 MiniMax Group ID，用于 MiniMax 对话模型
12 | "midjourney_proxy_api_base": "https://xxx/mj", // 你的 https://github.com/novicezk/midjourney-proxy 代理地址
13 | "midjourney_proxy_api_secret": "", // 你的 MidJourney Proxy API Secret，用于鉴权访问 api，可选
14 | "midjourney_discord_proxy_url": "", // 你的 MidJourney Discord Proxy URL，用于对生成对图进行反代，可选
15 | "midjourney_temp_folder": "./tmp", // 你的 MidJourney 临时文件夹，用于存放生成的图片，填空则关闭自动下载切图（直接显示MJ的四宫格图）
16 | "spark_appid": "", // 你的 讯飞星火大模型 API AppID，用于讯飞星火大模型对话模型
17 | "spark_api_key": "", // 你的 讯飞星火大模型 API Key，用于讯飞星火大模型对话模型
18 | "spark_api_secret": "", // 你的 讯飞星火大模型 API Secret，用于讯飞星火大模型对话模型
19 | "claude_api_secret":"",// 你的 Claude API Secret，用于 Claude 对话模型
20 | "ernie_api_key": "",// 你的文心一言在百度云中的API Key，用于文心一言对话模型
21 | "ernie_secret_key": "",// 你的文心一言在百度云中的Secret Key，用于文心一言对话模型
22 | "ollama_host": "", // 你的 Ollama Host，用于 Ollama 对话模型
23 | "huggingface_auth_token": "", // 你的 Hugging Face API Token，用于访问有限制的模型
24 | "groq_api_key": "", // 你的 Groq API Key，用于 Groq 对话模型(https://console.groq.com/)
25 |
26 | //== Azure ==
27 | "openai_api_type": "openai", // 可选项：azure, openai
28 | "azure_openai_api_key": "", // 你的 Azure OpenAI API Key，用于 Azure OpenAI 对话模型
29 | "azure_openai_api_base_url": "", // 你的 Azure Base URL
30 | "azure_openai_api_version": "2023-05-15", // 你的 Azure OpenAI API 版本
31 | "azure_deployment_name": "", // 你的 Azure OpenAI Chat 模型 Deployment 名称
32 | "azure_embedding_deployment_name": "", // 你的 Azure OpenAI Embedding 模型 Deployment 名称
33 | "azure_embedding_model_name": "text-embedding-ada-002", // 你的 Azure OpenAI Embedding 模型名称
34 |
35 | //== 基础配置 ==
36 | "language": "auto", // 界面语言，可选"auto", "zh_CN", "en_US", "ja_JP", "ko_KR", "sv_SE", "ru_RU", "vi_VN"
37 | "users": [], // 用户列表，[["用户名1", "密码1"], ["用户名2", "密码2"], ...]
38 | "admin_list": [], // 管理员列表，["用户名1", "用户名2", ...] 只有管理员可以重启服务
39 | "local_embedding": false, //是否在本地编制索引
40 | "hide_history_when_not_logged_in": false, //未登录情况下是否不展示对话历史
41 | "check_update": true, //是否启用检查更新
42 | "default_model": "GPT3.5 Turbo", // 默认模型
43 | "chat_name_method_index": 2, // 选择对话名称的方法。0: 使用日期时间命名；1: 使用第一条提问命名，2: 使用模型自动总结
44 | "bot_avatar": "default", // 机器人头像，可填写本地或网络图片链接，或者"none"（不显示头像）
45 | "user_avatar": "default", // 用户头像，可填写本地或网络图片链接，或者"none"（不显示头像）
46 |
47 | //== API 用量 ==
48 | "show_api_billing": false, //是否显示OpenAI API用量（启用需要填写sensitive_id）
49 | "sensitive_id": "", // 你 OpenAI 账户的 Sensitive ID，用于查询 API 用量
50 | "usage_limit": 120, // 该 OpenAI API Key 的当月限额，单位：美元，用于计算百分比和显示上限
51 | "legacy_api_usage": false, // 是否使用旧版 API 用量查询接口（OpenAI现已关闭该接口，但是如果你在使用第三方 API，第三方可能仍然支持此接口）
52 |
53 | //== 川虎助理设置 ==
54 | "GOOGLE_CSE_ID": "", //谷歌搜索引擎ID，用于川虎助理Pro模式，获取方式请看 https://stackoverflow.com/questions/37083058/programmatically-searching-google-in-python-using-custom-search
55 | "GOOGLE_API_KEY": "", //谷歌API Key，用于川虎助理Pro模式
56 | "WOLFRAM_ALPHA_APPID": "", //Wolfram Alpha API Key，用于川虎助理Pro模式，获取方式请看 https://products.wolframalpha.com/api/
57 | "SERPAPI_API_KEY": "", //SerpAPI API Key，用于川虎助理Pro模式，获取方式请看 https://serpapi.com/
58 |
59 | //== 文档处理与显示 ==
60 | "latex_option": "default", // LaTeX 公式渲染策略，可选"default", "strict", "all"或者"disabled"
61 | "advance_docs": {
62 | "pdf": {
63 | "two_column": false, // 是否认为PDF是双栏的
64 | "formula_ocr": true // 是否使用OCR识别PDF中的公式
65 | }
66 | },
67 |
68 | //== 高级配置 ==
69 | // 是否多个API Key轮换使用
70 | "multi_api_key": false,
71 | "hide_my_key": false, // 如果你想在UI中隐藏 API 密钥输入框，将此值设置为 true
72 | // "available_models": ["GPT3.5 Turbo", "GPT4 Turbo", "GPT4 Vision"], // 可用的模型列表，将覆盖默认的可用模型列表
73 | // "extra_models": ["模型名称3", "模型名称4", ...], // 额外的模型，将添加到可用的模型列表之后
74 | // "extra_model_metadata": {
75 | // "GPT-3.5 Turbo Keldos": {
76 | // "model_name": "gpt-3.5-turbo",
77 | // "description": "GPT-3.5 Turbo is a large language model trained by OpenAI. It is the latest version of the GPT series of models, and is known for its ability to generate human-like text.",
78 | // "model_type": "OpenAI",
79 | // "multimodal": false,
80 | // "api_host": "https://www.example.com",
81 | // "token_limit": 4096,
82 | // "max_generation": 4096,
83 | // },
84 | // }
85 | // "api_key_list": [
86 | // "sk-xxxxxxxxxxxxxxxxxxxxxxxx1",
87 | // "sk-xxxxxxxxxxxxxxxxxxxxxxxx2",
88 | // "sk-xxxxxxxxxxxxxxxxxxxxxxxx3"
89 | // ],
90 | // "rename_model": "GPT-4o-mini", //指定默认命名模型
91 | // 自定义OpenAI API Base
92 | // "openai_api_base": "https://api.openai.com",
93 | // 自定义使用代理（请替换代理URL）
94 | // "https_proxy": "http://127.0.0.1:1079",
95 | // "http_proxy": "http://127.0.0.1:1079",
96 | // 自定义端口、自定义ip（请替换对应内容）
97 | // "server_name": "0.0.0.0",
98 | // "server_port": 7860,
99 | // 如果要share到gradio，设置为true
100 | // "share": false,
101 | //如果不想自动打开浏览器，设置为false
102 | //"autobrowser": false
103 | }
104 |
--------------------------------------------------------------------------------
/configs/ds_config_chatbot.json:
--------------------------------------------------------------------------------
1 | {
2 | "fp16": {
3 | "enabled": false
4 | },
5 | "bf16": {
6 | "enabled": true
7 | },
8 | "comms_logger": {
9 | "enabled": false,
10 | "verbose": false,
11 | "prof_all": false,
12 | "debug": false
13 | },
14 | "steps_per_print": 20000000000000000,
15 | "train_micro_batch_size_per_gpu": 1,
16 | "wall_clock_breakdown": false
17 | }
18 |
--------------------------------------------------------------------------------
/locale/extract_locale.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import logging
3 | import os
4 | import re
5 | import sys
6 |
7 | import aiohttp
8 | import commentjson
9 | import commentjson as json
10 |
11 | asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
12 |
13 | with open("config.json", "r", encoding="utf-8") as f:
14 | config = commentjson.load(f)
15 | api_key = config["openai_api_key"]
16 | url = config["openai_api_base"] + "/v1/chat/completions" if "openai_api_base" in config else "https://api.openai.com/v1/chat/completions"
17 |
18 |
19 | def get_current_strings():
20 | pattern = r'i18n\s*\(\s*["\']([^"\']*(?:\)[^"\']*)?)["\']\s*\)'
21 |
22 | # Load the .py files
23 | contents = ""
24 | for dirpath, dirnames, filenames in os.walk("."):
25 | for filename in filenames:
26 | if filename.endswith(".py"):
27 | filepath = os.path.join(dirpath, filename)
28 | with open(filepath, 'r', encoding='utf-8') as f:
29 | contents += f.read()
30 | # Matching with regular expressions
31 | matches = re.findall(pattern, contents, re.DOTALL)
32 | data = {match.strip('()"'): '' for match in matches}
33 | fixed_data = {} # fix some keys
34 | for key, value in data.items():
35 | if "](" in key and key.count("(") != key.count(")"):
36 | fixed_data[key+")"] = value
37 | else:
38 | fixed_data[key] = value
39 |
40 | return fixed_data
41 |
42 |
43 | def get_locale_strings(filename):
44 | try:
45 | with open(filename, "r", encoding="utf-8") as f:
46 | locale_strs = json.load(f)
47 | except FileNotFoundError:
48 | locale_strs = {}
49 | return locale_strs
50 |
51 |
52 | def sort_strings(existing_translations):
53 | # Sort the merged data
54 | sorted_translations = {}
55 | # Add entries with (NOT USED) in their values
56 | for key, value in sorted(existing_translations.items(), key=lambda x: x[0]):
57 | if "(🔴NOT USED)" in value:
58 | sorted_translations[key] = value
59 | # Add entries with empty values
60 | for key, value in sorted(existing_translations.items(), key=lambda x: x[0]):
61 | if value == "":
62 | sorted_translations[key] = value
63 | # Add the rest of the entries
64 | for key, value in sorted(existing_translations.items(), key=lambda x: x[0]):
65 | if value != "" and "(NOT USED)" not in value:
66 | sorted_translations[key] = value
67 |
68 | return sorted_translations
69 |
70 |
71 | async def auto_translate(str, language):
72 | headers = {
73 | "Content-Type": "application/json",
74 | "Authorization": f"Bearer {api_key}",
75 | "temperature": f"{0}",
76 | }
77 | payload = {
78 | "model": "gpt-3.5-turbo",
79 | "messages": [
80 | {
81 | "role": "system",
82 | "content": f"You are a translation program;\nYour job is to translate user input into {language};\nThe content you are translating is a string in the App;\nDo not explain emoji;\nIf input is only a emoji, please simply return origin emoji;\nPlease ensure that the translation results are concise and easy to understand."
83 | },
84 | {"role": "user", "content": f"{str}"}
85 | ],
86 | }
87 |
88 | async with aiohttp.ClientSession() as session:
89 | async with session.post(url, headers=headers, json=payload) as response:
90 | data = await response.json()
91 | return data["choices"][0]["message"]["content"]
92 |
93 |
94 | async def main(auto=False):
95 | current_strs = get_current_strings()
96 | locale_files = []
97 | # 遍历locale目录下的所有json文件
98 | for dirpath, dirnames, filenames in os.walk("locale"):
99 | for filename in filenames:
100 | if filename.endswith(".json"):
101 | locale_files.append(os.path.join(dirpath, filename))
102 |
103 |
104 | for locale_filename in locale_files:
105 | if "zh_CN" in locale_filename:
106 | continue
107 | try:
108 | locale_strs = get_locale_strings(locale_filename)
109 | except json.decoder.JSONDecodeError:
110 | import traceback
111 | traceback.print_exc()
112 | logging.error(f"Error decoding {locale_filename}")
113 | continue
114 |
115 | # Add new keys
116 | new_keys = []
117 | for key in current_strs:
118 | if key not in locale_strs:
119 | new_keys.append(key)
120 | locale_strs[key] = ""
121 | print(f"{locale_filename[7:-5]}'s new str: {len(new_keys)}")
122 | # Add (NOT USED) to invalid keys
123 | for key in locale_strs:
124 | if key not in current_strs:
125 | locale_strs[key] = "(🔴NOT USED)" + locale_strs[key]
126 | print(f"{locale_filename[7:-5]}'s invalid str: {len(locale_strs) - len(current_strs)}")
127 |
128 | locale_strs = sort_strings(locale_strs)
129 |
130 | if auto:
131 | tasks = []
132 | non_translated_keys = []
133 | for key in locale_strs:
134 | if locale_strs[key] == "":
135 | non_translated_keys.append(key)
136 | tasks.append(auto_translate(key, locale_filename[7:-5]))
137 | results = await asyncio.gather(*tasks)
138 | for key, result in zip(non_translated_keys, results):
139 | locale_strs[key] = "(🟡REVIEW NEEDED)" + result
140 | print(f"{locale_filename[7:-5]}'s auto translated str: {len(non_translated_keys)}")
141 |
142 | with open(locale_filename, 'w', encoding='utf-8') as f:
143 | json.dump(locale_strs, f, ensure_ascii=False, indent=4)
144 |
145 |
146 | if __name__ == "__main__":
147 | auto = False
148 | if len(sys.argv) > 1 and sys.argv[1] == "--auto":
149 | auto = True
150 | asyncio.run(main(auto))
151 |
--------------------------------------------------------------------------------
/locale/zh_CN.json:
--------------------------------------------------------------------------------
1 | {
2 | "gpt3.5turbo_description": "GPT-3.5 Turbo 是由 OpenAI 开发的一款仅限文本的大型语言模型。它基于 GPT-3 模型，并已经在大量数据上进行了微调。最新版本的 GPT-3.5 Turbo 进行了性能和精度优化，支持最大 16k tokens 的上下文窗口和最大 4096 tokens 的响应长度。此模型始终使用可用的最新版本的 GPT-3.5 Turbo。",
3 | "gpt3.5turbo_instruct_description": "GPT3.5 Turbo Instruct 是 OpenAI 开发的文本补全模型，具有与 GPT-3 时代模型相似的功能。它兼容旧版的 Completions 端点，但不兼容 Chat Completions。该模型的上下文窗口为 4096 个 tokens。",
4 | "gpt3.5turbo_16k_description": "旧版的 GPT-3.5 Turbo 模型，具有 16k tokens 的上下文窗口。",
5 | "gpt4_description": "GPT-4 是 OpenAI 开发的一款仅限文本的大型语言模型。它具有 8192 个 tokens 的上下文窗口和 4096 个 tokens 的最大响应长度。该模型始终使用可用的最新版本的 GPT-4。建议使用 GPT-4 Turbo 以获得更好的性能、更快的速度和更低的成本。",
6 | "gpt4_32k_description": "GPT-4 32K 是 OpenAI 开发的一个仅限文本的大型语言模型。它具有 32,000 tokens 的上下文窗口和 4,096 tokens 的最大响应长度。这个模型从未广泛推出,建议使用 GPT-4 Turbo。",
7 | "gpt4turbo_description": "GPT-4 Turbo 是由 OpenAI 开发的一款多模态大型语言模型。它在广泛的自然语言处理任务上提供最先进的性能，包括文本生成、翻译、摘要、视觉问题回答等。GPT-4 Turbo 拥有最大 128k tokens 的上下文窗口和最大 4096 tokens 的响应长度。此模型始终使用可用的最新版本的 GPT-4 Turbo。",
8 | "claude3_haiku_description": "Claude3 Haiku 是由 Anthropic 开发的一款多模态大型语言模型。它是 Claude 3 模型家族中最快、最紧凑的模型，旨在实现近乎即时的响应速度，但是性能不如 Sonnet 和 Opus。Claude3 Haiku 有最大 200k tokens 的上下文窗口和最大 4096 tokens 的响应长度。此模型始终使用可用的最新版本的 Claude3 Haiku。",
9 | "claude3_sonnet_description": "Claude3 Sonnet 是由 Anthropic 开发的一款多模态大型语言模型。它在智能与速度之间保持最佳平衡，适用于企业工作负载和大规模 AI 部署。Claude3 Sonnet 拥有最大 200k tokens 的上下文窗口和最大 4096 tokens 的响应长度。此模型始终使用可用的最新版本的 Claude3 Sonnet。",
10 | "claude3_opus_description": "Claude3 Opus 是由 Anthropic 开发的一款多模态大型语言模型。它是 Claude 3 模型家族中最智能、最大的模型，能够在高度复杂的任务上呈现最顶尖的性能，呈现出类似人类的理解能力。Claude3 Opus 拥有最大 200k tokens 的上下文窗口和最大 4096 tokens 的响应长度。此模型始终使用可用的最新版本的 Claude3 Opus。",
11 | "groq_llama3_8b_description": "采用 [Groq](https://console.groq.com/) 的 LLaMA 3 8B。Groq 是一个非常快速的语言模型推理服务。",
12 | "groq_llama3_70b_description": "采用 [Groq](https://console.groq.com/) 的 LLaMA 3 70B。Groq 是一个非常快速的语言模型推理服务。",
13 | "groq_mixtral_8x7b_description": "采用 [Groq](https://console.groq.com/) 的 Mixtral 8x7B。Groq 是一个非常快速的语言模型推理服务。",
14 | "groq_gemma_7b_description": "采用 [Groq](https://console.groq.com/) 的 Gemma 7B。Groq 是一个非常快速的语言模型推理服务。",
15 | "chuanhu_description": "一个能使用多种工具解决复杂问题的智能体。",
16 | "gpt_default_slogan": "今天能帮您些什么？",
17 | "claude_default_slogan": "我能帮您什么忙？",
18 | "chuanhu_slogan": "川虎今天能帮你做些什么？",
19 | "chuanhu_question_1": "今天杭州天气如何？",
20 | "chuanhu_question_2": "最近 Apple 发布了什么新品？",
21 | "chuanhu_question_3": "现在显卡的价格如何？",
22 | "chuanhu_question_4": "TikTok 上有什么新梗？",
23 | "gpt4o_description": "OpenAI 的最先进的多模态旗舰模型，比 GPT-4 Turbo 更便宜、更快。",
24 | "gpt4omini_description": "OpenAI 的经济实惠且智能的小型模型，适用于快速、轻量级任务。",
25 | "o1_description": "o1 系列的大型语言模型通过强化学习训练，能够执行复杂的推理任务。o1 模型在回答之前会进行思考，产生一长串内部思维链，然后再回应用户。",
26 | "no_permission_to_update_description": "你没有权限更新。请联系管理员。管理员的配置方式为在配置文件 config.json 中的 admin_list 中添加用户名。"
27 | }
--------------------------------------------------------------------------------
/modules/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GaiZhenbiao/ChuanhuChatGPT/550fd86b9411bf8afe73d783a0d90d074e118be4/modules/__init__.py
--------------------------------------------------------------------------------
/modules/index_func.py:
--------------------------------------------------------------------------------
1 | import PyPDF2
2 | from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
3 | from langchain_community.vectorstores import FAISS
4 | from langchain_openai import OpenAIEmbeddings, AzureOpenAIEmbeddings
5 | from tqdm import tqdm
6 |
7 | from modules.config import local_embedding
8 | from modules.utils import *
9 |
10 |
11 | def get_documents(file_src):
12 | from langchain.schema import Document
13 | from langchain.text_splitter import TokenTextSplitter
14 |
15 | text_splitter = TokenTextSplitter(chunk_size=500, chunk_overlap=30)
16 |
17 | documents = []
18 | logging.debug("Loading documents...")
19 | logging.debug(f"file_src: {file_src}")
20 | for file in file_src:
21 | filepath = file.name
22 | filename = os.path.basename(filepath)
23 | file_type = os.path.splitext(filename)[1]
24 | logging.info(f"loading file: {filename}")
25 | texts = None
26 | try:
27 | if file_type == ".pdf":
28 | logging.debug("Loading PDF...")
29 | try:
30 | from modules.config import advance_docs
31 | from modules.pdf_func import parse_pdf
32 |
33 | two_column = advance_docs["pdf"].get("two_column", False)
34 | pdftext = parse_pdf(filepath, two_column).text
35 | except:
36 | pdftext = ""
37 | with open(filepath, "rb") as pdfFileObj:
38 | pdfReader = PyPDF2.PdfReader(pdfFileObj)
39 | for page in tqdm(pdfReader.pages):
40 | pdftext += page.extract_text()
41 | texts = [Document(page_content=pdftext, metadata={"source": filepath})]
42 | elif file_type == ".docx":
43 | logging.debug("Loading Word...")
44 | from langchain.document_loaders import \
45 | UnstructuredWordDocumentLoader
46 |
47 | loader = UnstructuredWordDocumentLoader(filepath)
48 | texts = loader.load()
49 | elif file_type == ".pptx":
50 | logging.debug("Loading PowerPoint...")
51 | from langchain.document_loaders import \
52 | UnstructuredPowerPointLoader
53 |
54 | loader = UnstructuredPowerPointLoader(filepath)
55 | texts = loader.load()
56 | elif file_type == ".epub":
57 | logging.debug("Loading EPUB...")
58 | from langchain.document_loaders import UnstructuredEPubLoader
59 |
60 | loader = UnstructuredEPubLoader(filepath)
61 | texts = loader.load()
62 | elif file_type == ".xlsx":
63 | logging.debug("Loading Excel...")
64 | text_list = excel_to_string(filepath)
65 | texts = []
66 | for elem in text_list:
67 | texts.append(
68 | Document(page_content=elem, metadata={"source": filepath})
69 | )
70 | elif file_type in [
71 | ".jpg",
72 | ".jpeg",
73 | ".png",
74 | ".heif",
75 | ".heic",
76 | ".webp",
77 | ".bmp",
78 | ".gif",
79 | ".tiff",
80 | ".tif",
81 | ]:
82 | raise gr.Warning(
83 | i18n("不支持的文件: ")
84 | + filename
85 | + i18n("，请使用 .pdf, .docx, .pptx, .epub, .xlsx 等文档。")
86 | )
87 | else:
88 | logging.debug("Loading text file...")
89 | from langchain.document_loaders import TextLoader
90 |
91 | loader = TextLoader(filepath, "utf8")
92 | texts = loader.load()
93 | except Exception as e:
94 | import traceback
95 |
96 | logging.error(f"Error loading file: {filename}")
97 | traceback.print_exc()
98 |
99 | if texts is not None:
100 | texts = text_splitter.split_documents(texts)
101 | documents.extend(texts)
102 | logging.debug("Documents loaded.")
103 | return documents
104 |
105 |
106 | def construct_index(
107 | api_key,
108 | file_src,
109 | max_input_size=4096,
110 | num_outputs=5,
111 | max_chunk_overlap=20,
112 | chunk_size_limit=600,
113 | embedding_limit=None,
114 | separator=" ",
115 | load_from_cache_if_possible=True,
116 | ):
117 | if api_key:
118 | os.environ["OPENAI_API_KEY"] = api_key
119 | else:
120 | # 由于一个依赖的愚蠢的设计，这里必须要有一个API KEY
121 | os.environ["OPENAI_API_KEY"] = "sk-xxxxxxx"
122 | logging.debug(f"api base: {os.environ.get('OPENAI_API_BASE', None)}")
123 | chunk_size_limit = None if chunk_size_limit == 0 else chunk_size_limit
124 | embedding_limit = None if embedding_limit == 0 else embedding_limit
125 | separator = " " if separator == "" else separator
126 |
127 | index_name = get_file_hash(file_src)
128 | index_path = f"./index/{index_name}"
129 | if local_embedding:
130 | embeddings = HuggingFaceEmbeddings(
131 | model_name="sentence-transformers/distiluse-base-multilingual-cased-v2"
132 | )
133 | else:
134 | if os.environ.get("OPENAI_API_TYPE", "openai") == "openai":
135 | embeddings = OpenAIEmbeddings(
136 | openai_api_base=os.environ.get("OPENAI_API_BASE", None),
137 | openai_api_key=os.environ.get("OPENAI_EMBEDDING_API_KEY", api_key),
138 | model="text-embedding-3-large",
139 | )
140 | else:
141 | embeddings = AzureOpenAIEmbeddings(
142 | deployment=os.environ["AZURE_EMBEDDING_DEPLOYMENT_NAME"],
143 | openai_api_key=os.environ["AZURE_OPENAI_API_KEY"],
144 | model=os.environ["AZURE_EMBEDDING_MODEL_NAME"],
145 | azure_endpoint=os.environ["AZURE_OPENAI_API_BASE_URL"],
146 | openai_api_type="azure",
147 | )
148 | if os.path.exists(index_path) and load_from_cache_if_possible:
149 | logging.info(i18n("找到了缓存的索引文件，加载中……"))
150 | return FAISS.load_local(
151 | index_path, embeddings, allow_dangerous_deserialization=True
152 | )
153 | else:
154 | documents = get_documents(file_src)
155 | logging.debug(i18n("构建索引中……"))
156 | if documents:
157 | with retrieve_proxy():
158 | index = FAISS.from_documents(documents, embeddings)
159 | else:
160 | raise Exception(i18n("没有找到任何支持的文档。"))
161 | logging.debug(i18n("索引构建完成！"))
162 | os.makedirs("./index", exist_ok=True)
163 | index.save_local(index_path)
164 | logging.debug(i18n("索引已保存至本地!"))
165 | return index
166 |
--------------------------------------------------------------------------------
/modules/models/Azure.py:
--------------------------------------------------------------------------------
1 | from langchain.chat_models import AzureChatOpenAI, ChatOpenAI
2 | import os
3 |
4 | from .base_model import Base_Chat_Langchain_Client
5 |
6 | # load_config_to_environ(["azure_openai_api_key", "azure_api_base_url", "azure_openai_api_version", "azure_deployment_name"])
7 |
8 | class Azure_OpenAI_Client(Base_Chat_Langchain_Client):
9 | def setup_model(self):
10 | # inplement this to setup the model then return it
11 | return AzureChatOpenAI(
12 | openai_api_base=os.environ["AZURE_OPENAI_API_BASE_URL"],
13 | openai_api_version=os.environ["AZURE_OPENAI_API_VERSION"],
14 | deployment_name=os.environ["AZURE_DEPLOYMENT_NAME"],
15 | openai_api_key=os.environ["AZURE_OPENAI_API_KEY"],
16 | openai_api_type="azure",
17 | streaming=True
18 | )
19 |
--------------------------------------------------------------------------------
/modules/models/ChatGLM.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | import logging
4 | import os
5 | import platform
6 |
7 | import gc
8 | import torch
9 | import colorama
10 |
11 | from ..index_func import *
12 | from ..presets import *
13 | from ..utils import *
14 | from .base_model import BaseLLMModel
15 |
16 |
17 | class ChatGLM_Client(BaseLLMModel):
18 | def __init__(self, model_name, user_name="") -> None:
19 | super().__init__(model_name=model_name, user=user_name)
20 | import torch
21 | from transformers import AutoModel, AutoTokenizer
22 | global CHATGLM_TOKENIZER, CHATGLM_MODEL
23 | self.deinitialize()
24 | if CHATGLM_TOKENIZER is None or CHATGLM_MODEL is None:
25 | system_name = platform.system()
26 | model_path = None
27 | if os.path.exists("models"):
28 | model_dirs = os.listdir("models")
29 | if model_name in model_dirs:
30 | model_path = f"models/{model_name}"
31 | if model_path is not None:
32 | model_source = model_path
33 | else:
34 | model_source = f"THUDM/{model_name}"
35 | CHATGLM_TOKENIZER = AutoTokenizer.from_pretrained(
36 | model_source, trust_remote_code=True
37 | )
38 | quantified = False
39 | if "int4" in model_name:
40 | quantified = True
41 | model = AutoModel.from_pretrained(
42 | model_source, trust_remote_code=True
43 | )
44 | if torch.cuda.is_available():
45 | # run on CUDA
46 | logging.info("CUDA is available, using CUDA")
47 | model = model.half().cuda()
48 | # mps加速还存在一些问题，暂时不使用
49 | elif system_name == "Darwin" and model_path is not None and not quantified:
50 | logging.info("Running on macOS, using MPS")
51 | # running on macOS and model already downloaded
52 | model = model.half().to("mps")
53 | else:
54 | logging.info("GPU is not available, using CPU")
55 | model = model.float()
56 | model = model.eval()
57 | CHATGLM_MODEL = model
58 |
59 | def _get_glm3_style_input(self):
60 | history = self.history
61 | query = history.pop()["content"]
62 | return history, query
63 |
64 | def _get_glm2_style_input(self):
65 | history = [x["content"] for x in self.history]
66 | query = history.pop()
67 | logging.debug(colorama.Fore.YELLOW +
68 | f"{history}" + colorama.Fore.RESET)
69 | assert (
70 | len(history) % 2 == 0
71 | ), f"History should be even length. current history is: {history}"
72 | history = [[history[i], history[i + 1]]
73 | for i in range(0, len(history), 2)]
74 | return history, query
75 |
76 | def _get_glm_style_input(self):
77 | if "glm2" in self.model_name:
78 | return self._get_glm2_style_input()
79 | else:
80 | return self._get_glm3_style_input()
81 |
82 | def get_answer_at_once(self):
83 | history, query = self._get_glm_style_input()
84 | response, _ = CHATGLM_MODEL.chat(
85 | CHATGLM_TOKENIZER, query, history=history)
86 | return response, len(response)
87 |
88 | def get_answer_stream_iter(self):
89 | history, query = self._get_glm_style_input()
90 | for response, history in CHATGLM_MODEL.stream_chat(
91 | CHATGLM_TOKENIZER,
92 | query,
93 | history,
94 | max_length=self.token_upper_limit,
95 | top_p=self.top_p,
96 | temperature=self.temperature,
97 | ):
98 | yield response
99 |
100 | def deinitialize(self):
101 | # 释放显存
102 | global CHATGLM_MODEL, CHATGLM_TOKENIZER
103 | CHATGLM_MODEL = None
104 | CHATGLM_TOKENIZER = None
105 | gc.collect()
106 | torch.cuda.empty_cache()
107 | logging.info("ChatGLM model deinitialized")
108 |
--------------------------------------------------------------------------------
/modules/models/Claude.py:
--------------------------------------------------------------------------------
1 | from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
2 | from ..presets import *
3 | from ..utils import *
4 |
5 | from .base_model import BaseLLMModel
6 |
7 |
8 | class Claude_Client(BaseLLMModel):
9 | def __init__(self, model_name, api_secret) -> None:
10 | super().__init__(model_name=model_name)
11 | self.api_secret = api_secret
12 | if None in [self.api_secret]:
13 | raise Exception("请在配置文件或者环境变量中设置Claude的API Secret")
14 | self.claude_client = Anthropic(api_key=self.api_secret, base_url=self.api_host)
15 |
16 | def _get_claude_style_history(self):
17 | history = []
18 | image_buffer = []
19 | image_count = 0
20 | for message in self.history:
21 | if message["role"] == "user":
22 | content = []
23 | if image_buffer:
24 | if image_count == 1:
25 | content.append(
26 | {
27 | "type": "image",
28 | "source": {
29 | "type": "base64",
30 | "media_type": f"image/{self.get_image_type(image_buffer[0])}",
31 | "data": self.get_base64_image(image_buffer[0]),
32 | },
33 | },
34 | )
35 | else:
36 | image_buffer_length = len(image_buffer)
37 | for idx, image in enumerate(image_buffer):
38 | content.append(
39 | {"type": "text", "text": f"Image {image_count - image_buffer_length + idx + 1}:"},
40 | )
41 | content.append(
42 | {
43 | "type": "image",
44 | "source": {
45 | "type": "base64",
46 | "media_type": f"image/{self.get_image_type(image)}",
47 | "data": self.get_base64_image(image),
48 | },
49 | },
50 | )
51 | if content:
52 | content.append({"type": "text", "text": message["content"]})
53 | history.append(construct_user(content))
54 | image_buffer = []
55 | else:
56 | history.append(message)
57 | elif message["role"] == "assistant":
58 | history.append(message)
59 | elif message["role"] == "image":
60 | image_buffer.append(message["content"])
61 | image_count += 1
62 | # history with base64 data replaced with "#base64#"
63 | # history_for_display = history.copy()
64 | # for message in history_for_display:
65 | # if message["role"] == "user":
66 | # if type(message["content"]) == list:
67 | # for content in message["content"]:
68 | # if content["type"] == "image":
69 | # content["source"]["data"] = "#base64#"
70 | # logging.info(f"History for Claude: {history_for_display}")
71 | return history
72 |
73 | def get_answer_stream_iter(self):
74 | system_prompt = self.system_prompt
75 | history = self._get_claude_style_history()
76 |
77 | try:
78 | with self.claude_client.messages.stream(
79 | model=self.model_name,
80 | max_tokens=self.max_generation_token,
81 | messages=history,
82 | system=system_prompt,
83 | ) as stream:
84 | partial_text = ""
85 | for text in stream.text_stream:
86 | partial_text += text
87 | yield partial_text
88 | except Exception as e:
89 | yield i18n(GENERAL_ERROR_MSG) + ": " + str(e)
90 |
91 | def get_answer_at_once(self):
92 | system_prompt = self.system_prompt
93 | history = self._get_claude_style_history()
94 |
95 | response = self.claude_client.messages.create(
96 | model=self.model_name,
97 | max_tokens=self.max_generation_token,
98 | messages=history,
99 | system=system_prompt,
100 | )
101 | if response is not None:
102 | return response.content[0].text, response.usage.output_tokens
103 | else:
104 | return i18n("获取资源错误"), 0
105 |
--------------------------------------------------------------------------------
/modules/models/DALLE3.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from .base_model import BaseLLMModel
3 | from .. import shared
4 | import requests
5 | from ..presets import *
6 | from ..config import retrieve_proxy, sensitive_id
7 |
8 | class OpenAI_DALLE3_Client(BaseLLMModel):
9 | def __init__(self, model_name, api_key, user_name="") -> None:
10 | super().__init__(model_name=model_name, user=user_name, config={"api_key": api_key})
11 | if self.api_host is not None:
12 | self.chat_completion_url, self.images_completion_url, self.openai_api_base, self.balance_api_url, self.usage_api_url = shared.format_openai_host(self.api_host)
13 | else:
14 | self.api_host, self.chat_completion_url, self.images_completion_url, self.openai_api_base, self.balance_api_url, self.usage_api_url = shared.state.api_host, shared.state.chat_completion_url, shared.state.images_completion_url, shared.state.openai_api_base, shared.state.balance_api_url, shared.state.usage_api_url
15 | self._refresh_header()
16 |
17 | def _get_dalle3_prompt(self):
18 | prompt = self.history[-1]["content"]
19 | if prompt.endswith("--raw"):
20 | prompt = "I NEED to test how the tool works with extremely simple prompts. DO NOT add any detail, just use it AS-IS:" + prompt
21 | return prompt
22 |
23 | def get_answer_at_once(self, stream=False):
24 | prompt = self._get_dalle3_prompt()
25 | headers = {
26 | "Content-Type": "application/json",
27 | "Authorization": f"Bearer {self.api_key}"
28 | }
29 | payload = {
30 | "model": self.model_name,
31 | "prompt": prompt,
32 | "n": 1,
33 | "size": "1024x1024",
34 | "quality": "standard",
35 | }
36 | if stream:
37 | timeout = TIMEOUT_STREAMING
38 | else:
39 | timeout = TIMEOUT_ALL
40 |
41 | if self.images_completion_url != IMAGES_COMPLETION_URL:
42 | logging.debug(f"使用自定义API URL: {self.images_completion_url}")
43 |
44 | with retrieve_proxy():
45 | try:
46 | response = requests.post(
47 | self.images_completion_url,
48 | headers=headers,
49 | json=payload,
50 | stream=stream,
51 | timeout=timeout,
52 | )
53 | response.raise_for_status() # 根据HTTP状态码引发异常
54 | response_data = response.json()
55 | image_url = response_data['data'][0]['url']
56 | img_tag = f'