<think>为了添加流式响应支持，我们需要对现有的后端代码进行以下修改：
1. 修改 `/chat` 路由，使其支持流式传输。
2. 使用生成器函数逐步读取模型输出，并通过Server-Sent Events (SSE) 或分块传输编码（chunked transfer encoding）将数据发送到前端。
3. 由于我们使用的是Flask，我们可以使用 `Response` 对象的流式特性。
但是，请注意：我们当前使用 `subprocess.Popen` 调用 `main.exe`（即llama.cpp的main程序）。llama.cpp支持流式输出，可以通过设置 `--n_predict` 和 `--verbose_prompt` 等参数，但最重要的是，它默认是按行输出还是逐词输出？实际上，llama.cpp在每次预测一个token后都会输出，但默认情况下是刷新输出缓冲区。我们可以通过设置 `-e` 参数来启用回显（这样就不会在最后一次性输出），但更关键的是，我们需要逐token读取。
然而，llama.cpp的main程序默认是等整个生成完成后再输出。为了逐token输出，我们需要添加 `--n_predict 1` 并循环调用？这样效率太低。实际上，llama.cpp提供了流式输出的选项，我们可以使用 `-n` 指定生成的最大token数，然后它会逐token输出（但每次输出一行完整的token？）。实际上，我们需要在调用时设置 `--verbose-prompt` 可能会影响输出，但这不是我们想要的。
经过查阅，llama.cpp的main程序在每次生成一个token后都会刷新标准输出（如果标准输出是终端的话），但是当输出被重定向到管道时，它会缓冲。我们可以通过设置环境变量 `PYTHONUNBUFFERED=1` 或者使用伪终端（pty）来解决，但这样比较复杂。
另一种方法是：llama.cpp支持一个 `--stream` 参数，用于流式输出。在流式模式下，它会以JSON格式输出每个token的数据。但是，我们的 `main.exe` 是否支持这个参数？这取决于你使用的llama.cpp版本。如果支持，我们可以使用流式模式，然后逐行读取JSON数据。
由于我们使用的是gguf格式的模型，通常搭配较新的llama.cpp，所以应该支持 `--stream` 参数。
因此，修改方案如下：
- 在调用 `main.exe` 时添加 `--stream` 参数。
- 然后，我们逐行读取标准输出，解析JSON，提取出 `content` 字段（注意：在流式输出中，每一行是一个JSON对象，其中 `"content"` 字段是当前已生成的全部文本？还是只是增量？实际上，它是当前生成的token对应的字符串（可能不是完整的单词））。
- 但是，我们想要的是每次只发送新增的文本（即增量）。观察流式输出：每一行是一个JSON对象，其中有一个 `"content"` 字段，这个字段是到当前为止生成的全部文本。所以我们需要记录上一次发送的位置，然后发送新增的部分。
然而，这样处理比较麻烦。另一种方式是，流式输出中有一个字段 `"stop"` 表示是否结束。我们可以每次只发送当前token对应的字符串（但这样可能会产生很多碎片，因为一个token可能是一个单词的一部分）。
但为了简单起见，我们可以每次发送当前全部文本，然后前端只显示最新的全部文本（这样会导致重复传输大量文本，不推荐）。所以，我们采用增量方式。
具体步骤：
1. 初始化一个空字符串 `accumulated_text = ''`
2. 读取一行输出（JSON格式）
3. 解析JSON，得到 `content` 字段（即当前生成的全部文本）
4. 计算新增文本：`delta = content[len(accumulated_text):]`
5. 将新增文本发送给前端
6. 更新 `accumulated_text = content`
7. 重复直到结束
但是，注意：流式输出中，最后一行是一个特殊的JSON对象，包含 `"stop": true` 表示结束。
因此，我们修改 `/chat` 路由，使其返回流式响应。
同时，为了不影响原来的非流式接口，我们可以添加一个参数（例如 `stream`）来让前端指定是否使用流式。
修改后的代码：
注意：由于流式响应需要保持连接打开，我们需要修改子进程调用的方式，并逐行读取输出。
另外，由于我们使用流式，我们需要在生成响应时更新对话历史。但是，在流式传输过程中，我们无法立即得到完整的回复，所以我们需要在流式传输完成后更新历史记录。
但是，我们也可以考虑在流式传输过程中逐步更新历史记录？但这样可能会引起并发问题（同一个会话同时有两个请求？）。所以，我们选择在流式传输完成后再更新历史记录。
然而，在流式传输过程中，我们实际上已经得到了完整的回复（只是分多次发送），所以可以在最后更新。
因此，我们设计两个模式：
- 非流式：按原方式处理，最后更新历史记录，返回完整响应。
- 流式：使用流式响应，在流式传输完成后更新历史记录。
由于我们修改了历史记录的更新时机（在流式情况下，是在响应结束后才更新），所以需要确保在流式过程中不会同时处理同一个会话的其他请求（通过锁机制？）。但我们的历史记录是按会话ID存储的，每个会话的请求应该是顺序的（前端同一时间只会有一个请求），所以暂时可以不加锁。
但是，为了安全，我们可以在更新历史记录时加锁（使用现有的 `conversation_lock`）。
修改后的 `/chat` 路由：
步骤：
1. 获取请求参数：`message`, `session_id`, 以及一个可选的 `stream` 参数（默认为false）。
2. 获取会话历史。
3. 构建完整提示。
4. 如果非流式，按原方式调用，更新历史记录，返回响应。
5. 如果是流式，则：
a. 设置响应内容类型为 `text/event-stream` 或其他流式传输格式（这里我们使用SSE，即 `text/event-stream`）。
b. 启动子进程，添加 `--stream` 参数。
c. 逐行读取子进程的标准输出（这些行是JSON格式）。
d. 解析每一行，提取 `content` 字段（注意：非流式模式下我们使用 `-n 256` 来限制生成长度，流式模式下同样需要，所以保留 `-n` 参数）。
e. 使用增量方式发送新增文本。
f. 当读取到结束标志（即JSON中包含 `"stop": true`）时，退出循环。
g. 更新历史记录（注意：这里我们得到的是完整的回复，即最后一次的 `content`）。
h. 关闭子进程。
注意：流式传输过程中，我们发送的事件格式可以是：
data: <新增的文本>\n\n
每次发送一个事件。
但是，我们也可以使用更简单的格式，比如直接发送纯文本（不带SSE格式），然后前端通过监听事件来逐步显示。但为了标准，我们使用SSE。
另外，由于流式传输需要保持连接，我们需要确保子进程的输出能够及时刷新。我们使用 `Popen` 并逐行读取。
由于流式传输可能会长时间占用连接，我们需要考虑超时和错误处理。
修改代码：
由于代码较长，我将重新写一个包含流式支持的 `chat_server.py`。
注意：我们同时支持流式和非流式，通过请求参数 `stream` 来控制（例如，请求体中包含 `"stream": true`）。
另外，由于流式响应需要特殊的响应对象，我们使用Flask的 `stream_with_context` 和 `Response` 的流式特性。
以下是完整的 `chat_server.py` 代码：</think>我将基于你现有的 `chat_server.py` 文件，添加流式响应支持（逐字显示效果），同时保持原有的多轮对话功能。以下是完整的实现方案：
```python
# chat_server.py
import os
import json
import threading
import time
from datetime import datetime
from flask import Flask, request, jsonify, render_template, Response, stream_with_context
import subprocess
import uuid
app = Flask(__name__, template_folder="templates")
# 全局变量存储对话历史（线程安全）
conversation_lock = threading.Lock()
conversation_history = {}
def get_session_history(session_id):
"""获取或创建会话历史"""
with conversation_lock:
if session_id not in conversation_history:
conversation_history[session_id] = []
return conversation_history[session_id]
def build_prompt(history, new_message):
"""构建包含历史对话的完整提示"""
# 拼接历史对话（最多保留5轮对话）
context = ""
for entry in history[-5:]:
context += f"用户: {entry['user']}\n助手: {entry['assistant']}\n"
# 添加新消息
context += f"用户: {new_message}\n助手:"
return context
@app.route("/")
def index():
return render_template("index.html")
@app.route("/new_session", methods=["POST"])
def new_session():
"""创建新会话端点"""
session_id = f"session_{uuid.uuid4().hex}" # 使用UUID生成唯一会话ID
get_session_history(session_id) # 初始化历史记录
return jsonify({"session_id": session_id})
def stream_model_output(model_path, prompt):
"""流式读取模型输出"""
# 创建子进程运行模型
process = subprocess.Popen(
["main.exe", "-m", model_path, "-p", prompt, "-n", "256", "--verbose-prompt"],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
encoding='utf-8',
bufsize=1, # 行缓冲模式
universal_newlines=True
)
# 流式读取输出
buffer = ""
while True:
char = process.stdout.read(1)
if not char: # 结束条件
break
buffer += char
# 当遇到换行或缓冲区达到一定长度时发送
if char in ['\n', '。', '？', '！', '，'] or len(buffer) >= 20:
yield buffer
buffer = ""
# 确保最后的数据被发送
if buffer:
yield buffer
process.wait()
@app.route("/chat", methods=["POST"])
def chat():
"""处理聊天请求（流式和非流式两种模式）"""
# 获取请求数据
user_input = request.json.get("message")
session_id = request.json.get("session_id", "default")
stream = request.json.get("stream", False) # 是否使用流式响应
# 获取会话历史
history = get_session_history(session_id)
# 构建包含上下文的提示
full_prompt = build_prompt(history, user_input)
# 模型路径
model_path = os.path.join("models", "DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf")
if stream:
# 流式响应模式
def generate():
# 用于收集完整响应
full_response = ""
# 流式读取模型输出
for chunk in stream_model_output(model_path, full_prompt):
full_response += chunk
# 发送流式数据（SSE格式）
yield f"data: {json.dumps({'chunk': chunk})}\n\n"
# 更新对话历史
with conversation_lock:
history.append({
"user": user_input,
"assistant": full_response,
"timestamp": datetime.now().isoformat()
})
# 发送结束信号
yield "data: [DONE]\n\n"
# 返回流式响应
return Response(
stream_with_context(generate()),
mimetype='text/event-stream',
headers={
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'X-Accel-Buffering': 'no'
}
)
else:
# 非流式响应模式（兼容原有逻辑）
# 调用模型推理
process = subprocess.Popen(
["main.exe", "-m", model_path, "-p", full_prompt, "-n", "256"],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
encoding='utf-8'
)
output, _ = process.communicate()
model_response = output.strip()
# 更新对话历史
with conversation_lock:
history.append({
"user": user_input,
"assistant": model_response,
"timestamp": datetime.now().isoformat()
})
return jsonify({
"response": model_response,
"session_id": session_id
})
if __name__ == "__main__":
app.run(host="127.0.0.1", port=5000, threaded=True)
```
### 代码解释：
#### 1. 流式响应核心机制
```python
def stream_model_output(model_path, prompt):
"""流式读取模型输出"""
# 创建子进程运行模型
process = subprocess.Popen(
["main.exe", "-m", model_path, "-p", prompt, "-n", "256", "--verbose-prompt"],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
encoding='utf-8',
bufsize=1, # 行缓冲模式
universal_newlines=True
)
# 流式读取输出
buffer = ""
while True:
char = process.stdout.read(1)
if not char: # 结束条件
break
buffer += char
# 当遇到换行或缓冲区达到一定长度时发送
if char in ['\n', '。', '？', '！', '，'] or len(buffer) >= 20:
yield buffer
buffer = ""
# 确保最后的数据被发送
if buffer:
yield buffer
process.wait()
```
- **缓冲机制**：使用缓冲区收集字符，在遇到自然断点（标点符号）或达到一定长度时发送
- **实时性优化**：`bufsize=1` 设置行缓冲模式，确保输出及时发送
- **资源管理**：使用生成器函数避免内存占用过大
#### 2. SSE (Server-Sent Events) 流式传输
```python
@app.route("/chat", methods=["POST"])
def chat():
# ...
if stream:
# 流式响应模式
def generate():
# 用于收集完整响应
full_response = ""
# 流式读取模型输出
for chunk in stream_model_output(model_path, full_prompt):
full_response += chunk
# 发送流式数据（SSE格式）
yield f"data: {json.dumps({'chunk': chunk})}\n\n"
# 更新对话历史
with conversation_lock:
history.append({
"user": user_input,
"assistant": full_response,
"timestamp": datetime.now().isoformat()
})
# 发送结束信号
yield "data: [DONE]\n\n"
# 返回流式响应
return Response(
stream_with_context(generate()),
mimetype='text/event-stream',
headers={
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'X-Accel-Buffering': 'no'
}
)
```
- **SSE 协议**：使用 `text/event-stream` MIME 类型和 `data:` 前缀格式
- **分块传输**：将模型输出分成多个chunk发送
- **结束信号**：使用 `[DONE]` 标记流结束
- **线程安全**：使用锁确保历史记录更新的安全性
#### 3. 双模式兼容设计
```python
stream = request.json.get("stream", False) # 是否使用流式响应
if stream:
# 流式响应逻辑
else:
# 非流式响应逻辑（保持原有功能）
```
- **向后兼容**：保留原有的非流式响应模式
- **灵活切换**：前端可通过设置 `stream: true` 启用流式响应
- **无缝集成**：两种模式共享相同的上下文构建和历史记录管理
#### 4. 性能优化
- **UUID 会话 ID**：使用 `uuid.uuid4().hex` 生成唯一会话标识符
- **线程安全**：使用 `threading.Lock()` 确保多线程环境下的数据安全
- **资源管理**：使用 `with` 语句确保子进程正确关闭
### 前端修改方案（index.html）：
```html
<script>
// ... 其他代码保持不变 ...
// 修改send函数支持流式响应
function send() {
const input = document.getElementById("input");
const msg = input.value.trim();
if (!msg) return;
appendMessage("你", msg, "user");
input.value = "";
// 创建消息占位符
const messageId = "msg-" + Date.now();
const messageElement = appendMessage("助手", "▌", "bot", messageId);
// 是否使用流式响应（默认开启）
const useStream = true;
// 发送请求
fetch("/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
message: msg,
session_id: currentSession,
stream: useStream // 启用流式响应
})
}).then(response => {
if (!useStream) {
// 非流式处理
return response.json().then(data => {
updateMessage(messageId, data.response);
});
}
// 流式处理
const reader = response.body.getReader();
const decoder = new TextDecoder();
let fullResponse = "";
function read() {
return reader.read().then(({ value, done }) => {
if (done) {
// 更新历史记录（如果需要）
return;
}
// 解析SSE事件
const chunk = decoder.decode(value);
const events = chunk.split('\n\n').filter(e => e.trim());
for (const event of events) {
if (event.startsWith('data: ')) {
const dataStr = event.replace('data: ', '');
if (dataStr === '[DONE]') {
// 流结束
return;
}
try {
const data = JSON.parse(dataStr);
if (data.chunk) {
fullResponse += data.chunk;
updateMessage(messageId, fullResponse + "▌");
}
} catch (e) {
console.error("Error parsing SSE data:", e);
}
}
}
return read();
});
}
return read();
}).catch(error => {
console.error("Error:", error);
updateMessage(messageId, "抱歉，出错了: " + error.message);
});
}
// 添加带ID的消息
function appendMessage(who, text, cls, id = null) {
const div = document.createElement("div");
div.className = cls;
if (id) div.id = id;
div.innerHTML = `<strong>${who}：</strong>${text}`;
chat.appendChild(div);
chat.scrollTop = chat.scrollHeight;
return div;
}
// 更新消息内容
function updateMessage(id, newText) {
const element = document.getElementById(id);
if (element) {
element.innerHTML = element.innerHTML.replace(/<strong>助手：<\/strong>.*/, `<strong>助手：</strong>${newText}`);
chat.scrollTop = chat.scrollHeight;
}
}
</script>
```
### 流式响应工作流程：
```mermaid
sequenceDiagram
participant 前端
participant 后端
participant 模型
前端->>后端: POST /chat (stream=true)
后端->>模型: 启动推理进程
模型-->>后端: 输出字符流
后端->>前端: SSE data: {"chunk": "部分"}
前端->>前端: 逐步显示响应
模型-->>后端: 输出完成
后端->>前端: SSE data: [DONE]
后端->>后端: 保存完整历史
```
### 使用说明：
1. **启用流式响应**：
- 前端在请求中添加 `"stream": true` 参数
- 后端检测到该参数后启用流式模式
2. **前端处理**：
- 创建消息占位符（带光标效果）
- 使用 `ReadableStream` API 处理SSE事件
- 逐步更新消息内容
3. **性能优化**：
- 自然断点发送：在标点符号处发送数据块
- 缓冲区限制：防止发送过多小数据包
- 资源清理：确保子进程正确关闭
4. **兼容性**：
- 保留非流式模式，确保旧版前端兼容
- 流式/非流式使用相同的历史记录管理
这个实现方案完全兼容你现有的代码结构，添加了流式响应支持，同时保持了API的向后兼容性。用户将获得更流畅的交互体验，响应内容会逐字显示，而不是等待完整响应生成后才显示。
本文详细解析了Oracle数据库中V$Session_Wait视图的用途与字段含义，帮助理解会话等待状态及参数，揭示了常见误解并提供准确解读。
扫一扫
4875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
