文字调整 日志打印优化 决策返回前端处理为空的现在返回 新增本地测试get请求的决策接口

slibra-admin/src/main/java/com/slibra/web/controller/business/GRPCController.java

@@ -76,6 +76,160 @@ public class GRPCController extends BaseController {
     private BigModelConfig bigModelConfig;
 
 
+    /**
+     *
+     * get请求测试决策输出
+     *
+     * @param response
+     */
+    @GetMapping(value = "/test/aaa")
+    public void decisionStreamTest(HttpServletResponse response)
+//    public void decisionStream(HttpServletResponse response,  ChatReq chatReq)
+    {
+        log.info("进入了调⽤大模型决策接口");
+        ChatReq chatReq = new ChatReq();
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("2_2", "正常");
+        map.put("4_25", "没有");
+        map.put("2_28", "否");
+        map.put("6_3", "超标");
+        chatReq.setFeedback(JSON.toJSONString(map));
+        chatReq.setCategory("出水氨氮");
+        chatReq.setWarningId("782");
+        chatReq.setSimulate("{}");
+        // 获取输出流
+        OutputStream outputStream = null;
+        ManagedChannel channel = null;
+        //response.setContentType("text/plain");
+        response.setContentType("text/event-stream");
+        response.setCharacterEncoding("utf-8");
+        //2024年5月29日14:15:58 新增逻辑，判断报警状态是否已经结束了，如果结束了就直接模拟一个report返回给前端，不再调用大模型
+        String warningId = chatReq.getWarningId();
+        if(StringUtils.isBlank(warningId))
+            throw new ServiceException("请输入正确的告警id");
+        TXinyiWarningRecord xinyiWarningRecord = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordById(Long.parseLong(warningId));
+        if(Objects.isNull(xinyiWarningRecord))
+            throw new ServiceException("请输入正确的告警id,没有查询到告警信息");
+        if(1 == xinyiWarningRecord.getStatus() || 2 == xinyiWarningRecord.getStatus()){
+            //已经关闭的报警，不允许再次点击报警了
+            String message = this.buildMsg();
+            try {
+                outputStream = response.getOutputStream();
+                outputStream.write(message.getBytes());
+                outputStream.flush();
+                return;//输出完提示信息就结束
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        //大模型结果 放入一个结合中
+        List<String> resultData = new ArrayList<>();
+        //决策和问答不一样 没有历史的概念 所以sessionId都是新的  次数都是1
+        String sessionId = IdUtils.simpleUUID();
+        String feedback = chatReq.getFeedback();
+        String simulate = chatReq.getSimulate();
+        int type = 3;//仿真预测
+        if(StringUtils.isBlank(simulate) || "{}".equals(simulate))
+            type = 1;//决策
+        //决策请求的业务参数
+        List<DecisionReq> decisionReqs = getDecisionReqs();
+//        String rows = JSON.toJSONString(decisionReqs, JSONWriter.Feature.WriteNulls);
+        boolean needAdd = true;//标识变量是否可以保存
+        String dataJson = "";
+        try {
+            channel = ManagedChannelBuilder.forAddress(bigModelConfig.getIp(), bigModelConfig.getPort())
+                    .usePlaintext()
+                    .build();
+            InferenceAPIsServiceGrpc.InferenceAPIsServiceBlockingStub stub = InferenceAPIsServiceGrpc.newBlockingStub(channel);
+//            dataJson = "{\"bot_id\":\"b00001\",\"exp_id\":\"721\",\"norm\":\"" + chatReq.getCategory() + "\",\"feedback\":" + feedback + ",\"simulate\":" + simulate + ",\"session_id\":" + "\"" + sessionId + "\"" + ",\"generate_args\":{\"max_new_tokens\":1024,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{\"rows\":" +  rows + "}}";
+            //2024年6月24日17:59:17  优化，不再拼接JSON字符串
+            dataJson = buildBigModelReqForDecision(chatReq, feedback, simulate, sessionId, decisionReqs, xinyiWarningRecord, chatReq.getTopP(), chatReq.getTemperature());
+//            log.info("请求大模型的决策的参数为{}", dataJson);
+            PredictionsRequest request = PredictionsRequest.newBuilder()
+                    .setModelName("slibra_bot")
+                    .putInput("method", ByteString.copyFrom("decision_stream", "utf-8"))//推理
+                    .putInput("data", ByteString.copyFrom(dataJson, "utf-8"))
+                    .buildPartial();
+            outputStream = response.getOutputStream();
+            Iterator<PredictionResponse> predictions = stub.streamPredictions(request);
+            int i = 0 ;
+            while (predictions.hasNext()) {
+                String responseStr = predictions.next().getPrediction().toStringUtf8();
+//                log.info("决策流式返回的结果是{}", responseStr);
+                if(StringUtils.isBlank(responseStr)){
+                    log.info("大模型返回的流式决策内容存在空的值，跳过此次输出");
+                    continue;
+                }
+                String message = JSON.parseObject(responseStr).getString("message");
+                //2024年5月25日16:37:16  按照大模型返回的类型解析数据
+                String biz = JSON.parseObject(responseStr).getString("biz");
+//                String message = JSON.parseObject(responseStr).getString("message");
+                if(BusinessEnum.BigModelBizEnum.OK.getCode().equals(biz)){
+                    log.info("结尾语句并且是非JSON，无需处理，返回数据为{}", responseStr);
+                    //结束语句也流式输出，但是并不记录下来  2024年5月24日11:15:23 也不返回前端
+                }else if(BusinessEnum.BigModelBizEnum.DECISION_DEBUGGER.getCode().equals(biz)){
+                    log.info("中间过程，目前只打印日志，不记录数据，也不返回给前端，返回数据为{}", responseStr);
+                    //结束语句也流式输出，但是并不记录下来  2024年5月24日11:15:23 也不返回前端
+                    //2024年6月23日14:55:19 如果大模型返回error了，不保存记录，并且提示一句错误语
+                }else if(BusinessEnum.BigModelBizEnum.ERROR.getCode().equalsIgnoreCase(biz)){
+                    log.info("调用大模型的时候，返回的是ERROR，返回数据为{}", responseStr);
+                    needAdd = false;
+                    //返回的是error 给前端返回一句话
+                    try {
+                        String errMsg = this.buildErrMsg();
+                        outputStream.write(errMsg.getBytes());
+                        outputStream.flush();
+                    } catch (IOException ex) {
+                        throw new RuntimeException(ex);
+                    }
+                } else{//其他 要么alert 要么出的报告
+//                    if(StringUtils.isBlank(message)){
+//                        log.info("×××××××××××××××××××××××××××为空的数据暂时不返回×××××××××××××××××××××××××××");
+//                    }else {
+//                    log.info("返回给前端的数据是{}", responseStr);
+                    resultData.add(responseStr);
+                    responseStr = responseStr + (i++) + "\n";
+                    outputStream.write(responseStr.getBytes());
+                    outputStream.flush();
+                    //2024年7月12日17:47:08 加个打印，处理只要report类型的拼接结果
+                    if(BusinessEnum.BigModelBizEnum.DECISION_REPORT.getCode().equalsIgnoreCase(biz)){
+                        sb.append(message);
+                    }
+//                    }
+                }
+            }
+        } catch (Exception e) {
+//            throw new RuntimeException(e);
+            log.error("处理大模型推理异常，异常信息为{}", JSON.toJSONString(e));
+            //出现异常 给前端返回一句话
+            try {
+                outputStream = response.getOutputStream();
+                String errMsg = this.buildErrMsg();
+                outputStream.write(errMsg.getBytes());
+                outputStream.flush();
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        } finally {
+//            log.info("sessionId是{}\n决策最终要保存的数据是{}", sessionId, JSON.toJSONString(resultData));
+//            log.info("~~~~~~~~~~~~~~~决策最终返回的报告数据是{}", sb.toString());
+            //保存聊天记录
+            //将问答更新到数据库中
+            needAdd = false;
+            if(needAdd)
+                addChatRecord(chatReq, sessionId, type, warningId, dataJson, resultData);
+            // 关闭输出流
+            try {
+                outputStream.close();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }finally {
+                channel.shutdown();
+            }
+        }
+    }
+
 
     /**
      * 调⽤大模型决策接口 + 仿真预测
@@ -134,7 +288,7 @@ public class GRPCController extends BaseController {
 //            dataJson = "{\"bot_id\":\"b00001\",\"exp_id\":\"721\",\"norm\":\"" + chatReq.getCategory() + "\",\"feedback\":" + feedback + ",\"simulate\":" + simulate + ",\"session_id\":" + "\"" + sessionId + "\"" + ",\"generate_args\":{\"max_new_tokens\":1024,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{\"rows\":" +  rows + "}}";
             //2024年6月24日17:59:17  优化，不再拼接JSON字符串
             dataJson = buildBigModelReqForDecision(chatReq, feedback, simulate, sessionId, decisionReqs, xinyiWarningRecord, chatReq.getTopP(), chatReq.getTemperature());
-            log.info("请求大模型的决策的参数为{}", dataJson);
+//            log.info("请求大模型的决策的参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("decision_stream", "utf-8"))//推理
@@ -144,7 +298,7 @@ public class GRPCController extends BaseController {
             Iterator<PredictionResponse> predictions = stub.streamPredictions(request);
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("决策流式返回的结果是{}", responseStr);
+//                log.info("决策流式返回的结果是{}", responseStr);
                 if(StringUtils.isBlank(responseStr)){
                     log.info("大模型返回的流式决策内容存在空的值，跳过此次输出");
                     continue;
@@ -173,13 +327,17 @@ public class GRPCController extends BaseController {
                     }
                 } else{//其他 要么alert 要么出的报告
 //                    sb.append(responseStr);
-                    if(StringUtils.isBlank(message)){
+                    //2024年7月13日13:48:48  空的数据也返回，否则样式会有问题（当时加上这个是为了前端正常解析，否则他那里一次接受多个）
+                    /*if(StringUtils.isBlank(message)){
                         log.info("×××××××××××××××××××××××××××为空的数据暂时不返回×××××××××××××××××××××××××××");
                     }else {
                         resultData.add(responseStr);
                         outputStream.write(responseStr.getBytes());
                         outputStream.flush();
-                    }
+                    }*/
+                    resultData.add(responseStr);
+                    outputStream.write(responseStr.getBytes());
+                    outputStream.flush();
                 }
             }
         } catch (Exception e) {
@@ -195,7 +353,7 @@ public class GRPCController extends BaseController {
                 throw new RuntimeException(ex);
             }
         } finally {
-            log.info("sessionId是{}\n决策最终要保存的数据是{}", sessionId, JSON.toJSONString(resultData));
+//            log.info("sessionId是{}\n决策最终要保存的数据是{}", sessionId, JSON.toJSONString(resultData));
             //保存聊天记录
             //将问答更新到数据库中
             if(needAdd)
@@ -440,7 +598,7 @@ public class GRPCController extends BaseController {
 //            String dataJson = "{\"bot_id\":\"721\",\"exp_id\":\"721\",\"session_id\":\"" + sessionId + "\",\"use_rag\":\"true\",\"prompt\":\"你是LibraAI水务大模型，由红杉天枰开发的水务垂直大语言模型，能够提供水务行业专家问答、智能决策、报表分析、智能工单管理等一系列功能，作为水务人的AI助手，你会竭尽全力帮助我处理工作问题。\",\"history_dia\":" + JSON.toJSONString(historyDates) + ",\"generate_args\":{\"max_new_tokens\":2048,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{ \"ip_address\": \"" + ipAddr  + "\" },\"strengthen\":" + (isStrong == 1) + "}";
             //2024年6月25日18:12:23 优化，不再使用拼接JSON字符串
             String dataJson = buildBigModelReqForChat(sessionId, historyDates, ipAddr, isStrong, chatReq.getTopP(), chatReq.getTemperature(), tools, useRag);
-            log.info("请求大模型的问答参数为{}", dataJson);
+//            log.info("请求大模型的问答参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("infer_stream", "utf-8"))//推理
@@ -451,7 +609,7 @@ public class GRPCController extends BaseController {
             //将结果记录到问答表
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("大模型问答返回的原始结果为{}", responseStr);
+//                log.info("大模型问答返回的原始结果为{}", responseStr);
                 responseStr = JSON.parseObject(responseStr).getString("message");
                 if("complete".equals(responseStr) || StringUtils.isBlank(responseStr)){
 //                    System.out.println("结尾语句并且是非JSON，无需处理");
@@ -759,7 +917,7 @@ public class GRPCController extends BaseController {
 //            String dataJson = "{\"bot_id\":\"b00001\",\"exp_id\":\"721\",\"norm\":\"出水氨氮\",\"session_id\":\" " + IdUtils.simpleUUID() + "  \",\"extra\":{}}";
             //2024年6月27日13:23:25  优化：改成非拼接JSON字符串
             String dataJson = buildBigModelReqForPredictor("出水氨氮");
-            log.info("请求大模型的预测的参数为{}", dataJson);
+//            log.info("请求大模型的预测的参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("predictor", "utf-8"))//推理
@@ -772,7 +930,7 @@ public class GRPCController extends BaseController {
             log.info("大模型问答返回的原始结果为{}", responseStr);*/
             PredictionResponse predictions = stub.predictions(request);
             String responseStr = predictions.getPrediction().toStringUtf8();
-            log.info("大模型问答返回的原始结果为{}", responseStr);
+//            log.info("大模型问答返回的原始结果为{}", responseStr);
         } catch (IOException e) {
             throw new RuntimeException(e);
         } finally {

slibra-admin/src/main/resources/application-local.yml

@@ -109,6 +109,6 @@ oss:
 #默认走测试环境
 big-model:
   ip: 10.0.0.24
-  port: 27070
+  port: 17070
   temperature: 0.7
   topP: 0.7

slibra-common/src/main/java/com/slibra/common/constant/MyConstants.java

@@ -158,8 +158,8 @@ public class MyConstants {
     public static final String CHAT_GONGDAN_2_ERROR_MSG = "很抱歉，当前日期指标没有数据，请查证后再试";
     public static final String CHAT_GONGDAN_CUSTOM_ERROR_MSG = "很抱歉，数据分析维度过多，请尝试减少时间区间或统计数据项再试...";
 
-    public static final String GONGDAN_TITLE = "请生成#{0}智能工单分析报告";
-    public static final String GONGDAN_TITLE_CUSTOM = "请成生#{0}-#{1}日的日报工单";
+    public static final String GONGDAN_TITLE = "#{0}智能工单分析报告";
+    public static final String GONGDAN_TITLE_CUSTOM = "#{0}-#{1}日的日报工单";
 
     public static final String GONGDAN_PROMPT_BEGIN = "作为一个工艺分析师，请生成一份#{0}分析报告，根据我提供的详细数据，输出一份详细的分析报告。报告需数据准确、分析深入，建议具体可行，以便为水务管理和决策提供支持。报告分为三部分：\n" +
             "1、水质数据、生化数据：以下是#{0}详细数据，必须要使用表格形式展现\n" +

slibra-quartz/src/main/java/com/slibra/quartz/task/AsyncTask.java

@@ -1181,7 +1181,7 @@ public class AsyncTask {
 //            String dataJson = "{\"bot_id\":\"721\",\"exp_id\":\"721\",\"session_id\":\"" + sessionId + "\",\"use_rag\":\"true\",\"prompt\":\"你是⼀个资深⽔务领域专家，能回答各种⽔务相关问题\",\"history_dia\":" + JSON.toJSONString(historyDates) + ",\"generate_args\":{\"max_new_tokens\":2048,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{ \"ip_address\": \"" + ipAddr  + "\" },\"strengthen\":" + (true) + "}";
             //2024年6月27日13:29:18 优化，不再使用拼接JSON字符串
             String dataJson = buildBigModelReqForChat(sessionId, historyDates, ipAddr, false);
-            log.info("请求大模型的问答参数为{}", dataJson);
+//            log.info("请求大模型的问答参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("infer_stream", "utf-8"))//推理
@@ -1191,7 +1191,7 @@ public class AsyncTask {
             //将结果记录到问答表
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("大模型问答返回的原始结果为{}", responseStr);
+//                log.info("大模型问答返回的原始结果为{}", responseStr);
                 responseStr = JSON.parseObject(responseStr).getString("message");
                 if("complete".equals(responseStr)){
                     log.info("结尾语句并且是非JSON，无需处理");
@@ -1355,7 +1355,7 @@ public class AsyncTask {
                 map.put("source", "gkz");
             policyReq.setExtra(map);
             dataJson = JSON.toJSONString(policyReq, JSONWriter.Feature.WriteNulls);
-            log.info("请求大模型的决策的参数为{}", dataJson);
+//            log.info("请求大模型的决策的参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("decision_stream", "utf-8"))//推理
@@ -1364,7 +1364,7 @@ public class AsyncTask {
             Iterator<PredictionResponse> predictions = stub.streamPredictions(request);
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("决策流式返回的结果是{}", responseStr);
+//                log.info("决策流式返回的结果是{}", responseStr);
 
                 //2024年5月25日16:37:16  按照大模型返回的类型解析数据
                 String biz = JSON.parseObject(responseStr).getString("biz");
@@ -1388,7 +1388,7 @@ public class AsyncTask {
             log.error("定时任务处理告警调用决策异常，异常信息为{}", JSON.toJSONString(e));
             resultData.add("{\"biz\":\"ERROR\",\"message\":\"大模型分析数据异常，请稍后再试\"}");
         } finally {
-            log.info("决策最终要保存的数据是{}", JSON.toJSONString(resultData));
+//            log.info("决策最终要保存的数据是{}", JSON.toJSONString(resultData));
             //保存聊天记录
             //将问答更新到数据库中
             chatReq.setSessionId(sessionId);

slibra-quartz/src/main/java/com/slibra/quartz/task/RyTask.java

@@ -655,7 +655,7 @@ public class RyTask
         //暂时不考虑因为没有填写日报 导致生成重复数据的问题（后续需要的话再添加）
         //处理数据 并 拼装
         String queryData = buildShortReportQueryDataNew(dailyTwoRecords);
-        log.info("定时生成简报，组装好的请求大模型的参数为:{}", queryData);
+//        log.info("定时生成简报，组装好的请求大模型的参数为:{}", queryData);
         if(StringUtils.isBlank(queryData)){
             log.error("无法拼装请求数据！！！！！！");
             return;
@@ -802,7 +802,7 @@ public class RyTask
             for (int i = 0; i < split1.length; i++) {
                 splitNew[i] = String.valueOf((Double.parseDouble(split1[i]) + Double.parseDouble(split2[i]))/2/0.8);
             }
-            log.info("取完平均值再组装的数组为{}", Arrays.toString(splitNew));
+//            log.info("取完平均值再组装的数组为{}", Arrays.toString(splitNew));
             //解析数据 处理报警 调研prompt 保存等
             this.handlePredictorWarningSpecialTn(splitNew, hour1, "tn", tXinyiIndustries6, tXinyiRobots6, date1);
         }else {
@@ -1332,7 +1332,7 @@ public class RyTask
 //            String dataJson = "{\"bot_id\":\"721\",\"exp_id\":\"721\",\"session_id\":\"" + sessionId + "\",\"use_rag\":\"true\",\"prompt\":\"你是⼀个资深⽔务领域专家，能回答各种⽔务相关问题\",\"history_dia\":" + JSON.toJSONString(historyDates) + ",\"generate_args\":{\"max_new_tokens\":2048,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{ \"ip_address\": \"" + ipAddr  + "\" },\"strengthen\":" + (true) + "}";
             //2024年6月27日10:51:47  优化：不再手动拼接JSON字符串
             String dataJson = buildBigModelReqForChat(sessionId, historyDates);
-            log.info("请求大模型的问答参数为{}", dataJson);
+//            log.info("请求大模型的问答参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("infer_stream", "utf-8"))//推理
@@ -1342,7 +1342,7 @@ public class RyTask
             //将结果记录到问答表
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("大模型问答返回的原始结果为{}", responseStr);
+//                log.info("大模型问答返回的原始结果为{}", responseStr);
                 responseStr = JSON.parseObject(responseStr).getString("message");
                 if("complete".equals(responseStr)){
                     log.info("结尾语句并且是非JSON，无需处理");
@@ -1400,7 +1400,7 @@ public class RyTask
 //            String dataJson = "{\"bot_id\":\"b00001\",\"exp_id\":\"721\",\"norm\":\"" + type + "\",\"session_id\":\" " + IdUtils.simpleUUID() + "  \",\"extra\":{}}";
             //2024年6月27日13:23:25  优化：改成非拼接JSON字符串
             String dataJson = buildBigModelReqForPredictor(type);
-            log.info("请求大模型的预测的参数为{}", dataJson);
+//            log.info("请求大模型的预测的参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("predictor", "utf-8"))//推理
@@ -1467,7 +1467,7 @@ public class RyTask
 //            String dataJson = "{\"bot_id\":\"721\",\"exp_id\":\"721\",\"session_id\":\"" + sessionId + "\",\"use_rag\":\"true\",\"prompt\":\"你是⼀个资深⽔务领域专家，能回答各种⽔务相关问题\",\"history_dia\":" + JSON.toJSONString(historyDates) + ",\"generate_args\":{\"max_new_tokens\":2048,\"max_length\":4096,\"num_beams\":1,\"do_sample\":true,\"top_p\":0.7,\"temperature\":0.95},\"extra\":{ \"ip_address\": \"" + ipAddr  + "\" },\"strengthen\":" + (true) + "}";
             //2024年6月27日10:51:47  优化：不再手动拼接JSON字符串
             String dataJson = buildBigModelReqForChat(sessionId, historyDates);
-            log.info("请求大模型的问答参数为{}", dataJson);
+//            log.info("请求大模型的问答参数为{}", dataJson);
             PredictionsRequest request = PredictionsRequest.newBuilder()
                     .setModelName("slibra_bot")
                     .putInput("method", ByteString.copyFrom("infer_stream", "utf-8"))//推理
@@ -1477,7 +1477,7 @@ public class RyTask
             //将结果记录到问答表
             while (predictions.hasNext()) {
                 String responseStr = predictions.next().getPrediction().toStringUtf8();
-                log.info("大模型问答返回的原始结果为{}", responseStr);
+//                log.info("大模型问答返回的原始结果为{}", responseStr);
                 responseStr = JSON.parseObject(responseStr).getString("message");
                 if("complete".equals(responseStr)){
                     System.out.println("结尾语句并且是非JSON，无需处理");