"好"    → 概率 62%
"不错"  → 概率 18%
"差"    → 概率 8%
"热"    → 概率 5%
"糟糕"  → 概率 3%
其他    → 概率 4%

用户：请用一句话介绍一下 Python 这门编程语言。
助手：

Python是一门简洁易读、功能强大的高级编程语言，广泛应用于Web开发、数据分析、人工智能等领域。

原文：人工智能正在改变我们的生活方式
训练样本：人工智能正在____我们的生活方式
正确答案：改变

最大化 P(下一个词 | 上下文)

"他" 与各词的关联分数（示意）：
小明  → 0.15
把    → 0.02
作业  → 0.08
交给了 → 0.05
老师  → 0.35  ← 最高！
因为  → 0.03
他    → 0.10
要求  → 0.12
必须  → 0.04
今天  → 0.03
交    → 0.03

注意力分数 = softmax(Q × K的转置 / √d)
输出 = 注意力分数 × V

PE(pos, 2i) = sin(pos / 10000^(2i/d))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d))

FFN(x) = max(0, xW1 + b1)W2 + b2

GPT 架构（简化）：

输入 tokens
    ↓
词嵌入 + 位置编码
    ↓
┌─────────────────────┐
│  掩码自注意力层      │
│  前馈神经网络        │  × N 层（GPT-3 是 96 层）
│  残差连接 + 层归一化  │
└─────────────────────┘
    ↓
线性层 + Softmax
    ↓
下一个词的概率分布

用户：什么是机器学习？
助手：

["用户", "：", "什么", "是", "机器", "学习", "？", "\n", "助手", "："]

[1234, 567, 8901, 234, 5678, 9012, 345, 678, 9012, 567]

"机器"   → 0.35
"它"     → 0.20
"简单"   → 0.10
"一种"   → 0.08
...

["用户", "：", "什么", "是", "机器", "学习", "？", "\n", "助手", "：", "机器"]

机器学习是人工智能的一个分支，它使计算机能够通过数据和经验自动学习和改进，而无需明确编程。

low: 5次
lower: 2次
newest: 6次
widest: 3次

l o w </w>: 5
l o w e r </w>: 2
n e w e s t </w>: 6
w i d e s t </w>: 3

l o w </w>: 5
l o w e r </w>: 2
n e w es t </w>: 6
w i d es t </w>: 3

l o w </w>: 5
l o w e r </w>: 2
n e w est </w>: 6
w i d est </w>: 3

{l, o, w, e, r, n, s, t, i, d, </w>, es, est, est</w>, lo, low, low</w>, ...}

[系统提示词 System Prompt] → 几十到几百 Token
[历史对话记录] → 根据对话长度，可能占大头
  - 第1轮：用户问题 + 助手回答
  - 第2轮：用户问题 + 助手回答
  - ...
[当前用户问题] → 几十到几百 Token
[模型生成的回答] → 这也算在窗口内！

{
  "messages": [
    {"role": "system", "content": "你是一个编程助手"},
    {"role": "user", "content": "什么是冒泡排序？"},
    {"role": "assistant", "content": "冒泡排序是一种简单的排序算法...（500字）"},
    {"role": "user", "content": "能给我写个例子吗？"},
    {"role": "assistant", "content": "当然，这是一个Python实现...（300字）"},
    {"role": "user", "content": "能改成Java吗？"}
  ]
}

def truncate_messages(messages, max_tokens=4000, encoder=None):
    """截断历史消息，保留最新的"""
    if encoder is None:
        encoder = tiktoken.encoding_for_model("gpt-4")
    
    total_tokens = 0
    truncated = []
    
    # 倒序遍历，保留最新的消息
    for msg in reversed(messages):
        msg_tokens = len(encoder.encode(str(msg)))
        if total_tokens + msg_tokens > max_tokens:
            break
        truncated.insert(0, msg)
        total_tokens += msg_tokens
    
    return truncated

长文档（50000 字）
    ↓
分成 10 个块（每块 5000 字）
    ↓
每块单独让模型处理（提取要点/生成摘要）
    ↓
把 10 个结果汇总
    ↓
再让模型对汇总结果做最终处理

def summarize_long_document(document, chunk_size=3000):
    """对长文档进行分块摘要"""
    # 分块
    chunks = split_into_chunks(document, chunk_size)
    
    # Map: 对每个块生成摘要
    summaries = []
    for chunk in chunks:
        summary = call_llm(f"请用100字总结以下内容：\n{chunk}")
        summaries.append(summary)
    
    # Reduce: 汇总所有摘要
    combined = "\n".join(summaries)
    final_summary = call_llm(f"请综合以下摘要，给出最终总结：\n{combined}")
    
    return final_summary

def manage_conversation_history(messages, max_recent=5, max_tokens=6000):
    """管理对话历史：保留最近N轮 + 早期摘要"""
    if len(messages) <= max_recent * 2:  # 用户+助手算两条
        return messages
    
    # 分离早期和最近的消息
    recent = messages[-(max_recent * 2):]
    early = messages[:-(max_recent * 2)]
    
    # 对早期消息做摘要
    early_text = format_messages_as_text(early)
    summary = call_llm(f"请简要概括以下对话的主要内容：\n{early_text}")
    
    # 返回：摘要 + 最近消息
    return [
        {"role": "system", "content": f"之前对话摘要：{summary}"},
        *recent
    ]

[开头的内容] → 注意力较高
[中间的内容] → 注意力下降 ← 关键信息可能被忽略
[结尾的内容] → 注意力较高

P(wi) = exp(zi) / Σexp(zj)

P(wi) = exp(zi/T) / Σexp(zj/T)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "..."}],
    temperature=0.8,  # 先调整概率分布
    top_p=0.9,        # 再从累积概率 90% 的词中选
)

输入 Token
    ↓
门控网络（Router）分析输入
    ↓
选择 Top-K 个最相关的专家（通常 K=2）
    ↓
只激活被选中的专家进行计算
    ↓
合并专家的输出
    ↓
输出结果

输入: "写一段Python代码"
    ↓
Router 分析: 这是编程任务
    ↓
选择专家: Expert3（代码专家）和 Expert7（Python专家）
    ↓
只有 Expert3 和 Expert7 参与计算
    ↓
其他 6 个专家"休息"

输入: "翻译这段文字到英文"
    ↓
Router 分析: 这是翻译任务
    ↓
选择专家: Expert1（语言理解）和 Expert5（英语生成）
    ↓
只有 Expert1 和 Expert5 参与计算

答案是 2.4 小时。

让我一步步分析这个问题。

1. 首先确定每个管的效率：
   - A 管每小时注入水池的 1/4
   - B 管每小时注入水池的 1/6

2. 两管同时开时，每小时注入量：
   1/4 + 1/6 = 3/12 + 2/12 = 5/12

3. 注满整个水池需要的时间：
   1 ÷ (5/12) = 12/5 = 2.4 小时

所以两管同时开，需要 2.4 小时注满水池。

请一步一步地思考这个问题，写出你的推理过程，然后给出最终答案。

问题：xxx

Let's think step by step.

问题：一辆车以 60 公里/小时的速度行驶，2 小时能走多远？

思考过程：
1. 已知速度是 60 公里/小时
2. 已知时间是 2 小时
3. 根据公式：距离 = 速度 × 时间
4. 距离 = 60 × 2 = 120 公里

答案：120 公里

---

问题：小明有 100 元，买了 3 本书，每本 25 元，还剩多少钱？

思考过程：

原始参数 (FP16):   0.0012345678...    [16 bits = 2 bytes]
INT8 量化后:       3                   [8 bits = 1 byte]    → 压缩 2 倍
INT4 量化后:       1                   [4 bits = 0.5 byte]  → 压缩 4 倍

# 使用 GPTQ 模型（通过 transformers）
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-7B-GPTQ",
    device_map="auto"
)

用户：请帮我写一份房屋租赁合同，要符合《民法典》相关规定。

根据《中华人民共和国民法典》第七百零三条规定，租赁合同是出租人将租赁物
交付承租人使用、收益，承租人支付租金的合同。

...

第五条 违约责任
根据《民法典》第五百八十四条的规定，当事人一方不履行合同义务或者履行
合同义务不符合约定，造成对方损失的，损失赔偿额应当相当于因违约所造成
的损失...

用户：3.9 和 3.11 哪个大？

某些模型的回答：3.11 更大，因为 11 > 9。

"3.11" → ["3", ".", "11"] 或 ["3.11"]

用户：17 × 24 = ?

模型的内部过程：
- 见过类似的乘法题
- 17 × 24 大约是 17 × 25 = 425，减一点
- 猜一个看起来合理的数字，比如 408

实际答案：17 × 24 = 408（碰巧对了）

用户：17 × 24 + 89 ÷ 3 = ?

正确答案：408 + 29.67 = 437.67
模型可能回答：412（随便猜的）

用户：2025 年的诺贝尔物理学奖得主是谁？

如果模型的截止日期是 2024 年，它会：
- 诚实地说"我的知识截止到 2024 年，不知道 2025 年的获奖者"
- 或者错误地猜测一个答案（幻觉）

用户：我们公司的年假政策是什么？

模型的真实情况：
- 它不知道你在哪家公司
- 你们公司的员工手册不在它的训练数据里
- 它只能给出一个通用的、基于常见做法的回答
- 这个回答可能和你们公司的实际政策完全不同

用户提问："我们公司的年假政策是什么？"
    ↓
【检索阶段】
从公司知识库中搜索"年假政策"相关的文档
    ↓
找到《员工手册》第 5 章"休假制度"相关段落
    ↓
【增强阶段】
构建 Prompt：
"根据以下公司资料回答员工的问题：

【参考资料】
员工入职满一年可享受 5 天年假，每增加一年工龄增加 1 天，
上限为 15 天。年假需提前 3 个工作日申请...

【问题】
我们公司的年假政策是什么？"
    ↓
【生成阶段】
大模型基于提供的资料生成回答
    ↓
回答："根据公司规定，员工入职满一年后可享受 5 天年假..."

 把文本转换成向量，便于语义搜索：

 ```python
 from sentence_transformers import SentenceTransformer
 
 model = SentenceTransformer('BAAI/bge-base-zh')  # 中文 Embedding 模型
 
 # 把文档块转换成向量
 doc_embeddings = model.encode(chunks)
 
 # 把用户问题转换成向量
 query_embedding = model.encode(query)
 ```

 存储和检索向量，常用的有：

 -   Milvus
 -   Pinecone
 -   Chroma
 -   Qdrant
 -   FAISS

 决定如何找到最相关的文档块：

 -   **语义检索**：基于向量相似度
 -   **关键词检索**：基于 BM25 等传统方法
 -   **混合检索**：两者结合

 把检索到的文档和问题一起发给大模型：

 ```python
 def rag_answer(query, retrieved_docs):
     context = "\n\n".join(retrieved_docs)
     
     prompt = f"""请根据以下参考资料回答问题。
 如果资料中没有相关信息，请说明无法回答。
 
 【参考资料】
 {context}
 
 【问题】
 {query}
 
 【回答】"""
     
     return llm.generate(prompt)
 ```

用户：北京今天天气怎么样？
    ↓
【大模型判断】
这个问题需要实时天气数据，我应该调用天气 API
    ↓
【输出工具调用请求】
{
  "tool": "get_weather",
  "arguments": {"city": "北京"}
}
    ↓
【系统执行工具】
调用天气 API，获得结果：
{"temp": 25, "weather": "晴", "humidity": 40}
    ↓
【把结果返回给模型】
    ↓
【大模型生成回答】
北京今天天气晴朗，气温 25°C，湿度 40%，是个适合外出的好天气。

import openai

# 定义可用的工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的实时天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如'北京'、'上海'"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式，如 '17 * 24 + 89 / 3'"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# 调用模型
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
    tools=tools,
    tool_choice="auto"  # 让模型自己决定是否调用工具
)

# 检查是否需要调用工具
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    
    # 执行工具（这里需要你自己实现）
    if tool_call.function.name == "get_weather":
        args = json.loads(tool_call.function.arguments)
        result = get_weather_api(args["city"])
        
        # 把结果返回给模型
        messages.append(response.choices[0].message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })
        
        # 模型基于工具结果生成最终回答
        final_response = client.chat.completions.create(
            model="gpt-4",
            messages=messages
        )

{
  "model": "Qwen/Qwen3.5-plus",
  "messages": [
    {"role": "system", "content": "你是一个专业的技术顾问"},
    {"role": "user", "content": "什么是微服务架构？"},
    {"role": "assistant", "content": "微服务架构是一种将应用程序..."},
    {"role": "user", "content": "它和单体架构有什么区别？"}
  ],
  "temperature": 0.7,
  "top_p": 1.0,
  "max_tokens": 1000,
  "stream": false,
  "stop": ["\n\n"],
  "presence_penalty": 0,
  "frequency_penalty": 0
}

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1699000000,
  "model": "Qwen/Qwen3.5-plus",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "微服务架构和单体架构的主要区别在于..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 156,
    "completion_tokens": 423,
    "total_tokens": 579
  }
}

data: {"id":"chatcmpl-abc123","choices":[{"delta":{"content":"微"},"index":0}]}

data: {"id":"chatcmpl-abc123","choices":[{"delta":{"content":"服务"},"index":0}]}

data: {"id":"chatcmpl-abc123","choices":[{"delta":{"content":"架构"},"index":0}]}

data: [DONE]

package com.normaling.aidemo;

/**
 * 大模型 API 非流式调用示例
 * 演示如何调用硅基流动的 API 进行对话
 */
public class LLMClient {

    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    /**
     * API 配置
     * */
    private static final String API_URL = "https://api.siliconflow.cn/v1/chat/completions";
    /**
     * 替换成你的 API Key
     * */
    private static final String API_KEY = "设置成你的apiKey";

    private static final String MODEL = "Qwen/Qwen3.5-122B-A10B";
    /**
     * 硅基流动文档中该模型支持 thinking 模式，默认开启时非流式调用可能等待较久。
     * 这里示例默认关闭，以减少直接运行 demo 时的超时概率。
     */
    private static final boolean ENABLE_THINKING = false;
    private static final int MAX_TOKENS = 512;
    private static final int CONNECT_TIMEOUT_SECONDS = 30;
    private static final int READ_TIMEOUT_SECONDS = 180;
    private static final int WRITE_TIMEOUT_SECONDS = 30;
    private static final int CALL_TIMEOUT_SECONDS = 180;

    /**
     * HTTP 客户端（复用以提高性能）
     * */
    private final OkHttpClient httpClient;
    private final Gson gson;

    public LLMClient() {
        // 配置 HTTP 客户端
        this.httpClient = new OkHttpClient.Builder()
                .connectTimeout(CONNECT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
                .readTimeout(READ_TIMEOUT_SECONDS, TimeUnit.SECONDS)
                .writeTimeout(WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
                .callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
                .retryOnConnectionFailure(true)
                .build();

        this.gson = new GsonBuilder()
                .setPrettyPrinting()
                .create();
    }

    /**
     * 发送对话请求
     *
     * @param systemPrompt 系统提示词，定义模型角色
     * @param userMessage  用户消息
     * @return 模型的回复
     */
    public String chat(String systemPrompt, String userMessage) throws IOException {
        // 1. 构建请求体
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("model", MODEL);
        requestBody.addProperty("temperature", 0.7);
        requestBody.addProperty("max_tokens", MAX_TOKENS);
        requestBody.addProperty("stream", false);
        requestBody.addProperty("enable_thinking", ENABLE_THINKING);

        // 构建 messages 数组
        JsonArray messages = new JsonArray();

        // 添加 system 消息
        if (systemPrompt != null && !systemPrompt.isEmpty()) {
            JsonObject systemMsg = new JsonObject();
            systemMsg.addProperty("role", "system");
            systemMsg.addProperty("content", systemPrompt);
            messages.add(systemMsg);
        }

        // 添加 user 消息
        JsonObject userMsg = new JsonObject();
        userMsg.addProperty("role", "user");
        userMsg.addProperty("content", userMessage);
        messages.add(userMsg);

        requestBody.add("messages", messages);

        // 2. 构建 HTTP 请求
        Request request = new Request.Builder()
                .url(API_URL)
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .post(RequestBody.create(
                        requestBody.toString(),
                        JSON
                ))
                .build();

        // 3. 发送请求并处理响应
        long requestStart = System.nanoTime();
        try (Response response = httpClient.newCall(request).execute()) {
            String traceId = response.header("x-siliconcloud-trace-id");
            long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - requestStart);

            // 检查响应状态
            if (!response.isSuccessful()) {
                String errorBody = response.body() != null ? response.body().string() : "No error body";
                throw new IOException(String.format(
                        "API 请求失败: %d, traceId=%s, body=%s",
                        response.code(),
                        traceId != null ? traceId : "N/A",
                        errorBody
                ));
            }

            // 解析响应 JSON
            if (response.body() == null) {
                throw new IOException("API 响应体为空");
            }
            String responseBody = response.body().string();
            JsonObject json = gson.fromJson(responseBody, JsonObject.class);

            // 提取回答内容
            JsonArray choices = json.getAsJsonArray("choices");
            if (choices == null || choices.size() == 0) {
                throw new IOException("响应中没有 choices");
            }

            if (traceId != null) {
                System.out.printf("[请求耗时] %d ms, traceId=%s%n", elapsedMs, traceId);
            } else {
                System.out.printf("[请求耗时] %d ms%n", elapsedMs);
            }

            String answer = choices.get(0).getAsJsonObject()
                    .getAsJsonObject("message")
                    .get("content").getAsString();

            // 打印 Token 使用情况
            if (json.has("usage")) {
                JsonObject usage = json.getAsJsonObject("usage");
                System.out.printf("[Token 使用] 输入: %d, 输出: %d, 总计: %d%n",
                        usage.get("prompt_tokens").getAsInt(),
                        usage.get("completion_tokens").getAsInt(),
                        usage.get("total_tokens").getAsInt());
            }

            if (choices.get(0).getAsJsonObject().has("finish_reason")) {
                String finishReason = choices.get(0).getAsJsonObject()
                        .get("finish_reason").getAsString();
                if ("length".equals(finishReason)) {
                    System.out.printf("[提示] 输出触发 max_tokens=%d 上限，如需更完整回答可调大该值，同时建议同步调大 readTimeout/callTimeout。%n",
                            MAX_TOKENS);
                }
            }

            return answer;
        } catch (SocketTimeoutException e) {
            throw new SocketTimeoutException(String.format(
                    "调用硅基流动超时（%d 秒）。当前示例已默认关闭 enable_thinking；如果你改回 true 或更换为更慢的推理模型，建议使用 stream=true，或继续增大 readTimeout/callTimeout。原始错误: %s",
                    CALL_TIMEOUT_SECONDS,
                    e.getMessage()
            ));
        }
    }

    public static void main(String[] args) {
        LLMClient client = new LLMClient();

        String systemPrompt = """
            你是一个专业的 Java 技术顾问，擅长解答 Java 相关的技术问题。
            回答要准确、简洁，如果涉及代码，请给出示例。
            如果不确定答案，请明确说明。
            """;

        String userMessage = "请解释一下 Java 中的 volatile 关键字有什么作用？";

        try {
            System.out.println("发送问题: " + userMessage);
            System.out.printf("等待回复... [model=%s, enableThinking=%s]%n%n", MODEL, ENABLE_THINKING);

            String answer = client.chat(systemPrompt, userMessage);

            System.out.println("=== 模型回答 ===");
            System.out.println(answer);
        } catch (IOException e) {
            System.err.println("调用失败: " + e.getMessage());
        }
    }
}

发送问题: 请解释一下 Java 中的 volatile 关键字有什么作用？
等待回复... [model=Qwen/Qwen3.5-122B-A10B, enableThinking=false]

[请求耗时] 61716 ms, traceId=ti_gowxb2k8nuoapfql24
[Token 使用] 输入: 67, 输出: 512, 总计: 579
[提示] 输出触发 max_tokens=512 上限，如需更完整回答可调大该值，同时建议同步调大 readTimeout/callTimeout。
=== 模型回答 ===
`volatile` 是 Java 中用于**保证变量的可见性** 和**禁止指令重排序** 的关键字，但它**不保证原子性** 。

### 核心作用

1. **保证可见性（Visibility）** 
   - 当一个线程修改了 `volatile` 变量，新值会立即刷新到主内存中。
   - 其他线程读取该变量时，会直接从主内存中获取最新值，而不是使用 CPU 缓存中的旧值。
   - 解决了多线程环境下，线程工作内存（CPU缓存）与主内存数据不一致的问题。

2. **禁止指令重排序（Ordering）** 
   - 编译器和处理器为了优化性能，可能会重排指令执行顺序。
   - `volatile` 通过插入**内存屏障（MemoryBarrier）** ，禁止重排序操作，确保代码按照程序规定的顺序执行。
   - 典型应用是**双重检查锁（DCL）单例模式** 中的 `instance` 变量。

### 关键限制：不保证原子性

`volatile` 只能保证“读”和“写”操作本身的可见性，无法保证复合操作的原子性（例如 `i++`）。

/**
 * 大模型 API 流式调用示例
 * 实现类似 ChatGPT 的打字机效果
 */
public class LLMStreamClient {

    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
    private static final String API_URL = "https://api.siliconflow.cn/v1/chat/completions";
    private static final String API_KEY = "替换成你的apiKey";
    private static final String MODEL = "Qwen/Qwen3.5-122B-A10B";
    /**
     * 该模型支持 thinking 模式；流式返回时 reasoning_content 可能出现，而 content 为 null。
     * 示例默认关闭 thinking，避免首次体验时既慢又需要额外解析思考流。
     */
    private static final boolean ENABLE_THINKING = false;
    private static final int MAX_TOKENS = 512;
    private static final int CONNECT_TIMEOUT_SECONDS = 30;
    private static final int READ_TIMEOUT_SECONDS = 300;
    private static final int WRITE_TIMEOUT_SECONDS = 30;
    private static final int CALL_TIMEOUT_SECONDS = 300;

    private final OkHttpClient httpClient;
    private final Gson gson;

    public LLMStreamClient() {
        this.httpClient = new OkHttpClient.Builder()
            .connectTimeout(CONNECT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .readTimeout(READ_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .writeTimeout(WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .retryOnConnectionFailure(true)
            .build();

        this.gson = new Gson();
    }

    /**
     * 回调接口，用于处理流式数据
     */
    public interface StreamCallback {
        /**
         * 收到新的文本片段
         */
        void onContent(String content);

        /**
         * 流式传输完成
         */
        void onComplete(String fullContent);

        /**
         * 发生错误
         */
        void onError(Exception e);
    }

    /**
     * 流式对话
     */
    public void chatStream(String systemPrompt, String userMessage, StreamCallback callback) {
        // 1. 构建请求体
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("model", MODEL);
        requestBody.addProperty("temperature", 0.7);
        requestBody.addProperty("max_tokens", MAX_TOKENS);
        requestBody.addProperty("stream", true);
        requestBody.addProperty("enable_thinking", ENABLE_THINKING);

        JsonArray messages = new JsonArray();

        if (systemPrompt != null && !systemPrompt.isEmpty()) {
            JsonObject systemMsg = new JsonObject();
            systemMsg.addProperty("role", "system");
            systemMsg.addProperty("content", systemPrompt);
            messages.add(systemMsg);
        }

        JsonObject userMsg = new JsonObject();
        userMsg.addProperty("role", "user");
        userMsg.addProperty("content", userMessage);
        messages.add(userMsg);

        requestBody.add("messages", messages);

        // 2. 构建请求
        Request request = new Request.Builder()
            .url(API_URL)
            .addHeader("Authorization", "Bearer " + API_KEY)
            .addHeader("Content-Type", "application/json")
            .addHeader("Accept", "text/event-stream")
            .post(RequestBody.create(
                requestBody.toString(),
                JSON
            ))
            .build();

        // 3. 异步执行请求
        httpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callback.onError(e);
            }

            @Override
            public void onResponse(Call call, Response response) {
                long requestStart = System.nanoTime();
                try (response) {
                    String traceId = response.header("x-siliconcloud-trace-id");
                    if (!response.isSuccessful()) {
                        String errorBody = response.body() != null ? response.body().string() : "No error body";
                        callback.onError(new IOException(String.format(
                            "API 请求失败: %d, traceId=%s, body=%s",
                            response.code(),
                            traceId != null ? traceId : "N/A",
                            errorBody
                        )));
                        return;
                    }

                    if (response.body() == null) {
                        callback.onError(new IOException("API 响应体为空"));
                        return;
                    }

                    StringBuilder fullContent = new StringBuilder();
                    String finishReason = null;

                    try (BufferedReader reader = new BufferedReader(
                            new InputStreamReader(response.body().byteStream()))) {

                        String line;
                        while ((line = reader.readLine()) != null) {
                            if (line.isBlank() || !line.startsWith("data:")) {
                                continue;
                            }

                            String data = line.substring(5).trim();
                            if ("[DONE]".equals(data)) {
                                break;
                            }

                            try {
                                JsonObject chunk = gson.fromJson(data, JsonObject.class);
                                JsonArray choices = chunk.getAsJsonArray("choices");
                                if (choices == null || choices.size() == 0) {
                                    continue;
                                }

                                JsonObject choice = choices.get(0).getAsJsonObject();
                                JsonObject delta = getAsJsonObject(choice, "delta");
                                if (delta == null) {
                                    continue;
                                }

                                String content = getNullableString(delta, "content");
                                if (content != null && !content.isEmpty()) {
                                    fullContent.append(content);
                                    callback.onContent(content);
                                }

                                String chunkFinishReason = getNullableString(choice, "finish_reason");
                                if (chunkFinishReason != null) {
                                    finishReason = chunkFinishReason;
                                }
                            } catch (JsonParseException | IllegalStateException e) {
                                // SSE 中可能夹杂非 JSON 行，或字段结构与普通 completion 不同，跳过即可。
                            }
                        }

                        long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - requestStart);
                        System.out.printf("%n[流式请求耗时] %d ms, traceId=%s%n",
                            elapsedMs,
                            traceId != null ? traceId : "N/A");
                        if ("length".equals(finishReason)) {
                            System.out.printf("[提示] 输出触发 max_tokens=%d 上限，如需更完整回答可调大该值。%n",
                                MAX_TOKENS);
                        }
                        callback.onComplete(fullContent.toString());
                    } catch (SocketTimeoutException e) {
                        callback.onError(new SocketTimeoutException(String.format(
                            "流式调用超时（%d 秒）。如果切换回 thinking 模式或增大 max_tokens，建议同步调大 readTimeout/callTimeout。原始错误: %s",
                            CALL_TIMEOUT_SECONDS,
                            e.getMessage()
                        )));
                    }
                } catch (IOException e) {
                    callback.onError(e);
                } catch (RuntimeException e) {
                    callback.onError(new IOException("解析流式响应失败: " + e.getMessage(), e));
                }
            }
        });
    }

    private static JsonObject getAsJsonObject(JsonObject parent, String memberName) {
        if (parent == null || !parent.has(memberName)) {
            return null;
        }
        JsonElement element = parent.get(memberName);
        if (element == null || element.isJsonNull() || !element.isJsonObject()) {
            return null;
        }
        return element.getAsJsonObject();
    }

    private static String getNullableString(JsonObject parent, String memberName) {
        if (parent == null || !parent.has(memberName)) {
            return null;
        }
        JsonElement element = parent.get(memberName);
        if (element == null || element.isJsonNull()) {
            return null;
        }
        return element.getAsString();
    }

    public static void main(String[] args) throws InterruptedException {
        LLMStreamClient client = new LLMStreamClient();

        String systemPrompt = "你是一个编程助手，用简洁清晰的方式解答问题。";
        String userMessage = "用 Java 写一个单例模式的示例";

        System.out.println("发送问题: " + userMessage);
        System.out.printf("模型: %s, enableThinking=%s%n", MODEL, ENABLE_THINKING);
        System.out.println("\n=== 模型回答（流式）===\n");

        // 用于等待异步调用完成
        Object lock = new Object();

        client.chatStream(systemPrompt, userMessage, new LLMStreamClient.StreamCallback() {
            @Override
            public void onContent(String content) {
                // 实时打印收到的内容（打字机效果）
                System.out.print(content);
                System.out.flush();
            }

            @Override
            public void onComplete(String fullContent) {
                System.out.println("\n\n=== 回答完成 ===");
                System.out.println("总长度: " + fullContent.length() + " 字符");
                
                synchronized (lock) {
                    lock.notify();
                }
            }

            @Override
            public void onError(Exception e) {
                System.err.println("\n发生错误: " + e.getMessage());
                
                synchronized (lock) {
                    lock.notify();
                }
            }
        });

        // 等待异步调用完成
        synchronized (lock) {
            // 最多等待 5 分钟
            lock.wait(300000);  
        }
    }
}

public class ConversationClient {

    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
    private static final String API_URL = "https://api.siliconflow.cn/v1/chat/completions";
    private static final String API_KEY = "设置你的apiKey";
    private static final String MODEL = "Qwen/Qwen3.5-122B-A10B";
    private static final boolean ENABLE_THINKING = false;
    private static final int MAX_TOKENS = 256;
    private static final int CONNECT_TIMEOUT_SECONDS = 30;
    private static final int READ_TIMEOUT_SECONDS = 180;
    private static final int CALL_TIMEOUT_SECONDS = 180;

    /**
     * 最大历史消息数（防止上下文过长）
     * */
    private static final int MAX_HISTORY_SIZE = 20;

    private final OkHttpClient httpClient;
    private final Gson gson;
    private final String systemPrompt;
    private final List<Message> conversationHistory;

    /**
     * 消息类
     */
    public static class Message {
        public String role;
        public String content;

        public Message(String role, String content) {
            this.role = role;
            this.content = content;
        }
    }

    public ConversationClient(String systemPrompt) {
        this.httpClient = new OkHttpClient.Builder()
            .connectTimeout(CONNECT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .readTimeout(READ_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .retryOnConnectionFailure(true)
            .build();

        this.gson = new Gson();
        this.systemPrompt = systemPrompt;
        this.conversationHistory = new ArrayList<>();
    }

    /**
     * 发送消息并获取回复
     */
    public String send(String userMessage) throws IOException {
        List<Message> requestMessages = buildRequestMessages(userMessage);

        // 1. 构建请求
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("model", MODEL);
        requestBody.addProperty("temperature", 0.7);
        requestBody.addProperty("max_tokens", MAX_TOKENS);
        requestBody.addProperty("stream", false);
        requestBody.addProperty("enable_thinking", ENABLE_THINKING);

        // 构建 messages：system + 历史对话
        JsonArray messages = new JsonArray();

        // 添加 system 消息
        JsonObject systemMsg = new JsonObject();
        systemMsg.addProperty("role", "system");
        systemMsg.addProperty("content", systemPrompt);
        messages.add(systemMsg);

        // 添加历史对话（最近的 MAX_HISTORY_SIZE 条）
        for (Message msg : requestMessages) {
            JsonObject msgJson = new JsonObject();
            msgJson.addProperty("role", msg.role);
            msgJson.addProperty("content", msg.content);
            messages.add(msgJson);
        }

        requestBody.add("messages", messages);

        // 3. 发送请求
        Request request = new Request.Builder()
            .url(API_URL)
            .addHeader("Authorization", "Bearer " + API_KEY)
            .addHeader("Content-Type", "application/json")
            .post(RequestBody.create(
                requestBody.toString(),
                JSON
            ))
            .build();

        long requestStart = System.nanoTime();
        try (Response response = httpClient.newCall(request).execute()) {
            String traceId = response.header("x-siliconcloud-trace-id");
            if (!response.isSuccessful()) {
                String errorBody = response.body() != null ? response.body().string() : "No error body";
                throw new IOException(String.format(
                    "请求失败: %d, traceId=%s, body=%s",
                    response.code(),
                    traceId != null ? traceId : "N/A",
                    errorBody
                ));
            }

            if (response.body() == null) {
                throw new IOException("API 响应体为空");
            }

            String body = response.body().string();
            JsonObject json = gson.fromJson(body, JsonObject.class);

            JsonArray choices = json.getAsJsonArray("choices");
            if (choices == null || choices.size() == 0) {
                throw new IOException("响应中没有 choices");
            }

            String answer = json.getAsJsonArray("choices")
                .get(0).getAsJsonObject()
                .getAsJsonObject("message")
                .get("content").getAsString();

            // 4. 请求成功后再提交本轮历史，避免失败重试造成重复上下文
            conversationHistory.add(new Message("user", userMessage));
            conversationHistory.add(new Message("assistant", answer));

            long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - requestStart);
            System.out.printf("[请求耗时] %d ms, traceId=%s%n",
                elapsedMs,
                traceId != null ? traceId : "N/A");

            // 打印 Token 使用情况
            if (json.has("usage")) {
                JsonObject usage = json.getAsJsonObject("usage");
                System.out.printf("[Token] 本轮: %d, 历史消息数: %d%n",
                    usage.get("total_tokens").getAsInt(),
                    conversationHistory.size());
            }

            String finishReason = getNullableString(choices.get(0).getAsJsonObject(), "finish_reason");
            if ("length".equals(finishReason)) {
                System.out.printf("[提示] 输出触发 max_tokens=%d 上限，如需更完整回答可调大该值，同时建议同步调大 readTimeout/callTimeout。%n",
                    MAX_TOKENS);
            }

            return answer;
        } catch (SocketTimeoutException e) {
            throw new SocketTimeoutException(String.format(
                "多轮对话调用超时（%d 秒）。当前示例已默认关闭 enable_thinking；如果改回 true 或调大 max_tokens，建议同步调大 readTimeout/callTimeout，或直接改成流式输出。原始错误: %s",
                CALL_TIMEOUT_SECONDS,
                e.getMessage()
            ));
        }
    }

    private List<Message> buildRequestMessages(String userMessage) {
        int startIndex = Math.max(0, conversationHistory.size() - MAX_HISTORY_SIZE);
        List<Message> requestMessages = new ArrayList<>(conversationHistory.subList(startIndex, conversationHistory.size()));
        requestMessages.add(new Message("user", userMessage));
        return requestMessages;
    }

    private static String getNullableString(JsonObject parent, String memberName) {
        if (parent == null || !parent.has(memberName)) {
            return null;
        }
        JsonElement element = parent.get(memberName);
        if (element == null || element.isJsonNull()) {
            return null;
        }
        return element.getAsString();
    }

    /**
     * 清空对话历史
     */
    public void clearHistory() {
        conversationHistory.clear();
        System.out.println("对话历史已清空");
    }

    /**
     * 获取对话历史
     */
    public List<Message> getHistory() {
        return new ArrayList<>(conversationHistory);
    }

    public static void main(String[] args) throws IOException {
        String systemPrompt = """
            你是一个友好的编程助手。
            记住用户之前说过的话，在对话中保持连贯性。
            回答要简洁明了。
            """;

        ConversationClient client = new ConversationClient(systemPrompt);
        Scanner scanner = new Scanner(System.in);

        System.out.println("=== 多轮对话演示 ===");
        System.out.println("输入 'quit' 退出，输入 'clear' 清空历史\n");

        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine().trim();

            if ("quit".equalsIgnoreCase(input)) {
                System.out.println("再见！");
                break;
            }

            if ("clear".equalsIgnoreCase(input)) {
                client.clearHistory();
                continue;
            }

            if (input.isEmpty()) {
                continue;
            }

            try {
                System.out.printf("助手: 正在思考... [model=%s, enableThinking=%s]%n",
                    MODEL,
                    ENABLE_THINKING);
                String answer = client.send(input);
                System.out.println("\n助手: " + answer + "\n");
            } catch (IOException e) {
                System.err.println("发生错误: " + e.getMessage());
            }
        }

        scanner.close();
    }
}

=== 多轮对话演示 ===
输入 'quit' 退出，输入 'clear' 清空历史

你: 你好，我叫小明
助手: 正在思考... [model=Qwen/Qwen3.5-122B-A10B, enableThinking=false]
[请求耗时] 2513 ms, traceId=ti_9e853c5mjbmufqudfl
[Token] 本轮: 64, 历史消息数: 2

助手: 你好，小明！很高兴认识你。有什么编程问题需要我帮忙吗？

你: 我想学习 Spring Boot
助手: 正在思考... [model=Qwen/Qwen3.5-122B-A10B, enableThinking=false]
[请求耗时] 13881 ms, traceId=ti_sxx4ah96dm296l9lai
[Token] 本轮: 194, 历史消息数: 4

助手: 太棒了，Spring Boot 是 Java 开发中最流行的框架之一，上手快且功能强大！

我们可以从以下几个步骤开始：
1. **基础准备** ：确保你熟悉 Java 基础（如注解、接口）和 Maven/Gradle。
2. **第一个项目** ：用 Spring Initializr 快速创建一个"Hello World"项目。
3. **核心概念** ：了解自动配置、依赖注入和 RESTful API 开发。

你想先了解**如何创建第一个项目** ，还是想直接聊聊**核心概念** ？

你: 从基础开始吧
助手: 正在思考... [model=Qwen/Qwen3.5-122B-A10B, enableThinking=false]
[请求耗时] 23357 ms, traceId=ti_o2vojopycyiyp7bk8e
[Token] 本轮: 408, 历史消息数: 6

助手: 没问题，小明！我们一步步来。

首先，**创建第一个项目** 是最快的上手方式：

1.  **访问官网工具** ：打开 [Spring Initializr](https://start.spring.io)。
2.  **填写配置** ：
    *   **Project** : Maven
    *   **Language** : Java
    *   **SpringBoot** : 选最新稳定版（如 3.x）
    *   **Dependencies** : 点击"Add dependencies"，搜索并添加 **SpringWeb** （这是开发网页和 API 的核心）。
3.  **生成代码** ：点击"Generate"下载压缩包，解压后用 IDE（如 IntelliJ IDEA 或 VS Code）打开。

**下一步** ：
项目里通常会有一个 `DemoApplication.java` 文件和一个 `Controller.java`（或者你需要自己新建一个）。

你需要我演示一下**如何写第一个"HelloWorld"接口** ，让你能在浏览器里看到结果吗？

curl -fsSL https://ollama.com/install.sh | sh

# 基础安装（仅 CPU）
docker run -d -p 11434:11434 --name ollama ollama/ollama

# 启用 GPU（需要 nvidia-container-toolkit）
docker run -d --gpus=all -p 11434:11434 --name ollama ollama/ollama

ollama --version
# 输出类似：ollama version 0.1.xxx

# 拉取 Qwen 2.5 7B 模型（约 4.5GB）
ollama pull qwen2.5:7b

# 拉取更小的模型（适合内存有限的情况）
ollama pull qwen2.5:3b

# 拉取更大的模型（效果更好）
ollama pull qwen2.5:14b

ollama run qwen2.5:7b

>>> 你好，介绍一下你自己
我是通义千问，一个由阿里云开发的大语言模型...

>>> 用 Python 写个快速排序
好的，这是一个 Python 实现的快速排序算法：

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

>>> /bye  （退出）

# 查看已下载的模型
ollama list

# 查看模型信息
ollama show qwen2.5:7b

# 删除模型
ollama rm qwen2.5:7b

# 停止 Ollama 服务
ollama stop

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5:7b",
    "messages": [
      {"role": "user", "content": "你好"}
    ]
  }'

// 云端调用
private static final String API_URL = "https://api.siliconflow.cn/v1/chat/completions";
private static final String API_KEY = "YOUR_API_KEY";

// 改成本地调用
private static final String API_URL = "http://localhost:11434/v1/chat/completions";
private static final String API_KEY = "ollama";  // 随便填，本地不校验