添加向量库

qianbao
1 parent e24472f7
Showing 19 changed files with 1545 additions and 230 deletions
pom.xml
src/main/java/com/xly/agent/ErpAiAgent.java
src/main/java/com/xly/entity/AiResponseDTO.java
src/main/java/com/xly/entity/ToolMeta.java
src/main/java/com/xly/entity/UserSceneSession.java
src/main/java/com/xly/milvus/service/AiGlobalAgentQuestionSqlEmitterService.java
src/main/java/com/xly/milvus/service/MilvusService.java
src/main/java/com/xly/milvus/service/impl/AiGlobalAgentQuestionSqlEmitterServiceImpl.java
src/main/java/com/xly/milvus/service/impl/MilvusServiceImpl.java
src/main/java/com/xly/ocr/service/OcrService.java
src/main/java/com/xly/ocr/test/Main.java
src/main/java/com/xly/ocr/test/Test.java
src/main/java/com/xly/ocr/web/OcrController.java
src/main/java/com/xly/service/XlyErpService.java
src/main/java/com/xly/thread/AiUserAgentQuestionThread.java
src/main/java/com/xly/tool/DynamicToolProvider.java
src/main/java/com/xly/tts/bean/TTSResponseDTO.java
src/main/java/com/xly/tts/service/PythonTtsProxyService.java
src/main/resources/application.yml
@@ -106,13 +106,41 @@
 			<artifactId>spring-boot-starter-webflux</artifactId>
 		</dependency>
+		<!-- Tess4J OCR -->
 		<dependency>
 			<groupId>net.sourceforge.tess4j</groupId>
 			<artifactId>tess4j</artifactId>
 			<version>${tess4j.version}</version>
-			<scope>compile</scope>
 		</dependency>
+		<!-- 官方 PaddleOCR Java SDK（最新稳定版） -->
+		<dependency>
+			<groupId>io.github.mymonstercat</groupId>
+			<artifactId>rapidocr</artifactId>
+			<version>0.0.7</version>
+		</dependency>
+
+		<dependency>
+			<groupId>io.github.mymonstercat</groupId>
+			<artifactId>rapidocr-onnx-platform</artifactId>
+			<version>0.0.7</version>
+		</dependency>
+
+		<!-- ONNX Runtime（必需） -->
+<!--		<dependency>-->
+<!--			<groupId>com.microsoft.onnxruntime</groupId>-->
+<!--			<artifactId>onnxruntime</artifactId>-->
+<!--			<version>1.17.0</version>-->
+<!--		</dependency>-->
+
+		<!-- 图片处理 -->
+		<dependency>
+			<groupId>commons-io</groupId>
+			<artifactId>commons-io</artifactId>
+			<version>2.15.1</version>
+		</dependency>
+
+
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-thymeleaf</artifactId>
@@ -335,12 +363,7 @@
 			<version>${langchain4j.version}</version>
 		</dependency>
-		<!-- ONNX Runtime（必需） -->
-		<dependency>
-			<groupId>com.microsoft.onnxruntime</groupId>
-			<artifactId>onnxruntime</artifactId>
-			<version>1.17.0</version>
-		</dependency>
+
 		<!-- 或者使用 Apache Tika 直接 -->
@@ -11,14 +11,14 @@ import dev.langchain4j.service.V;
  */
 public interface ErpAiAgent {
     @SystemMessage("""
-    1. 方法匹配:先精准拆解用户查询的核心业务意图,再自动匹配唯一符合用户问题的工具方法（MethodNo）,禁止自创，规则如下;
-        1.1 匹配方法时,无需考虑工具描述(@TOOL)中 1.必填参数，2.选填参数，示例，parameters内容 四个部分的内容；
-        1.2 匹配方法时,只关注工具描述(@TOOL)中 “当用户” 和 “时，必须调用本工具”两个短语之间的内容；
-        1.3 调用工具前，不需要询问用户提供缺失的参数
-    2. 参数提取:提取该工具的全部参数,与描述完全一致,严格按标注类型赋值，规则如下：
-        2.1 数字无引号,为空时禁止赋值0；
-        2.2 如果有空格需要去掉空格后再提取。
-    """)
+            1. 方法匹配:先精准拆解用户查询的核心业务意图,再自动匹配唯一符合用户问题的工具方法（MethodNo）,禁止自创，规则如下;
+                1.1 匹配方法时,无需考虑工具描述(@TOOL)中 1.必填参数，2.选填参数，示例，parameters内容 四个部分的内容；
+                1.2 匹配方法时,只关注工具描述(@TOOL)中 “当用户” 和 “时，必须调用本工具”两个短语之间的内容；
+                1.3 调用工具前，不需要询问用户提供缺失的参数
+            2. 参数提取:提取该工具的全部参数,与描述完全一致,严格按标注类型赋值，规则如下：
+                2.1 数字无引号,为空时禁止赋值0；
+                2.2 如果有空格需要去掉空格后再提取。
+            """)
     @UserMessage("用户输入：{{userInput}}")
     String chat(@MemoryId String userId, @V("userInput") String userInput);
@@ -27,16 +27,16 @@ public interface ErpAiAgent {
      * 入参：用户问题、执行的SQL、表结构、JSON格式结果
      */
     @SystemMessage("""
-        你是专业的业务数据分析师，严格遵循以下**通用规则**解释查询结果，适用于所有业务场景：
-            1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
-            2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
-            3. 输出格式：仅返回解释内容，不要列出ID,无多余标题、换行、符号,结果为空时直接返回“未查询到相关数据”
-                3.1. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 1000000，错误写法是 1,000,000,即使数字很大，也请保持连续的数字串，不要打断。
-                3.2  所有日期请转换为 YYYY-MM-DD 格式（例如：2026-03-15）,严禁包含时间部分（如小时、分钟、秒）（例如：2026-03-15 00:00:00），也不要包含时区信息。”
-                3.3. 金额,单价,数量 严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 2400056，错误写法是 2,400,056 即使数字很大，也请保持连续的数字串，不要打断。
-            4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
-            5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
-            """)
+            你是专业的业务数据分析师，严格遵循以下**通用规则**解释查询结果，适用于所有业务场景：
+                1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
+                2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
+                3. 输出格式：仅返回解释内容，不要列出ID,无多余标题、换行、符号,结果为空时直接返回“未查询到相关数据”
+                    3.1. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 1000000，错误写法是 1,000,000,即使数字很大，也请保持连续的数字串，不要打断。
+                    3.2  所有日期请转换为 YYYY-MM-DD 格式（例如：2026-03-15）,严禁包含时间部分（如小时、分钟、秒）（例如：2026-03-15 00:00:00），也不要包含时区信息。”
+                    3.3. 金额,单价,数量 严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 2400056，错误写法是 2,400,056 即使数字很大，也请保持连续的数字串，不要打断。
+                4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
+                5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
+                """)
     @UserMessage("""
             【业务场景表结构信息】
             表结构详情：{{tableStruct}}
@@ -57,119 +57,143 @@ public interface ErpAiAgent {
      * 入参：用户问题、执行的SQL、表结构、JSON格式结果
      */
     @SystemMessage("""
-    你是专业的业务数据分析师，请分析以下查询结果：
-    【用户问题】
-    {{userInput}}
-    【数据字段说明】
-    {{sMilvusFiledDescription}}
-    【查询结果数据（JSON格式）】
-    {{result}}
-    【分析要求】
-    1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
-    2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
-    3. 输出格式：
-       3.1. 如果用户要求"表格形式展示"，先输出简短文字说明，然后输出Markdown格式的表格
-       3.2. 如果用户未要求表格，仅返回解释内容，不要列出ID,无多余标题、换行、符号
-       3.3. 结果为空时直接返回"未查询到相关数据"
-       3.4. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）
-       3.5. 所有日期请转换为 YYYY-MM-DD 格式，严禁包含时间部分
-    4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
-    5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
-    """)
+            你是专业的业务数据分析师，请分析以下查询结果：
+            【用户问题】
+            {{userInput}}
+            【数据字段说明】
+            {{sMilvusFiledDescription}}
+            【查询结果数据（JSON格式）】
+            {{result}}
+            【分析要求】
+            1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
+            2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
+            3. 输出格式：
+               3.1. 如果用户要求"表格形式展示"，先输出简短文字说明，然后输出Markdown格式的表格
+               3.2. 如果用户未要求表格，仅返回解释内容，不要列出ID,无多余标题、换行、符号
+               3.3. 结果为空时直接返回"未查询到相关数据"
+               3.4. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）
+               3.5. 所有日期请转换为 YYYY-MM-DD 格式，严禁包含时间部分
+            4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
+            5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
+            """)
     @UserMessage("""
-    【用户查询】
-    {{userInput}}
-    【字段说明】
-    {{sMilvusFiledDescription}}
-    【查询结果】
-    用户原始查询：{{userInput}}
-    执行查询向量库后结果（JSON格式）：{{result}}
-    请根据上述信息+通用规则，对查询结果做业务解释：
-    """)
+            【用户查询】
+            {{userInput}}
+            【字段说明】
+            {{sMilvusFiledDescription}}
+            【查询结果】
+            用户原始查询：{{userInput}}
+            执行查询向量库后结果（JSON格式）：{{result}}
+            请根据上述信息+通用规则，对查询结果做业务解释：
+            """)
     String explainMilvusResult(@MemoryId String userId,
                                @V("userInput") String userInput,
                                @V("sMilvusFiledDescription") String sMilvusFiledDescription,
                                @V("result") String result);
-    /**
-     * AI路由判断接口
-     * true: 走聚合查询（MySQL）
-     * false: 走向量检索（Milvus）
-     */
-//    @SystemMessage("""
-//    你是一个智能查询路由专家，请根据用户需求判断应该使用哪种查询方式。
-//
-//    判断标准：
-//    1. 返回 true（聚合查询/MySQL）的场景：
-//       - 需要计算统计指标：总数、总和、平均值、最大/最小值、占比
-//       - 需要数据汇总：分组统计、排行榜、TopN
-//       - 包含关键词：统计、求和、汇总、排名、平均、数量、总额、最高、最低、占比、分组、分析、趋势
-//       - 示例：统计本月销售总额、查询销量前10的商品、各品类占比分析
-//
-//    2. 返回 false（向量检索/Milvus）的场景：
-//       - 查询明细数据：XXX的销售订单明细、XXX的客户信息、具体内容详情
-//       - 查找相似内容：根据语义查找相关文档、推荐相似商品
-//       - 模糊匹配：不确定具体关键词，需要语义理解
-//       - 内容检索：查找包含特定概念的文档
-//       - 包含关键词：明细、详情、查询明细、查找、搜索、匹配、推荐、相似、相关、类似
-//       - 示例：李留记的销售订单明细、查询关于人工智能的文档、找相似的图片
-//
-//    重要规则：
-//    - 只返回 true 或 false，不要返回其他内容
-//    - 不要解释，不要添加额外文字
-//    - 如果用户要求"表格形式展示"，返回 false（明细查询）
-//    - 如果用户指定具体人名、具体对象，返回 false（明细查询）
-//    """)
-//    @UserMessage("用户需求：{{userInput}}")
     @SystemMessage("""
-            你是一个智能查询路由专家。请根据【用户需求】，只返回 true 或 false
-            - 如果用户需求包含以下关键词：统计、求和、汇总、排名、TopN、平均、数量、总额、最高、最低、占比、分组，则返回true
-            - 如果用户需求属于模糊匹配、普通语义检索，查询明细，(例如:查询报价单明细,查询客户信息)，则返回false
-            - 查询明细数据：XXX的销售订单明细、XXX的客户信息、具体内容详情，则返回false
-            - 模糊匹配：不确定具体关键词，需要语义理解，则返回false
+                    你是一个智能查询路由专家。请根据【用户需求】，只返回 true 或 false。
+                    
+                    【最高优先级规则 - 必须首先判断】
+                    如果用户需求包含以下任一关键词，**直接返回 false**，不再进行其他判断：
+                    - 明细、详情、详细信息、详细内容、具体内容
+                    - 查询...明细、...详情、...记录、...列表、...清单
+                    
+                    重要：只要出现以上关键词，说明用户需要的是明细数据查询，而非统计分析。
+                    
+                    【统计类关键词 - 仅在满足最高优先级规则后才判断】
+                    只有当用户需求不包含上述明细类关键词时，才检查是否包含以下关键词：
+                    统计、求和、汇总、排名、TopN、平均、数量、总额、最高、最低、占比、分组
+                    
+                    - 如果包含，返回 true
+                    - 否则返回 false
+                    
+                    【判断示例】
+                    - \"查询中科精工集团的彩盒类产品的报价单明细\" → false（包含\"明细\"）
+                    - \"统计各产品销售额\" → true（包含\"统计\"，且无明细关键词）
+                    - \"查询客户张三信息\" → false（无统计关键词，无明细关键词）
+                    - \"销售额排名前10的产品\" → true（包含\"排名\"，且无明细关键词）
+                    - \"查看销售订单明细\" → false（包含\"明细\"）
             """)
     @UserMessage("""
-           【用户需求】
+            【用户需求】
             {{userInput}}
             """)
     Boolean routeQuery(@MemoryId String userId, @V("userInput") String userInput);
     /**
-     * 生成 Milvus 过滤条件
+     * 生成 Milvus 过滤条件（适配 Milvus v2.3.9）
      */
     @SystemMessage("""
-        MILVUS 标量过滤条件生成规则（严格遵守）：
-        1. 语法规范：
-           - 允许的操作符：==, !=, like
-           - 逻辑组合：&& (AND), || (OR)
-           - 所有字段都是字符串类型，值必须使用单引号包裹
-           - 字符串中的单引号需要转义：'O''Reilly'
-        2. 可用字段（只能使用这些字段）：
-           - {{sMilvusFiled}}
-           字段说明：
-           - {{sMilvusFiledDescription}}
-        3. 重要规则：
-           - 只使用上述可用字段，不要创建新字段
-           - 如果用户提到了文档类型（如"报价单"、"订单"等），但可用字段中没有类型字段，则忽略该条件
-           - 只提取有明确值的字段条件
-        4. 生成规则：
-           - 如果没有提取到任何具体条件，返回空字符串
-           - 从用户输入中提取明确的字段条件
-           - 识别模式：字段名 + 操作符 + 值
-           - 示例：
-             * "单据号 INV001" → sBillNo == 'INV001'
-             * "客户编号 C001" → sCustomerNo == 'C001'
-             * "销售人员张三" → sSalesManName == '张三'
-             * "产品包含手机" → sProductStyle like '%手机%'
-        5. 输出格式：
-           - 仅返回纯过滤条件，无任何解释、换行、备注
-           - 单条件：sBillNo == 'INV001'
-           - 多条件：(sBillNo == 'INV001' && sCustomerNo == 'C001')
-           - 无条件：直接返回空字符串
-    """)
-    @UserMessage("""
+            MILVUS 标量过滤条件生成规则（严格遵守 - 当前版本 v2.3.9）：
+            
+            【重要输出约束】
+            - 必须返回有效的 Milvus 过滤条件表达式
+            - 禁止返回 true 或 false
+            - 禁止返回空字符串以外的任何非表达式内容
+            - 无条件时只返回空字符串 ""
+            
+            1. 语法规范：
+               - 允许的操作符：==, !=, like
+               - 逻辑组合：&& (AND), || (OR)
+               - 所有字段都是字符串类型，值必须使用单引号包裹
+               - 字符串中的单引号需要转义：'O''Reilly'
+            
+            2. 【重要】Milvus v2.3.9 like 操作符限制：
+               - ✅ 支持：like '关键字%'（前缀匹配，以关键字开头）
+               - ❌ 不支持：like '%关键字%'（包含匹配）
+               - ❌ 不支持：like '%关键字'（后缀匹配）
+            
+            3. 可用字段（只能使用这些字段）：
+               - {{sMilvusFiled}}
+               字段说明：
+               - {{sMilvusFiledDescription}}
+            
+            4. 提取规则：
+               - 只使用上述可用字段，不要创建新字段
+               - 如果用户提到了文档类型（如"报价单"、"订单"等），但可用字段中没有类型字段，则忽略该条件
+               
+               【精确匹配规则】：
+               - 当用户提供明确值时：字段 == '值'
+                 * 例如："客户名称中科精工" → sCustomerName == '中科精工'
+                 * 例如："单据号 INV001" → sBillNo == 'INV001'
+            
+            5. 时间处理规则：
+               - 当前系统时间：{{sDataNow}}（格式：yyyy-MM-dd）
+               - 相对时间转换规则：
+                 * "今天/今日" → 当天 00:00:00 到 23:59:59
+                 * "昨天" → 前一天 00:00:00 到 23:59:59
+                 * "本周" → 本周一 00:00:00 到本周日 23:59:59
+                 * "本月" → 本月1日 00:00:00 到本月最后一天 23:59:59
+                 * "本年" → 本年1月1日 00:00:00 到本年12月31日 23:59:59
+                 * "近X天" → 从 X 天前 00:00:00 到今天 23:59:59
+               - 日期转时间戳：所有日期转换为 Unix 时间戳（秒）
+               - 时间范围格式：字段 >= 起始时间戳 && 字段 <= 结束时间戳
+               - 如果没有明确的时间需求，不要添加任何时间过滤条件
+            
+            6. 示例：
+               ✅ 正确输出：
+               - "客户名称中科精工" → sCustomerName == '中科精工'
+               - "中科精工的报价单明细" → sCustomerName == '中科精工'
+               - "产品以彩盒开头" → sProductStyle like '彩盒%'
+               - "无条件" → ""
+               
+               ❌ 错误输出（禁止）：
+               - "中科精工的报价单明细" → true
+               - "中科精工的报价单明细" → false
+               - "中科精工的报价单明细" → 1
+            
+            7. 输出格式：
+               - 仅返回纯过滤条件，无任何解释、换行、备注
+               - 单条件：sCustomerName == '中科精工'
+               - 多条件：(sCustomerName == '中科精工' && sProductStyle like '彩盒%')
+               - 无条件：直接返回空字符串 ""
+        """)
+        @UserMessage("""
         【用户查询】
             - {{userInput}}
+        【当前时间】
+            - {{sDataNow}}
         【可用字段】
             - {{sMilvusFiled}}
         【字段说明】
@@ -178,5 +202,7 @@ public interface ErpAiAgent {
     String getMilvusFilter(@MemoryId String userId,
                            @V("userInput") String userInput,
                            @V("sMilvusFiled") String sMilvusFiled,
-                           @V("sMilvusFiledDescription") String sMilvusFiledDescription);
+                           @V("sMilvusFiledDescription") String sMilvusFiledDescription,
+                           @V("sDataNow") String sDataNow);
+
 }
@@ -139,6 +139,17 @@ public class AiResponseDTO implements Serializable {
      */
     private String errorCode;
+    /**
+     * 数据库类型 X: 向量库  S:数据库
+     */
+    private String dbType;
+
+    /**
+     * 数据库类型 H: 缓存  D: 动态
+     */
+    private String dbCach;
+
+
     // ============ 便捷方法 ============
     /**
@@ -50,5 +50,6 @@ public class ToolMeta {
     private String sVectorfiled;
     private String sVectorjson;
     private String sVectorfiledAll;
+    private String sVectorfiledShow;
 }
@@ -67,6 +67,16 @@ public class UserSceneSession {
     private  Map<String, Object> args;
     /**
+     * 数据库类型 X: 向量库  S:数据库
+     */
+    private String dbType;
+
+    /**
+     * 数据库类型 H: 缓存  D: 动态
+     */
+    private String dbCach;
+
+    /**
      * 构建场景选择提示语：展示权限内场景，引导用户选择
      * @return 自然语言提示语
      */
@@ -12,7 +12,7 @@ public interface AiGlobalAgentQuestionSqlEmitterService {
      * @return void
      * @Description 插入向量库
      **/
-    void addAiGlobalAgentQuestionSqlEmitter(String sKey,Map<String,Object> data, String sQuestion, String sSqlContent, String collectionName);
+    void addAiGlobalAgentQuestionSqlEmitter(String sKey,Map<String,Object>  data,String sQuestion,String sSqlContent,String cachType,String collectionName);
     Map<String, Object> queryAiGlobalAgentQuestionSqlEmitter(String searchText, String collectionName);
@@ -54,5 +54,7 @@ public interface MilvusService {
      * @return java.util.Map<java.lang.String,java.lang.Object>
      * @Description 获取配置
      **/
-    Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll);
+    Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow);
+
+    boolean isValidMilvusFilter(String milvusFilter);
 }
 \ No newline at end of file
@@ -2,6 +2,7 @@ package com.xly.milvus.service.impl;
 import cn.hutool.core.collection.ConcurrentHashSet;
 import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.xly.milvus.service.AiGlobalAgentQuestionSqlEmitterService;
@@ -52,16 +53,19 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
      * @Description 插入数据
      **/
     @Override
-    public void addAiGlobalAgentQuestionSqlEmitter(String sKey,Map<String,Object>  data,String sQuestion,String sSqlContent,String collectionName) {
+    public void addAiGlobalAgentQuestionSqlEmitter(String sKey,Map<String,Object>  data,String sQuestion,String sSqlContent,String cachType,String collectionName) {
         // 向量化
         List<Float> vector = vectorizationService.textToVector(sKey);
         if (vector == null || vector.isEmpty()) {
             throw new RuntimeException("向量化失败");
         }
+        if(ObjectUtil.isEmpty(sSqlContent)){
+            sSqlContent = StrUtil.EMPTY;
+        }
         // 2. 转换为Milvus格式
-        JsonObject row = convertToMilvusRow(data, vector,sQuestion,sSqlContent,sKey);
+        JsonObject row = convertToMilvusRow(data, vector,sQuestion,sSqlContent,cachType,sKey);
         //创建集合
 //        createCollection(collectionName);
@@ -86,7 +90,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
         Map<String, Object> searchParams = new HashMap<>();
         searchParams.put("nprobe", 10);
         // 对于 IP 度量，相似度范围在 [minScore, maxScore]
-        searchParams.put("radius", 0.9);      // 最小相似度
+        searchParams.put("radius", 0.98);      // 最小相似度
         searchParams.put("range_filter", 1); // 最大相似度
         // 1. 确保集合已加载
         ensureCollectionLoaded(collectionName);
@@ -108,7 +112,6 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
 //                .limit(100)
 //                .build();
 //        QueryResp queryResp = milvusClient.query(queryReq);
-
         // 3. 创建 Milvus FloatVec 对象
         FloatVec floatVec = new FloatVec(floatArray);
         // 4. 构建搜索请求
@@ -118,7 +121,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
                 .annsField("vector")  // 向量字段名
                 .topK(10)  // 返回最相似的10条
                 .metricType(IndexParam.MetricType.IP)  // 内积相似度
-                .outputFields(Arrays.asList("sQuestion", "sSqlContent", "data_id", "create_time","metadata"))
+                .outputFields(Arrays.asList("sQuestion", "sSqlContent", "data_id","db_name", "create_time","metadata"))
                 .searchParams(searchParams)
                 .build();
         // 5. 执行搜索
@@ -230,7 +233,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
     /**
      * 从实体对象构建Milvus插入数据
      */
-    public JsonObject convertToMilvusRow(Map<String,Object> data, List<Float> vector,String sQuestion,String sSqlContent,String sKey) {
+    public JsonObject convertToMilvusRow(Map<String,Object> data, List<Float> vector,String sQuestion,String sSqlContent,String cachType,String sKey) {
         JsonObject row = new JsonObject();
         // 添加向量
@@ -242,6 +245,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
         row.addProperty("data_id", data.get("sId").toString());
         row.addProperty("sQuestion", sQuestion);
         row.addProperty("sSqlContent", sSqlContent);
+        row.addProperty("cachType", cachType);
         // 创建时间字段 - 必须提供！
         row.addProperty("create_time", System.currentTimeMillis());
         // 创建时间字段 - 必须提供！
@@ -305,23 +309,33 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
                 CreateCollectionReq.FieldSchema.builder()
                         .name("sQuestion")
                         .dataType(DataType.VarChar)
-                        .maxLength(1000)
+                        .maxLength(5000)
                         .description("用户问题")
                         .build(),
-                // 4. SQL内容字段
+                // 4. SQL内容字段 - 设置为可空
                 CreateCollectionReq.FieldSchema.builder()
                         .name("sSqlContent")
                         .dataType(DataType.VarChar)
-                        .maxLength(5000)  // SQL可能较长
+                        .maxLength(50000)  // SQL可能较长
+                        .isPrimaryKey(false)
+                        .isNullable(true)   //  设置为 true，允许为空
                         .description("SQL语句")
                         .build(),
+                // 4. 缓存类型
+                CreateCollectionReq.FieldSchema.builder()
+                        .name("cachType")
+                        .dataType(DataType.VarChar)
+                        .maxLength(100)  // 缓存类型
+                        .description("缓存类型")
+                        .build(),
+
                 // 5. 数据ID字段
                 CreateCollectionReq.FieldSchema.builder()
                         .name("data_id")
                         .dataType(DataType.VarChar)
-                        .maxLength(100)
+                        .maxLength(500)  // 增加最大长度
                         .description("原始数据ID")
                         .build(),
@@ -341,7 +355,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
                 CreateCollectionReq.FieldSchema.builder()
                         .name("sKey")
                         .dataType(DataType.VarChar)
-                        .maxLength(100)
+                        .maxLength(1000)  // 增加最大长度
                         .description("存入的vector转换前数据")
                         .build()
         );
@@ -667,7 +681,7 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
         IndexParam questionIndex = IndexParam.builder()
                 .fieldName("sQuestion")
                 .indexName("idx_question")
-                .indexType(IndexParam.IndexType.INVERTED)  // 倒排索引
+                .indexType(IndexParam.IndexType.TRIE)  // 倒排索引
                 .build();
         allIndexParams.add(questionIndex);
@@ -675,14 +689,21 @@ public class AiGlobalAgentQuestionSqlEmitterServiceImpl implements AiGlobalAgent
         IndexParam idIndex = IndexParam.builder()
                 .fieldName("data_id")
                 .indexName("idx_data_id")
-                .indexType(IndexParam.IndexType.INVERTED)
+                .indexType(IndexParam.IndexType.TRIE)
                 .build();
         allIndexParams.add(idIndex);
+        IndexParam idx_cach_type = IndexParam.builder()
+                .fieldName("cachType")
+                .indexName("idx_cach_type")
+                .indexType(IndexParam.IndexType.TRIE)
+                .build();
+        allIndexParams.add(idx_cach_type);
+
         IndexParam sKey = IndexParam.builder()
                 .fieldName("sKey")
                 .indexName("s_key")
-                .indexType(IndexParam.IndexType.INVERTED)
+                .indexType(IndexParam.IndexType.TRIE)
                 .build();
         allIndexParams.add(sKey);
@@ -264,24 +264,29 @@ public class MilvusServiceImpl implements MilvusService {
      * @Description 返回组装动态内容
      **/
     @Override
-    public Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll){
+    public Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow){
         List<String> sFileds = new ArrayList<>();
+        List<String> filedsShow = new ArrayList<>();
         List<String> sFiledDescriptions = new ArrayList<>();
         List<String> sFiledDescriptionsAll = new ArrayList<>();
         List<Map<String,String>> titleList = new LinkedList<>();
         String[] sVectorfiledArray = sVectorfiled.split(",");
         for(String sVectorfiledOne : sVectorfiledArray){
-            Map<String,String>  title = new HashMap<>();
-
             String[] sVectorfiledOneArray = sVectorfiledOne.split(":");
             String sDescriptions = sVectorfiledOneArray[0];
             String sName = sVectorfiledOneArray[1];
             sFileds.add(sName);
             // 处理描述中可能包含的换行，保持缩进一致
-//            String formattedDesc = sDescriptions.replace("\n", "\n    ");
-//            sFiledDescriptions.add(String.format("  - %s: %s", sName, formattedDesc));
             String formattedDesc =String.format("%s: %s", sName, sDescriptions);
             sFiledDescriptions.add(formattedDesc);
+        }
+        String[] sVectorfiledShowArray = sVectorfiledShow.split(",");
+        for(String sVectorfiledShowOne : sVectorfiledShowArray){
+            Map<String,String>  title = new HashMap<>(4);
+            String[] sVectorfiledOneArray = sVectorfiledShowOne.split(":");
+            String sDescriptions = sVectorfiledOneArray[0];
+            String sName = sVectorfiledOneArray[1];
+            filedsShow.add(sName);
             title.put("sName",sName);
             title.put("sTitle",sDescriptions);
             titleList.add(title);
@@ -291,9 +296,6 @@ public class MilvusServiceImpl implements MilvusService {
             String[] sVectorfiledOneArray = sVectorfiledOne.split(":");
             String sDescriptions = sVectorfiledOneArray[0];
             String sName = sVectorfiledOneArray[1];
-            // 处理描述中可能包含的换行，保持缩进一致
-//            String formattedDesc = sDescriptions.replace("\n", "\n    ");
-//            sFiledDescriptions.add(String.format("  - %s: %s", sName, formattedDesc));
             String formattedDesc =String.format("%s: %s", sName, sDescriptions);
             sFiledDescriptionsAll.add(formattedDesc);
         }
@@ -301,7 +303,7 @@ public class MilvusServiceImpl implements MilvusService {
         rMap.put("sMilvusFiled", String.join(",", sFileds));
         rMap.put("sMilvusFiledDescription", String.join(",", sFiledDescriptions));
         rMap.put("sMilvusFiledDescriptionAll", String.join(",", sFiledDescriptionsAll));
-        rMap.put("sFileds", sFileds);
+        rMap.put("filedsShow", filedsShow);
         rMap.put("title", titleList);
         return rMap;
     }
@@ -334,9 +336,6 @@ public class MilvusServiceImpl implements MilvusService {
         fields.add("metadata");
         // 3. 创建 Milvus FloatVec 对象
         FloatVec floatVec = new FloatVec(floatArray);
-        log.info("查询向量库条件{}",milvusFilter);
-        milvusFilter = isValidMilvusFilter(milvusFilter)?milvusFilter : null;
-        log.info("实际查询向量库条件{}",milvusFilter);
         // 4. 构建搜索请求
         SearchReq searchReq = SearchReq.builder()
                 .collectionName(collectionName)
@@ -357,7 +356,7 @@ public class MilvusServiceImpl implements MilvusService {
     /**
-     * 判断 Milvus 过滤条件是否有效
+     * 判断 Milvus 过滤条件是否有效（支持 TEXT_MATCH 全文检索）
      * @param milvusFilter 过滤条件字符串
      * @return true: 有效条件, false: 无效条件
      */
@@ -374,42 +373,135 @@ public class MilvusServiceImpl implements MilvusService {
             return false;
         }
-        // 3. 检查是否包含有效的操作符
-        boolean hasValidOperator = filter.matches(".*[=!<>]=?.*") || filter.contains(" like ");
+        // 3. 【修改】检查是否包含有效的操作符（增加 TEXT_MATCH 支持）
+        boolean hasValidOperator = filter.matches(".*[=!<>]=?.*")
+                || filter.contains(" like ")
+                || filter.toUpperCase().contains("TEXT_MATCH");
+
         if (!hasValidOperator) {
             return false;
         }
-        // 4. 检查字符串值是否使用单引号包裹
-        // 匹配模式：字段名 操作符 '值'
-        Pattern pattern = Pattern.compile("[a-zA-Z_][a-zA-Z0-9_]*\\s*(==|!=|>=|<=|>|<|like)\\s*('[^']*'|\\d+)");
-        Matcher matcher = pattern.matcher(filter);
-
-        // 5. 对于复合条件，递归检查
+        // 4. 对于复合条件，递归检查
         if (filter.contains("&&") || filter.contains("||")) {
             // 分割复合条件（简单处理，生产环境需要更完善的解析）
-            String[] conditions = filter.split("&&|\\|\\|");
+            String[] conditions = splitConditions(filter);
             for (String condition : conditions) {
-                condition = condition.trim().replaceAll("^[()]+|[()]+$", ""); // 去除括号
-                if (!isValidSimpleCondition(condition)) {
+                if (!isValidCondition(condition)) {
                     return false;
                 }
             }
             return true;
         }
-        // 6. 检查简单条件
-        return isValidSimpleCondition(filter);
+        // 5. 检查单个条件
+        return isValidCondition(filter);
+    }
+
+    /**
+     * 拆分复合条件（处理括号嵌套）
+     */
+    private String[] splitConditions(String filter) {
+        List<String> conditions = new ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        int parentheses = 0;
+
+        for (int i = 0; i < filter.length(); i++) {
+            char c = filter.charAt(i);
+
+            if (c == '(') {
+                parentheses++;
+                current.append(c);
+            } else if (c == ')') {
+                parentheses--;
+                current.append(c);
+            } else if (parentheses == 0 && (filter.startsWith("&&", i) || filter.startsWith("||", i))) {
+                // 遇到顶层操作符，分割条件
+                if (current.length() > 0) {
+                    conditions.add(current.toString().trim());
+                    current = new StringBuilder();
+                }
+                i += 1; // 跳过操作符的第二个字符
+            } else {
+                current.append(c);
+            }
+        }
+
+        if (current.length() > 0) {
+            conditions.add(current.toString().trim());
+        }
+
+        return conditions.toArray(new String[0]);
     }
     /**
-     * 验证简单条件（不包含 && 和 ||）
+     * 验证单个条件（支持 TEXT_MATCH 和普通条件）
+     */
+    private boolean isValidCondition(String condition) {
+        if (condition == null || condition.trim().isEmpty()) {
+            return false;
+        }
+
+        condition = condition.trim();
+        // 去除外层括号
+        while (condition.startsWith("(") && condition.endsWith(")")) {
+            condition = condition.substring(1, condition.length() - 1).trim();
+        }
+
+        // 1. 【新增】检查 TEXT_MATCH 语法
+        if (condition.toUpperCase().contains("TEXT_MATCH")) {
+            return isValidTextMatch(condition);
+        }
+
+        // 2. 检查普通条件
+        return isValidSimpleCondition(condition);
+    }
+
+    /**
+     * 【新增】验证 TEXT_MATCH 语法
+     * 格式：TEXT_MATCH(字段名, '关键词')
+     * 或：TEXT_MATCH(字段名, "关键词")
+     */
+    private boolean isValidTextMatch(String condition) {
+        // 匹配 TEXT_MATCH(字段名, '关键词') 或 TEXT_MATCH(字段名, "关键词")
+        Pattern pattern = Pattern.compile(
+                "TEXT_MATCH\\s*\\(\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*,\\s*['\"]([^'\"]*)['\"]\\s*\\)",
+                Pattern.CASE_INSENSITIVE
+        );
+        Matcher matcher = pattern.matcher(condition);
+
+        if (!matcher.matches()) {
+            log.warn("无效的 TEXT_MATCH 语法: {}", condition);
+            return false;
+        }
+
+        String fieldName = matcher.group(1);
+        String keyword = matcher.group(2);
+
+        // 检查字段名不能为空
+        if (fieldName == null || fieldName.trim().isEmpty()) {
+            log.warn("TEXT_MATCH 字段名不能为空: {}", condition);
+            return false;
+        }
+
+        // 检查关键词不能为空
+        if (keyword == null || keyword.trim().isEmpty()) {
+            log.warn("TEXT_MATCH 关键词不能为空: {}", condition);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 验证简单条件（不包含 && 和 ||，不包含 TEXT_MATCH）
      */
     private boolean isValidSimpleCondition(String condition) {
         if (condition == null || condition.trim().isEmpty()) {
             return false;
         }
         condition = condition.trim();
+
         // 匹配简单条件的正则
         // 格式：字段名 操作符 值
         // 字段名：字母开头，包含字母数字下划线
@@ -422,22 +514,27 @@ public class MilvusServiceImpl implements MilvusService {
         if (!condition.matches(regex)) {
             return false;
         }
-        // 额外检查：like 操作符的值必须包含 %
+
+        // 【修改】额外检查：like 操作符的限制
         if (condition.contains(" like ")) {
             String value = condition.split("like")[1].trim();
             if (!value.contains("%")) {
-                return false;  // like 必须使用 % 通配符
+                log.warn("like 操作符必须包含 % 通配符: {}", condition);
+                return false;
+            }
+
+            // 【新增】检查是否包含前后都有通配符的模式（Milvus 不支持）
+            if (value.matches("'%.*%'")) {
+                log.warn("Milvus 不支持前后都有通配符的 like: {}", condition);
+                return false;
             }
         }
+
         return true;
     }
-
-    /**
-    * 处理 Milvus 查询结果（完整版）
-    */
     /**
-     * 处理 Milvus 查询结果（完整版）
+     * 处理 Milvus 查询结果
      */
     private List<Map<String, Object>> processMilvusResults(SearchResp response) {
         List<Map<String, Object>> results = new ArrayList<>();
@@ -758,6 +855,7 @@ public class MilvusServiceImpl implements MilvusService {
                    .description(sDescription)
                    .isPrimaryKey(false)  // 如果不是主键
                    .isNullable(true)           // 允许为空
+
 //                    .defaultValue("")  // 如果有默认值
                    // SQL可能较长
                    .maxLength(1000)
+package com.xly.ocr.service;
+
+import net.sourceforge.tess4j.Tesseract;
+import net.sourceforge.tess4j.TesseractException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+@Service
+public class OcrService {
+
+    private static final Logger logger = LoggerFactory.getLogger(OcrService.class);
+
+    private final Tesseract tesseract;
+
+    // 配置参数
+    private static final List<String> ALLOWED_EXTENSIONS = Arrays.asList(".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".gif");
+    private static final long MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+    private static final int BINARIZE_THRESHOLD = 127;
+    private static final int MIN_WIDTH = 800;
+    private static final int MIN_HEIGHT = 200;
+
+    // 性能统计
+    private static class OcrStats {
+        long preprocessTime = 0;
+        long ocrTime = 0;
+        String imageSize = "";
+
+        @Override
+        public String toString() {
+            return String.format("预处理耗时: %dms, OCR耗时: %dms, 图片尺寸: %s",
+                    preprocessTime, ocrTime, imageSize);
+        }
+    }
+
+    public OcrService(@Value("${tesseract.datapath}") String dataPath) {
+        this.tesseract = new Tesseract();
+
+        // 基础配置
+        this.tesseract.setDatapath(dataPath);
+        this.tesseract.setLanguage("chi_sim+eng");
+
+        // 优化识别参数
+        configureTesseract();
+
+        logger.info("Tesseract 初始化完成，语言包路径: {}, 语言: chi_sim+eng", dataPath);
+    }
+
+    /**
+     * 配置 Tesseract 参数
+     */
+    private void configureTesseract() {
+        // 页面分割模式：3 = 自动页面分割，但没有方向检测
+        this.tesseract.setPageSegMode(3);
+
+        // OCR 引擎模式：3 = 默认，基于 LSTM 和传统引擎
+        this.tesseract.setOcrEngineMode(3);
+
+        // 提高中文识别率
+        this.tesseract.setVariable("preserve_interword_spaces", "1");
+        this.tesseract.setVariable("textord_force_make_prop_words", "true");
+
+        // 可选：设置字符白名单（根据需要启用）
+        // this.tesseract.setVariable("tessedit_char_whitelist",
+        //     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ，。！？；：\"‘’“”【】（）《》");
+
+        // 可选：设置黑名单（排除干扰字符）
+        // this.tesseract.setVariable("tessedit_char_blacklist", "|\\/`~@#$%^&*()_+={}[]");
+    }
+
+    /**
+     * 图片预处理 - 优化的处理流程
+     */
+    private BufferedImage preprocessImage(BufferedImage originalImage) {
+        if (originalImage == null) {
+            return null;
+        }
+
+        try {
+            long startTime = System.currentTimeMillis();
+
+            // 1. 自动调整亮度和对比度
+            BufferedImage adjusted = autoAdjustBrightnessContrast(originalImage);
+
+            // 2. 灰度化
+            BufferedImage grayImage = toGray(adjusted);
+
+            // 3. 自适应二值化（比固定阈值更好）
+            BufferedImage binaryImage = adaptiveBinarize(grayImage);
+
+            // 4. 降噪处理
+            BufferedImage denoisedImage = denoise(binaryImage);
+
+            // 5. 放大图片（如果太小）
+            BufferedImage scaledImage = scaleImageIfNeeded(denoisedImage);
+
+            // 6. 可选：边缘增强（提高清晰度）
+            BufferedImage enhancedImage = sharpen(scaledImage);
+
+            long endTime = System.currentTimeMillis();
+            logger.debug("图片预处理耗时: {}ms", endTime - startTime);
+
+            return enhancedImage;
+
+        } catch (Exception e) {
+            logger.error("图片预处理失败: {}", e.getMessage(), e);
+            return originalImage;
+        }
+    }
+
+    /**
+     * 自动调整亮度和对比度
+     */
+    private BufferedImage autoAdjustBrightnessContrast(BufferedImage image) {
+        BufferedImage result = new BufferedImage(
+                image.getWidth(), image.getHeight(), image.getType());
+
+        // 计算亮度直方图
+        int[] histogram = new int[256];
+        for (int y = 0; y < image.getHeight(); y++) {
+            for (int x = 0; x < image.getWidth(); x++) {
+                int rgb = image.getRGB(x, y);
+                int gray = (int)((rgb >> 16 & 0xFF) * 0.299 +
+                        (rgb >> 8 & 0xFF) * 0.587 +
+                        (rgb & 0xFF) * 0.114);
+                histogram[gray]++;
+            }
+        }
+
+        // 找到黑色和白色的阈值
+        int total = image.getWidth() * image.getHeight();
+        int blackThreshold = 0;
+        int whiteThreshold = 255;
+
+        int sum = 0;
+        for (int i = 0; i < 256; i++) {
+            sum += histogram[i];
+            if (sum > total * 0.05) {
+                blackThreshold = i;
+                break;
+            }
+        }
+
+        sum = 0;
+        for (int i = 255; i >= 0; i--) {
+            sum += histogram[i];
+            if (sum > total * 0.05) {
+                whiteThreshold = i;
+                break;
+            }
+        }
+
+        // 应用对比度拉伸
+        for (int y = 0; y < image.getHeight(); y++) {
+            for (int x = 0; x < image.getWidth(); x++) {
+                int rgb = image.getRGB(x, y);
+                int r = (rgb >> 16) & 0xFF;
+                int g = (rgb >> 8) & 0xFF;
+                int b = rgb & 0xFF;
+
+                // 拉伸到 0-255 范围
+                r = stretchValue(r, blackThreshold, whiteThreshold);
+                g = stretchValue(g, blackThreshold, whiteThreshold);
+                b = stretchValue(b, blackThreshold, whiteThreshold);
+
+                result.setRGB(x, y, (r << 16) | (g << 8) | b);
+            }
+        }
+
+        return result;
+    }
+
+    private int stretchValue(int value, int black, int white) {
+        if (value <= black) return 0;
+        if (value >= white) return 255;
+        return (value - black) * 255 / (white - black);
+    }
+
+    /**
+     * 灰度化
+     */
+    private BufferedImage toGray(BufferedImage image) {
+        BufferedImage result = new BufferedImage(
+                image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
+        Graphics g = result.getGraphics();
+        g.drawImage(image, 0, 0, null);
+        g.dispose();
+        return result;
+    }
+
+    /**
+     * 自适应二值化 - 根据局部区域动态调整阈值
+     */
+    private BufferedImage adaptiveBinarize(BufferedImage image) {
+        BufferedImage result = new BufferedImage(
+                image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_BINARY);
+
+        int blockSize = 15;
+        int constant = 5;
+
+        for (int y = 0; y < image.getHeight(); y++) {
+            for (int x = 0; x < image.getWidth(); x++) {
+                // 计算局部区域的平均值
+                int sum = 0;
+                int count = 0;
+                for (int ky = -blockSize/2; ky <= blockSize/2; ky++) {
+                    for (int kx = -blockSize/2; kx <= blockSize/2; kx++) {
+                        int px = Math.min(Math.max(x + kx, 0), image.getWidth() - 1);
+                        int py = Math.min(Math.max(y + ky, 0), image.getHeight() - 1);
+                        sum += new Color(image.getRGB(px, py)).getRed();
+                        count++;
+                    }
+                }
+                int threshold = sum / count - constant;
+
+                // 应用阈值
+                int gray = new Color(image.getRGB(x, y)).getRed();
+                int binary = gray > threshold ? 255 : 0;
+                result.setRGB(x, y, new Color(binary, binary, binary).getRGB());
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 降噪 - 优化的中值滤波
+     */
+    private BufferedImage denoise(BufferedImage image) {
+        BufferedImage result = new BufferedImage(
+                image.getWidth(), image.getHeight(), image.getType());
+
+        for (int y = 1; y < image.getHeight() - 1; y++) {
+            for (int x = 1; x < image.getWidth() - 1; x++) {
+                int[] neighbors = new int[9];
+                int index = 0;
+                for (int ky = -1; ky <= 1; ky++) {
+                    for (int kx = -1; kx <= 1; kx++) {
+                        neighbors[index++] = new Color(image.getRGB(x + kx, y + ky)).getRed();
+                    }
+                }
+                Arrays.sort(neighbors);
+                int median = neighbors[4];
+                result.setRGB(x, y, new Color(median, median, median).getRGB());
+            }
+        }
+
+        // 处理边缘
+        for (int x = 0; x < image.getWidth(); x++) {
+            result.setRGB(x, 0, image.getRGB(x, 0));
+            result.setRGB(x, image.getHeight() - 1, image.getRGB(x, image.getHeight() - 1));
+        }
+        for (int y = 0; y < image.getHeight(); y++) {
+            result.setRGB(0, y, image.getRGB(0, y));
+            result.setRGB(image.getWidth() - 1, y, image.getRGB(image.getWidth() - 1, y));
+        }
+
+        return result;
+    }
+
+    /**
+     * 锐化处理 - 增强文字边缘
+     */
+    private BufferedImage sharpen(BufferedImage image) {
+        BufferedImage result = new BufferedImage(
+                image.getWidth(), image.getHeight(), image.getType());
+
+        // 拉普拉斯锐化核
+        float[] sharpenKernel = {
+                0, -1, 0,
+                -1, 5, -1,
+                0, -1, 0
+        };
+
+        for (int y = 1; y < image.getHeight() - 1; y++) {
+            for (int x = 1; x < image.getWidth() - 1; x++) {
+                int sum = 0;
+                int index = 0;
+                for (int ky = -1; ky <= 1; ky++) {
+                    for (int kx = -1; kx <= 1; kx++) {
+                        int gray = new Color(image.getRGB(x + kx, y + ky)).getRed();
+                        sum += gray * sharpenKernel[index++];
+                    }
+                }
+                sum = Math.min(255, Math.max(0, sum));
+                result.setRGB(x, y, new Color(sum, sum, sum).getRGB());
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 放大图片（如果图片太小）
+     */
+    private BufferedImage scaleImageIfNeeded(BufferedImage image) {
+        int width = image.getWidth();
+        int height = image.getHeight();
+
+        if (width >= MIN_WIDTH && height >= MIN_HEIGHT) {
+            return image;
+        }
+
+        double scaleX = (double) MIN_WIDTH / width;
+        double scaleY = (double) MIN_HEIGHT / height;
+        double scale = Math.max(scaleX, scaleY);
+
+        int newWidth = (int) (width * scale);
+        int newHeight = (int) (height * scale);
+
+        // 使用更好的插值算法
+        BufferedImage result = new BufferedImage(newWidth, newHeight, image.getType());
+        Graphics2D g2d = result.createGraphics();
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+        g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
+                RenderingHints.VALUE_RENDER_QUALITY);
+        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                RenderingHints.VALUE_ANTIALIAS_ON);
+        g2d.drawImage(image, 0, 0, newWidth, newHeight, null);
+        g2d.dispose();
+
+        logger.debug("图片已放大: {}x{} -> {}x{}", width, height, newWidth, newHeight);
+        return result;
+    }
+
+    /**
+     * 识别图片中的文字（增强版）
+     */
+    public String extractText(File imageFile) {
+        if (imageFile == null || !imageFile.exists()) {
+            logger.error("图片文件不存在或为空");
+            return "图片文件不存在";
+        }
+
+        OcrStats stats = new OcrStats();
+
+        try {
+            logger.info("开始识别图片: {}, 大小: {} bytes",
+                    imageFile.getAbsolutePath(), imageFile.length());
+
+            // 读取原始图片
+            long readStart = System.currentTimeMillis();
+            BufferedImage originalImage = ImageIO.read(imageFile);
+            if (originalImage == null) {
+                return "无法读取图片文件，请确保图片格式正确";
+            }
+            stats.imageSize = originalImage.getWidth() + "x" + originalImage.getHeight();
+
+            // 图片预处理
+            long preprocessStart = System.currentTimeMillis();
+            BufferedImage processedImage = preprocessImage(originalImage);
+            stats.preprocessTime = System.currentTimeMillis() - preprocessStart;
+
+            // 可选：保存预处理图片用于调试（生产环境可注释）
+            if (logger.isDebugEnabled()) {
+                saveDebugImage(processedImage, imageFile);
+            }
+
+            // 执行 OCR
+            long ocrStart = System.currentTimeMillis();
+            String result = tesseract.doOCR(processedImage);
+            stats.ocrTime = System.currentTimeMillis() - ocrStart;
+
+            logger.info("识别完成 - {}", stats);
+
+            // 清理识别结果
+            result = cleanResult(result);
+
+            if (result.isEmpty()) {
+                logger.warn("识别结果为空，可能需要调整预处理参数");
+            }
+
+            return result;
+
+        } catch (TesseractException e) {
+            logger.error("OCR识别失败: {}", e.getMessage(), e);
+            return "OCR识别失败: " + e.getMessage();
+        } catch (IOException e) {
+            logger.error("读取图片失败: {}", e.getMessage(), e);
+            return "读取图片失败: " + e.getMessage();
+        }
+    }
+
+    /**
+     * 保存调试图片（仅用于调试）
+     */
+    private void saveDebugImage(BufferedImage image, File originalFile) {
+        try {
+            String debugPath = originalFile.getParent() + "/debug_" + originalFile.getName();
+            File debugFile = new File(debugPath);
+            ImageIO.write(image, "png", debugFile);
+            logger.debug("预处理图片已保存: {}", debugPath);
+        } catch (IOException e) {
+            logger.debug("保存调试图片失败: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * 清理识别结果
+     */
+    private String cleanResult(String result) {
+        if (result == null || result.isEmpty()) {
+            return "";
+        }
+
+        // 去除首尾空白
+        result = result.trim();
+
+        // 规范化换行符
+        result = result.replaceAll("\\r\\n", "\n")
+                .replaceAll("\\r", "\n");
+
+        // 合并多个空行
+        result = result.replaceAll("\n{3,}", "\n\n");
+
+        // 去除行首行尾空格
+        String[] lines = result.split("\n");
+        StringBuilder cleaned = new StringBuilder();
+        for (String line : lines) {
+            cleaned.append(line.trim()).append("\n");
+        }
+
+        return cleaned.toString().trim();
+    }
+
+    /**
+     * 封装方法，接收上传的 MultipartFile
+     */
+    public String extractTextFromMultipartFile(MultipartFile file) {
+        if (file == null || file.isEmpty()) {
+            logger.warn("上传的文件为空");
+            return "上传的文件为空";
+        }
+
+        // 验证文件大小
+        if (file.getSize() > MAX_FILE_SIZE) {
+            logger.warn("文件过大: {} bytes, 超过限制: {} bytes",
+                    file.getSize(), MAX_FILE_SIZE);
+            return String.format("文件过大，最大支持 %dMB", MAX_FILE_SIZE / 1024 / 1024);
+        }
+
+        // 验证文件格式
+        String originalFilename = file.getOriginalFilename();
+        if (originalFilename != null && !isAllowedImage(originalFilename)) {
+            logger.warn("不支持的文件格式: {}", originalFilename);
+            return "不支持的文件格式，仅支持: " + String.join(", ", ALLOWED_EXTENSIONS);
+        }
+
+        Path tempFile = null;
+        try {
+            // 创建临时文件
+            String suffix = getFileExtension(originalFilename);
+            tempFile = Files.createTempFile("ocr_", suffix);
+            file.transferTo(tempFile.toFile());
+
+            logger.info("临时文件创建成功: {}", tempFile);
+
+            // 执行 OCR
+            String result = extractText(tempFile.toFile());
+
+            return result;
+
+        } catch (IOException e) {
+            logger.error("文件处理失败: {}", e.getMessage(), e);
+            return "文件处理失败: " + e.getMessage();
+        } finally {
+            // 清理临时文件
+            cleanupTempFile(tempFile);
+        }
+    }
+
+    /**
+     * 清理临时文件
+     */
+    private void cleanupTempFile(Path tempFile) {
+        if (tempFile != null) {
+            try {
+                Files.deleteIfExists(tempFile);
+                logger.debug("临时文件已删除: {}", tempFile);
+            } catch (IOException e) {
+                logger.warn("删除临时文件失败: {}", tempFile, e);
+                // 注册JVM退出时删除
+                tempFile.toFile().deleteOnExit();
+            }
+        }
+    }
+
+    /**
+     * 批量识别（用于多张图片）
+     */
+    public List<String> batchExtractText(List<MultipartFile> files) {
+        return files.stream()
+                .map(this::extractTextFromMultipartFile)
+                .collect(java.util.stream.Collectors.toList());
+    }
+
+    /**
+     * 检查文件扩展名是否允许
+     */
+    private boolean isAllowedImage(String filename) {
+        if (filename == null) {
+            return false;
+        }
+        String lowerFilename = filename.toLowerCase();
+        return ALLOWED_EXTENSIONS.stream()
+                .anyMatch(lowerFilename::endsWith);
+    }
+
+    /**
+     * 获取文件扩展名
+     */
+    private String getFileExtension(String filename) {
+        if (filename == null || !filename.contains(".")) {
+            return ".jpg";
+        }
+        return filename.substring(filename.lastIndexOf("."));
+    }
+}
 \ No newline at end of file
+package com.xly.ocr.test;
+
+import com.benjaminwan.ocrlibrary.OcrResult;
+import com.benjaminwan.ocrlibrary.Point;
+import com.benjaminwan.ocrlibrary.TextBlock;
+import io.github.mymonstercat.Model;
+import io.github.mymonstercat.ocr.InferenceEngine;
+import io.github.mymonstercat.ocr.config.ParamConfig;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.Kernel;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Main {
+
+    static {
+        try {
+            String customTempDir = "D:/temp/ocrJava";
+            File tempDir = new File(customTempDir);
+            if (!tempDir.exists()) {
+                tempDir.mkdirs();
+            }
+            System.setProperty("java.io.tmpdir", customTempDir);
+            System.setProperty("TMP", customTempDir);
+            System.setProperty("TEMP", customTempDir);
+            System.setProperty("ORT_TMP_DIR", customTempDir);
+
+            System.out.println("==================================");
+            System.out.println("java.io.tmpdir: " + System.getProperty("java.io.tmpdir"));
+            System.out.println("临时目录是否存在: " + tempDir.exists());
+            System.out.println("==================================");
+
+        } catch (Exception e) {
+            System.err.println("设置临时目录失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("OCR 程序开始执行...");
+
+            // 检查旧的临时目录
+            String oldTempPath = "C:\\Users\\钱豹\\AppData\\Local\\Temp\\ocrJava";
+            File oldTempDir = new File(oldTempPath);
+            if (oldTempDir.exists()) {
+                System.out.println("发现旧的临时目录: " + oldTempPath);
+            }
+
+            // 1. 初始化引擎（V4 模型）
+            System.out.println("正在初始化 OCR 引擎...");
+            InferenceEngine engine = InferenceEngine.getInstance(Model.ONNX_PPOCR_V4);
+
+            // 2. 创建优化的参数配置
+            ParamConfig config = createOptimizedParamConfig();
+
+            // 3. 设置图片路径
+            String imagePath = "E:/aa/b.jpg";
+
+            File imageFile = new File(imagePath);
+            if (!imageFile.exists()) {
+                System.err.println("图片文件不存在: " + imagePath);
+                return;
+            }
+
+            // 4. 图像预处理（可选，注释掉可提高速度）
+            System.out.println("正在进行图像预处理...");
+            String processedImagePath = preprocessImage(imagePath);
+
+            // 5. 执行识别
+            System.out.println("开始识别图片: " + processedImagePath);
+            long startTime = System.currentTimeMillis();
+            OcrResult ocrResult = engine.runOcr(processedImagePath, config);
+            long endTime = System.currentTimeMillis();
+
+            // 6. 输出识别结果
+            String text = ocrResult.getStrRes().trim();
+            System.out.println("==================================");
+            System.out.println("识别结果：");
+            System.out.println(text);
+            System.out.println("==================================");
+            System.out.println("识别耗时: " + (endTime - startTime) + " ms");
+
+            // 7. 输出文本块详细信息（可选，用于调试）
+            if (ocrResult.getTextBlocks() != null && !ocrResult.getTextBlocks().isEmpty()) {
+                System.out.println("\n文本块详情（共" + ocrResult.getTextBlocks().size() + "块）：");
+                List<TextBlock> textBlocks = ocrResult.getTextBlocks();
+                for (int i = 0; i < textBlocks.size(); i++) {
+                    TextBlock block = textBlocks.get(i);
+                    System.out.printf("  块%d: %s (置信度: %.2f)%n",
+                            i + 1,
+                            block.getText(),
+                            block.getBoxScore()
+                    );
+                }
+            }
+
+            // 8. 清理临时文件
+            if (!processedImagePath.equals(imagePath)) {
+                File processedFile = new File(processedImagePath);
+                if (processedFile.exists()) {
+                    processedFile.delete();
+                    System.out.println("\n已清理临时文件: " + processedImagePath);
+                }
+            }
+
+        } catch (Exception e) {
+            System.err.println("OCR 识别失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    private static ParamConfig createOptimizedParamConfig() {
+        ParamConfig config = new ParamConfig();
+
+        // 手写体专用超强参数
+        config.setPadding(100);
+        config.setMaxSideLen(1200);
+
+        // 极低阈值 = 不漏检任何手写文字
+        config.setBoxScoreThresh(0.25f);
+        config.setBoxThresh(0.15f);
+        config.setUnClipRatio(2.5f);
+
+        // 必须开启角度矫正
+        config.setDoAngle(true);
+        config.setMostAngle(true);
+
+        return config;
+    }
+
+    /**
+     * 图像预处理：提高OCR识别准确度
+     */
+    private static String preprocessImage(String imagePath) throws IOException {
+        File inputFile = new File(imagePath);
+        BufferedImage originalImage = ImageIO.read(inputFile);
+
+        if (originalImage == null) return imagePath;
+
+        // 固定缩放到最佳尺寸
+        BufferedImage resized = resizeImageWithQuality(originalImage, 1000, 1500);
+
+        // 手写体必须：二值化（黑白强化）+ 锐化
+        BufferedImage binary = toBinary(resized);  // 黑白强化，核心！
+        BufferedImage sharp = sharpenImage(binary); // 锐化
+
+        // 保存
+        String outputPath = imagePath.substring(0, imagePath.lastIndexOf(".")) + "_final.jpg";
+        ImageIO.write(sharp, "jpg", new File(outputPath));
+        return outputPath;
+    }
+
+    // 手写体专用：黑白二值化，文字瞬间清晰
+    private static BufferedImage toBinary(BufferedImage image) {
+        BufferedImage gray = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
+        Graphics g = gray.getGraphics();
+        g.drawImage(image, 0, 0, null);
+        g.dispose();
+
+        // 手写体阈值 120，文字最清晰
+        int threshold = 120;
+        for (int y = 0; y < gray.getHeight(); y++) {
+            for (int x = 0; x < gray.getWidth(); x++) {
+                int rgb = gray.getRGB(x, y);
+                int grayValue = (rgb >> 16) & 0xFF;
+                if (grayValue < threshold) {
+                    gray.setRGB(x, y, Color.BLACK.getRGB());
+                } else {
+                    gray.setRGB(x, y, Color.WHITE.getRGB());
+                }
+            }
+        }
+        return gray;
+    }
+
+    /**
+     * 高质量调整图片大小
+     */
+    private static BufferedImage resizeImageWithQuality(BufferedImage original, int maxWidth, int maxHeight) {
+        int width = original.getWidth();
+        int height = original.getHeight();
+
+        // 如果图片尺寸合适，不进行调整
+        if (width <= maxWidth && height <= maxHeight) {
+            return original;
+        }
+
+        // 计算缩放比例
+        double ratio = Math.min((double) maxWidth / width, (double) maxHeight / height);
+        int newWidth = (int) (width * ratio);
+        int newHeight = (int) (height * ratio);
+
+        // 创建缩放后的图片
+        BufferedImage resized = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g = resized.createGraphics();
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g.drawImage(original, 0, 0, newWidth, newHeight, null);
+        g.dispose();
+
+        System.out.println("图片已缩放: " + width + "x" + height + " -> " + newWidth + "x" + newHeight);
+        return resized;
+    }
+
+    /**
+     * 增强对比度
+     */
+    private static BufferedImage enhanceContrast(BufferedImage image) {
+        BufferedImage result = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
+
+        for (int y = 0; y < image.getHeight(); y++) {
+            for (int x = 0; x < image.getWidth(); x++) {
+                Color color = new Color(image.getRGB(x, y));
+
+                // 增强对比度
+                int red = (int) (color.getRed() * 1.2);
+                int green = (int) (color.getGreen() * 1.2);
+                int blue = (int) (color.getBlue() * 1.2);
+
+                // 限制RGB值范围
+                red = Math.min(255, Math.max(0, red));
+                green = Math.min(255, Math.max(0, green));
+                blue = Math.min(255, Math.max(0, blue));
+
+                result.setRGB(x, y, new Color(red, green, blue).getRGB());
+            }
+        }
+
+        System.out.println("对比度已增强");
+        return result;
+    }
+
+    /**
+     * 锐化图像（可选，使文字边缘更清晰）
+     */
+    private static BufferedImage sharpenImage(BufferedImage image) {
+        BufferedImage result = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
+
+        float[] sharpenKernel = {
+                0, -1, 0,
+                -1, 5, -1,
+                0, -1, 0
+        };
+
+        Kernel kernel = new Kernel(3, 3, sharpenKernel);
+        java.awt.image.ConvolveOp op = new java.awt.image.ConvolveOp(kernel, java.awt.image.ConvolveOp.EDGE_NO_OP, null);
+        op.filter(image, result);
+
+        System.out.println("图像已锐化");
+        return result;
+    }
+}
 \ No newline at end of file
+package com.xly.ocr.test;
+
+import com.benjaminwan.ocrlibrary.OcrResult;
+import com.benjaminwan.ocrlibrary.TextBlock;
+import io.github.mymonstercat.Model;
+import io.github.mymonstercat.ocr.InferenceEngine;
+import io.github.mymonstercat.ocr.config.ParamConfig;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+public class Test {
+
+    static {
+        try {
+            String customTempDir = "D:/temp/ocrJava";
+            File tempDir = new File(customTempDir);
+            if (!tempDir.exists()) {
+                tempDir.mkdirs();
+            }
+            System.setProperty("java.io.tmpdir", customTempDir);
+            System.setProperty("TMP", customTempDir);
+            System.setProperty("TEMP", customTempDir);
+
+            System.out.println("==================================");
+            System.out.println("临时目录: " + System.getProperty("java.io.tmpdir"));
+            System.out.println("==================================");
+
+        } catch (Exception e) {
+            System.err.println("设置临时目录失败: " + e.getMessage());
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("OCR 程序开始执行...");
+
+            // 1. 初始化引擎（使用 v4 模型）
+            System.out.println("正在初始化 OCR 引擎 (PP-OCRv4)...");
+            InferenceEngine engine = InferenceEngine.getInstance(Model.ONNX_PPOCR_V4);
+
+            // 2. 创建优化的参数配置
+            ParamConfig config = createOptimizedParamConfig();
+
+            // 3. 图片路径
+            String imagePath = "E:/aa/b.jpg";
+            File imageFile = new File(imagePath);
+            if (!imageFile.exists()) {
+                System.err.println("图片文件不存在: " + imagePath);
+                return;
+            }
+
+            // 4. 图像预处理（直接处理原图，不保存临时文件）
+            System.out.println("正在进行图像预处理...");
+            BufferedImage processedImage = preprocessImage(imageFile);
+
+            // 5. 保存预处理后的图片到临时目录
+            String processedImagePath = "D:/temp/ocrJava/processed_" + System.currentTimeMillis() + ".png";
+            ImageIO.write(processedImage, "png", new File(processedImagePath));
+            System.out.println("预处理图片已保存: " + processedImagePath);
+
+            // 6. 执行识别
+            System.out.println("开始识别图片...");
+            long startTime = System.currentTimeMillis();
+            OcrResult ocrResult = engine.runOcr(processedImagePath, config);
+            long endTime = System.currentTimeMillis();
+
+            // 7. 输出结果
+            String text = ocrResult.getStrRes().trim();
+            System.out.println("\n==================================");
+            System.out.println("识别结果：");
+            System.out.println(text);
+            System.out.println("==================================");
+            System.out.println("识别耗时: " + (endTime - startTime) + " ms");
+
+            // 8. 输出每个文本块
+            if (ocrResult.getTextBlocks() != null && !ocrResult.getTextBlocks().isEmpty()) {
+                System.out.println("\n文本块详情（共" + ocrResult.getTextBlocks().size() + "块）：");
+                List<TextBlock> textBlocks = ocrResult.getTextBlocks();
+                for (int i = 0; i < textBlocks.size(); i++) {
+                    TextBlock block = textBlocks.get(i);
+                    System.out.printf("  块%d: %s (置信度: %.2f)%n",
+                            i + 1,
+                            block.getText(),
+                            block.getBoxScore()
+                    );
+                }
+            }
+
+            // 9. 清理临时文件
+            new File(processedImagePath).delete();
+
+        } catch (Exception e) {
+            System.err.println("OCR 识别失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 优化的参数配置
+     */
+    private static ParamConfig createOptimizedParamConfig() {
+        ParamConfig config = new ParamConfig();
+
+        config.setPadding(50);
+        config.setMaxSideLen(0);
+        config.setBoxScoreThresh(0.4f);
+        config.setBoxThresh(0.25f);
+        config.setUnClipRatio(1.8f);
+        config.setDoAngle(true);
+        config.setMostAngle(true);
+
+        return config;
+    }
+
+    /**
+     * 图像预处理 - 直接返回处理后的 BufferedImage
+     */
+    private static BufferedImage preprocessImage(File imageFile) throws IOException {
+        BufferedImage original = ImageIO.read(imageFile);
+        if (original == null) {
+            throw new IOException("无法读取图片: " + imageFile.getPath());
+        }
+
+        System.out.println("原始尺寸: " + original.getWidth() + "x" + original.getHeight());
+
+        BufferedImage processed = original;
+
+        // 1. 如果图片太大，缩小尺寸
+        if (processed.getWidth() > 2000 || processed.getHeight() > 2000) {
+            processed = resizeImage(processed, 1600, 1600);
+        }
+
+        // 2. 增强对比度
+        processed = enhanceContrast(processed);
+
+        System.out.println("处理后尺寸: " + processed.getWidth() + "x" + processed.getHeight());
+
+        return processed;
+    }
+
+    /**
+     * 调整图片大小
+     */
+    private static BufferedImage resizeImage(BufferedImage image, int maxWidth, int maxHeight) {
+        int w = image.getWidth();
+        int h = image.getHeight();
+        double ratio = Math.min((double) maxWidth / w, (double) maxHeight / h);
+        if (ratio >= 1) return image;
+
+        int newW = (int) (w * ratio);
+        int newH = (int) (h * ratio);
+
+        BufferedImage resized = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g = resized.createGraphics();
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+        g.drawImage(image, 0, 0, newW, newH, null);
+        g.dispose();
+        return resized;
+    }
+
+    /**
+     * 增强对比度
+     */
+    private static BufferedImage enhanceContrast(BufferedImage image) {
+        BufferedImage result = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
+        for (int y = 0; y < image.getHeight(); y++) {
+            for (int x = 0; x < image.getWidth(); x++) {
+                Color c = new Color(image.getRGB(x, y));
+                int r = Math.min(255, (int) (c.getRed() * 1.15));
+                int g = Math.min(255, (int) (c.getGreen() * 1.15));
+                int b = Math.min(255, (int) (c.getBlue() * 1.15));
+                result.setRGB(x, y, new Color(r, g, b).getRGB());
+            }
+        }
+        return result;
+    }
+}
 \ No newline at end of file
+//package com.xly.ocr.web;
+//
+//import com.xly.ocr.service.OcrService;
+//import org.springframework.beans.factory.annotation.Autowired;
+//import org.springframework.http.ResponseEntity;
+//import org.springframework.web.bind.annotation.*;
+//import org.springframework.web.multipart.MultipartFile;
+//
+//import java.util.HashMap;
+//import java.util.List;
+//import java.util.Map;
+//
+//@RestController
+//@RequestMapping("/api/ocr")
+//public class OcrController {
+//
+//    @Autowired
+//    private OcrService ocrService;
+//
+//    @PostMapping("/extract")
+//    public ResponseEntity<Map<String, Object>> extractText(
+//            @RequestParam("file") MultipartFile file) {
+//
+//        Map<String, Object> response = new HashMap<>();
+//        long startTime = System.currentTimeMillis();
+//
+//        String result = ocrService.extractTextFromMultipartFile(file);
+//
+//        response.put("text", result);
+//        response.put("time", System.currentTimeMillis() - startTime);
+//        response.put("success", !result.startsWith("错误") && !result.startsWith("失败"));
+//
+//        return ResponseEntity.ok(response);
+//    }
+//
+//    @PostMapping("/batch")
+//    public ResponseEntity<List<String>> batchExtract(
+//            @RequestParam("files") List<MultipartFile> files) {
+//        List<String> results = ocrService.batchExtractText(files);
+//        return ResponseEntity.ok(results);
+//    }
+//}
 \ No newline at end of file
@@ -161,13 +161,29 @@ public class XlyErpService {
                     && ObjectUtil.isNotEmpty(session.getCurrentTool().getSInputTabelName())
                     && ObjectUtil.isNotEmpty(session.getCurrentTool().getSStructureMemo()))
             ){
-                //查询是否走向量库 还是数据库查询
-                Boolean isAggregation = aiAgent.routeQuery(session.getUserId(), input);
+                //查询缓存是否存在取缓存 直接走
+                Map<String,Object>  cachMap = getDynamicTableCach(session,userInput);
+                Boolean isAggregation;
+                Boolean bHasCach;
+                String sCleanSql = StrUtil.EMPTY;
+                if(ObjectUtil.isEmpty(cachMap)){
+                    //查询是否走向量库 还是数据库查询
+                    isAggregation = aiAgent.routeQuery(session.getUserId(), input);
+                    session.setDbCach("D");
+                    bHasCach = false;
+                }else{
+                    isAggregation = "MYSQL".equals(cachMap.get("cachType"));
+                    session.setDbCach("H");
+                    bHasCach = true;
+                    sCleanSql = ObjectUtil.isNotEmpty(cachMap.get("sSqlContent"))?cachMap.get("sSqlContent").toString() : StrUtil.EMPTY;
+                }
                 if(!isAggregation){
                     //获取常量库内容
-                    sResponMessage = getMilvus(session, input, aiAgent);
+                    session.setDbType("X");
+                    sResponMessage = getMilvus(session, input, aiAgent,bHasCach);
                 }else {
-                    sResponMessage = getDynamicTableSql(session, input, userId, userInput,0,StrUtil.EMPTY,StrUtil.EMPTY,"0",StrUtil.EMPTY, aiAgent);
+                    session.setDbType("G");
+                    sResponMessage = getDynamicTableSql(session, input, userId, userInput,0,StrUtil.EMPTY,StrUtil.EMPTY,"0",StrUtil.EMPTY, aiAgent,sCleanSql);
                 }
                 return Flux.just(AiResponseDTO.builder()
                         .aiText(sResponMessage)
@@ -235,8 +251,10 @@ public class XlyErpService {
             session = userSceneSessionService.getUserSceneSession(userId,sUserName,sBrandsId,sSubsidiaryId,sUserType,authorization);
             session.setAuthorization(authorization);
             session.setSFunPrompts(null);
+            session.setDbCach(StrUtil.EMPTY);
+            session.setDbType(StrUtil.EMPTY);
+
             sceneName = ObjectUtil.isNotEmpty(session.getCurrentScene())?session.getCurrentScene().getSSceneName():StrUtil.EMPTY;
-            methodName = ObjectUtil.isNotEmpty(session.getCurrentTool())?session.getCurrentTool().getSMethodName():StrUtil.EMPTY;
             // 2. 特殊指令：重置场景（无论是否已选，都可重置）
             if (input.contains("重置") || input.contains("重新选择")) {
                 //清除记忆缓存
@@ -268,7 +286,7 @@ public class XlyErpService {
             ){
                 sResponMessage = aiAgent.chat(userId, input);
             }
-
+            methodName = ObjectUtil.isNotEmpty(session.getCurrentTool())?session.getCurrentTool().getSMethodName():StrUtil.EMPTY;
             if(ObjectUtil.isNotEmpty(session.getCurrentTool())
                     && !ObjectUtil.isNotEmpty(session.getCurrentTool().getSInputTabelName())
             ){
@@ -283,28 +301,44 @@ public class XlyErpService {
                     && ObjectUtil.isNotEmpty(session.getCurrentTool().getSInputTabelName())
                     && ObjectUtil.isNotEmpty(session.getCurrentTool().getSStructureMemo()))
             ){
-                //查询是否走向量库 还是数据库查询
-                Boolean isAggregation = aiAgent.routeQuery(session.getUserId(), input);
+                //查询缓存是否存在取缓存 直接走
+                Map<String,Object>  cachMap = getDynamicTableCach(session,userInput);
+                Boolean isAggregation;
+                Boolean bHasCach;
+                String sCleanSql = StrUtil.EMPTY;
+                if(ObjectUtil.isEmpty(cachMap)){
+                    //查询是否走向量库 还是数据库查询
+                    isAggregation = aiAgent.routeQuery(session.getUserId(), input);
+                    session.setDbCach("D");
+                    bHasCach = false;
+                }else{
+                    isAggregation = "MYSQL".equals(cachMap.get("cachType"));
+                    session.setDbCach("H");
+                    bHasCach = true;
+                    sCleanSql = ObjectUtil.isNotEmpty(cachMap.get("sSqlContent"))?cachMap.get("sSqlContent").toString() : StrUtil.EMPTY;
+                }
                 if(!isAggregation){
                     //获取常量库内容
-                    sResponMessage = getMilvus(session, input, aiAgent);
+                    session.setDbType("X");
+                    sResponMessage = getMilvus(session, input, aiAgent,bHasCach);
                 }else {
-                    sResponMessage = getDynamicTableSql(session, input, userId, userInput,0,StrUtil.EMPTY,StrUtil.EMPTY,"0",StrUtil.EMPTY, aiAgent);
+                    session.setDbType("G");
+                    sResponMessage = getDynamicTableSql(session, input, userId, userInput,0,StrUtil.EMPTY,StrUtil.EMPTY,"0",StrUtil.EMPTY, aiAgent,sCleanSql);
                 }
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).sReturnType(ReturnTypeCode.HTML.getCode()).dbType(session.getDbType()).dbCach(session.getDbCach()).build();
             } else if (ObjectUtil.isNotEmpty(session.getCurrentTool())) {
                 //2.处理工具参数采集结束后业务逻辑处理
                 //调用方法,参数缺失部分提示，就直接使用方法返回的
                 sResponMessage = dynamicToolProvider.doDynamicTool(session.getCurrentTool(),session);
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
             }else if(session.getCurrentScene()== null ){
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("当前场景:没有选择 退回当前场景 请输入 "+ CommonConstant.RESET + sResponMessage).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("当前场景:没有选择 退回当前场景 请输入 "+ CommonConstant.RESET + sResponMessage).dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
             }else{
                 return getChatiAgent (input, session);
             }
         } catch (Exception e) {
             e.printStackTrace();
-            return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("系统异常：" + e.getMessage() + "，请稍后重试！").sReturnType(ReturnTypeCode.HTML.getCode()).build();
+            return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("系统异常：" + e.getMessage() + "，请稍后重试！").dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
         }finally {
             //5.执行工具方法后，清除记忆
             if(session !=null && session.getBCleanMemory()){
@@ -363,23 +397,56 @@ public class XlyErpService {
      * @return java.lang.String
      * @Description 查询向量库
      **/
-    private String getMilvus(UserSceneSession session,String userInput,ErpAiAgent aiAgent){
+    private String getMilvus(UserSceneSession session,String userInput,ErpAiAgent aiAgent,Boolean bCach){
         String resultExplain = "信息模糊,请提供更具体的问题或指令";
         try{
+            addSessionUserQuestionList(session, userInput);
             String sVectorfiled = session.getCurrentTool().getSVectorfiled();
             String sInputTabelName = session.getCurrentTool().getSInputTabelName();
             String sVectorfiledAll = session.getCurrentTool().getSVectorfiledAll();
-            Map<String,Object> rMap = milvusService.getMilvusFiled(sVectorfiled,sVectorfiledAll);
+            String sVectorfiledShow = session.getCurrentTool().getSVectorfiledShow();
+            Map<String,Object> rMap = milvusService.getMilvusFiled(sVectorfiled,sVectorfiledAll,sVectorfiledShow);
             String sMilvusFiled =  rMap.get("sMilvusFiled").toString();
             String sMilvusFiledDescription = rMap.get("sMilvusFiledDescription").toString();
             String sMilvusFiledDescriptionAll = rMap.get("sMilvusFiledDescriptionAll").toString();
-            List<String> fields = (List<String>) rMap.get("sFileds");
-//            List<Map<String, String>> title  = (List<Map<String, String>>) rMap.get("title");
-            String milvusFilter = aiAgent.getMilvusFilter(session.getUserId(),userInput, sMilvusFiled, sMilvusFiledDescription);
-            List<Map<String,Object>> data = milvusService.getDataToCollection(sInputTabelName, milvusFilter,userInput,100,fields);
-            //采用表格形式显示
-            resultExplain = aiAgent.explainMilvusResult(session.getUserId(),userInput,sMilvusFiledDescriptionAll,JSONObject.toJSONString(data));
-                    //buildMarkdownTableWithStream(data, title);
+            List<String> filedsShow = (List<String>) rMap.get("filedsShow");
+            List<Map<String, String>> title  = (List<Map<String, String>>) rMap.get("title");
+            String milvusFilter = StrUtil.EMPTY;
+            if(!bCach){
+                milvusFilter = aiAgent.getMilvusFilter(session.getUserId(),userInput, sMilvusFiled, sMilvusFiledDescription,DateUtil.now());
+                log.info("查询向量库条件{}",milvusFilter);
+                milvusFilter = milvusService.isValidMilvusFilter(milvusFilter)?milvusFilter : null;
+                log.info("实际查询向量库条件{}",milvusFilter);
+            }
+            Integer pageSize = 100;
+            if(ObjectUtil.isEmpty(milvusFilter)){
+                pageSize = 10;
+            }
+//            待条件全查  不带 10条
+            List<Map<String,Object>> data = milvusService.getDataToCollection(sInputTabelName, milvusFilter,userInput,pageSize,filedsShow);
+            //存储到历史问题库（带where条件了就不存）并且没有记录过缓存
+            if(!bCach && ObjectUtil.isEmpty(milvusFilter)){
+                //执行操作记录表
+                try{
+                    List<ChatMessage> chatMessage = operableChatMemoryProvider.getCurrentChatMessages(session.getUserId());
+                    //插入向量库
+                    doAiUserAgentQuestion(session,userInput,milvusFilter,"MILVUS",chatMessage);
+                }catch (Exception e){
+                    log.error("插入向量库异常",e);
+                }
+            }
+            //采用表格形式显示明细、...详情、...记录、...列表、...清单
+            if(ObjectUtil.isEmpty(milvusFilter)
+                    || userInput.contains("明细")
+                    ||  userInput.contains("详情")
+                    ||  userInput.contains("记录")
+                    ||  userInput.contains("列表")
+                    ||  userInput.contains("清单")
+            ){
+                resultExplain = buildMarkdownTableWithStream(data, title);
+            }else{
+                resultExplain = aiAgent.explainMilvusResult(session.getUserId(),userInput,sMilvusFiledDescriptionAll,JSONObject.toJSONString(data));
+            }
             return resultExplain;
         }catch (Exception e){
             e.printStackTrace();
@@ -435,25 +502,16 @@ public class XlyErpService {
      * @return java.lang.String
      * @Description 获取执行动态SQL
      **/
-    private String getDynamicTableSql(UserSceneSession session,String input,String userId,String userInput,Integer attempt,String errorSql,String errorMessage,String iErroCount,String historySqlList,ErpAiAgent aiAgent){
+    private String getDynamicTableSql(UserSceneSession session,String input,String userId,String userInput,Integer attempt,String errorSql,String errorMessage,String iErroCount,String historySqlList,ErpAiAgent aiAgent,String  cleanSql){
         String resultExplain = "信息模糊,请提供更具体的问题或指令";
         try{
             while (attempt < maxRetries) {
                 try{
                     attempt = attempt+1;
                     if(attempt==1){
-                        List<String> userQuestionList = session.getSUserQuestionList();
-                        if(ObjectUtil.isEmpty(userQuestionList)){
-                            userQuestionList = new ArrayList<>();
-                        }
-                        String  sQuestion = StrUtil.replace(userInput," ",StrUtil.EMPTY);
-                        sQuestion = StrUtil.replace(sQuestion,"\t",StrUtil.EMPTY);
-                        sQuestion = StrUtil.replace(sQuestion,"\n",StrUtil.EMPTY);
-                        sQuestion = sQuestion.toLowerCase();
-                        userQuestionList.add(sQuestion);
-                        session.setSUserQuestionList(userQuestionList);
+                        addSessionUserQuestionList(session, userInput);
                     }
-                    return getDynamicTableSqlExec(session, input, userId, userInput,errorSql,errorMessage,iErroCount,historySqlList, aiAgent);
+                    return getDynamicTableSqlExec(session, input, userId, userInput,errorSql,errorMessage,iErroCount,historySqlList, aiAgent, cleanSql);
                 }catch (SqlValidateException e){
                     return "本场景没有识别到您的意图<br/> 如果切换场景，点［回首页］，如果在本场景下，转换意图，点［清除记忆］";
                 }catch (Exception e){
@@ -472,7 +530,7 @@ public class XlyErpService {
                     if (attempt == maxRetries) {
                         return resultExplain +"<br/>查询的SQL语句："+historySqlList;
                     } else {
-                        return getDynamicTableSql( session, input, userId, userInput, attempt,errorSqlOld,errorMessageOld,attempt.toString(),historySqlList, aiAgent);
+                        return getDynamicTableSql( session, input, userId, userInput, attempt,errorSqlOld,errorMessageOld,attempt.toString(),historySqlList, aiAgent,cleanSql);
                     }
                 }
             }
@@ -484,6 +542,19 @@ public class XlyErpService {
         return resultExplain;
     }
+    private void addSessionUserQuestionList(UserSceneSession session,String userInput){
+        List<String> userQuestionList = session.getSUserQuestionList();
+        if(ObjectUtil.isEmpty(userQuestionList)){
+            userQuestionList = new ArrayList<>();
+        }
+        String  sQuestion = StrUtil.replace(userInput," ",StrUtil.EMPTY);
+        sQuestion = StrUtil.replace(sQuestion,"\t",StrUtil.EMPTY);
+        sQuestion = StrUtil.replace(sQuestion,"\n",StrUtil.EMPTY);
+        sQuestion = sQuestion.toLowerCase();
+        userQuestionList.add(sQuestion);
+        session.setSUserQuestionList(userQuestionList);
+    }
+
     /***
      * @Author 钱豹
      * @Date 19:59 2026/3/4
@@ -510,18 +581,15 @@ public class XlyErpService {
      * @return java.lang.String
      * @Description 执行动态sSql
      **/
-    private String getDynamicTableSqlExec(UserSceneSession session,String input,String userId,String userInput,String errorSql,String errorMessage,String iErroCount,String historySqlList,ErpAiAgent aiAgent){
+    private String getDynamicTableSqlExec(UserSceneSession session,String input,String userId,String userInput,String errorSql,String errorMessage,String iErroCount,String historySqlList,ErpAiAgent aiAgent,String cleanSql){
         // 1. 构建自然语言转SQLAgent，
         List<Map<String, Object>> sqlResult;
-        String cleanSql = StrUtil.EMPTY;
         String rawSql;
         String tableStruct = session.getCurrentTool().getSStructureMemo();
         String sError_mes;
         Boolean doAddSql = false;
         List<ChatMessage> chatMessage = new ArrayList<>();
         try{
-            //获取缓存动态SQL
-//            cleanSql = getDynamicTableNl2Sql(session,input);
             //如果之前已查询直接返回
             if(ObjectUtil.isEmpty(cleanSql)){
                 DynamicTableNl2SqlAiAgent aiDynamicTableNl2SqlAiAgent = createDynamicTableNl2SqlAiAgent(userId, input, session);
@@ -575,7 +643,7 @@ public class XlyErpService {
         //插入常用操作
         if(doAddSql){
             //执行操作记录表
-            doAiUserAgentQuestion(session,input,cleanSql,chatMessage);
+            doAiUserAgentQuestion(session,input,cleanSql,"MYSQL",chatMessage);
         }
         String sText = aiAgent.explainSqlResult(
                 userId,
@@ -594,18 +662,41 @@ public class XlyErpService {
      * @return java.lang.String
      * @Description 获取动态SQL（历史中查询）
      **/
+    private Map<String,Object> getDynamicTableCach(UserSceneSession session,String input){
+        try{
+            String searchText = session.getCurrentScene().getSId()+"_"+session.getCurrentTool().getSId()+input;
+            //根据问题查询向量库
+            Map<String,Object> serMap = aiGlobalAgentQuestionSqlEmitterService.queryAiGlobalAgentQuestionSqlEmitter(searchText, "ai_global_agent_question_sql");
+            return serMap;
+        }catch (Exception e){
+            log.error("取是否走缓存异常");
+        }
+        return null;
+    }
+
+    /***
+     * @Author 钱豹
+     * @Date 17:04 2026/3/19
+     * @Param [session]
+     * @return java.lang.String
+     * @Description 获取动态SQL（历史中查询）
+     **/
     private String getDynamicTableNl2Sql(UserSceneSession session,String input){
 //        String sReidKey = SqlValidateUtil.getsKey( session.getCurrentScene().getSId(), session.getCurrentTool().getSId(), input);
 //        Object sSql = redisService.get(sReidKey);
 //        if(ObjectUtil.isNotEmpty(sSql)){
 //            return sSql.toString();
 //        }
-        String searchText = session.getCurrentScene().getSId()+"_"+session.getCurrentTool().getSId()+input;
-                //SqlValidateUtil.getsKey( session.getCurrentScene().getSId(), session.getCurrentTool().getSId(), SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
-        //根据问题查询向量库
-        Map<String,Object> serMap = aiGlobalAgentQuestionSqlEmitterService.queryAiGlobalAgentQuestionSqlEmitter(searchText, "ai_global_agent_question_sql");
-        if(ObjectUtil.isNotEmpty(serMap)){
-            return serMap.get("sSqlContent").toString();
+        try{
+            String searchText = session.getCurrentScene().getSId()+"_"+session.getCurrentTool().getSId()+input;
+            //SqlValidateUtil.getsKey( session.getCurrentScene().getSId(), session.getCurrentTool().getSId(), SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
+            //根据问题查询向量库
+            Map<String,Object> serMap = aiGlobalAgentQuestionSqlEmitterService.queryAiGlobalAgentQuestionSqlEmitter(searchText, "ai_global_agent_question_sql");
+            if(ObjectUtil.isNotEmpty(serMap)){
+                return serMap.get("sSqlContent").toString();
+            }
+        }catch (Exception e){
+
         }
         return null;
     }
@@ -639,11 +730,12 @@ public class XlyErpService {
     public void doAiUserAgentQuestion(UserSceneSession session,
                                           String sQuestion,
                                           String sSqlContent,
+                                          String cachType,
                                           List<ChatMessage> chatMessage
     ){
         MultiThreadPoolServer mts = MultiThreadPoolServer.getInstance();
-        AiUserAgentQuestionThread at = new AiUserAgentQuestionThread(session,sQuestion,sSqlContent,chatMessage);
+        AiUserAgentQuestionThread at = new AiUserAgentQuestionThread(session,sQuestion,sSqlContent,cachType,chatMessage);
         mts.service(at);
     }
@@ -21,14 +21,16 @@ public class AiUserAgentQuestionThread implements Runnable {
     private UserSceneSession session;
     private String sSqlContent;
     private String sQuestion;
+    private String cachType;
     List<ChatMessage> userMessage;
     public final String sProName="Sp_Ai_AiUserAgentQuestionThread";
-    public AiUserAgentQuestionThread(UserSceneSession session,String sQuestion,String sSqlContent, List<ChatMessage> userMessage ) {
+    public AiUserAgentQuestionThread(UserSceneSession session,String sQuestion,String sSqlContent,String cachType, List<ChatMessage> userMessage ) {
         this.session = session;
         this.sSqlContent = sSqlContent;
         this.sQuestion = sQuestion;
         this.userMessage = userMessage;
+        this.cachType = cachType;
     }
     @Override
@@ -44,6 +46,7 @@ public class AiUserAgentQuestionThread implements Runnable {
         Map<String, Object> data = getMap(sSceneId, sMethodId,bRedis,sQuestionGroupNo);
         data.put("sQuestion",SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
         data.put("sId",new UUIDGenerator().next());
+        data.put("cachType",cachType);
         //插入Redis缓存
         if(bRedis==1 && ObjectUtil.isNotEmpty(sSqlContent)){
             String sReidKey = SqlValidateUtil.getsKey( sSceneId, sMethodId, sQuestionGroupNo);
@@ -52,7 +55,7 @@ public class AiUserAgentQuestionThread implements Runnable {
         String sKey = sSceneId+"_"+sMethodId +"_"+sQuestion;
 //                SqlValidateUtil.getsKey( sSceneId, sMethodId, SqlValidateUtil.getsQuestion(session.getSUserQuestionList()));
         //存入向量库
-        aiGlobalAgentQuestionSqlEmitterService.addAiGlobalAgentQuestionSqlEmitter(sKey,data,sQuestion,sSqlContent,"ai_global_agent_question_sql");
+        aiGlobalAgentQuestionSqlEmitterService.addAiGlobalAgentQuestionSqlEmitter(sKey,data,sQuestion,sSqlContent,cachType,"ai_global_agent_question_sql");
         //调用数据库插入数据库
         Map<String, Object> searMap = dynamicExeDbService.getDoProMap(sProName, data);
         dynamicExeDbService.getCallPro(searMap, sProName);
@@ -903,17 +903,18 @@ public class DynamicToolProvider implements ToolProvider {
         Map<String,Object> returnMap = transformationArgs( args, paramDefs);
         return paramDefs.stream()
                 .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel())
-                .filter(pd ->
-                        (!returnMap.containsKey(pd.getSParam())
-                                || (ObjectUtil.isEmpty(returnMap.get(pd.getSParam())))
-                                || (pd.getSParamValue().startsWith("d") && 0==Double.valueOf (returnMap.get(pd.getSParam()).toString()))
-                        )
-                        && (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()))))
-                )
+                .filter(pd -> checkMiss( returnMap, pd))
                 .map(ParamRule::getSParam)
                 .toList();
     }
+    private Boolean checkMiss(Map<String,Object> returnMap,ParamRule pd) {
+        Boolean bBhcs = (ObjectUtil.isEmpty(returnMap.get(pd.getSParam())));
+        Boolean bDbZero = (pd.getSParamValue().startsWith("d") && 0 == Double.valueOf(returnMap.get(pd.getSParam()).toString()));
+        return  bDbZero || bBhcs  || (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()))));
+    }
+
+
     /**
      * 确认后必填参数
      */
@@ -72,6 +72,15 @@ public class TTSResponseDTO implements Serializable {
     private String sReturnType = ReturnTypeCode.MAKEDOWN.getCode();
     private Boolean ErpComplete;
+    /**
+     * 数据库类型 X: 向量库  S:数据库
+     */
+    private String dbType;
+
+    /**
+     * 数据库类型 H: 缓存  D: 动态
+     */
+    private String dbCach;
     /**
      * 创建失败响应
@@ -278,6 +278,8 @@ public class PythonTtsProxyService {
                 .sSceneName(aiResponseDTO.getSSceneName())
                 .sMethodName(aiResponseDTO.getSMethodName())
                 .sReturnType(aiResponseDTO.getSReturnType())
+                .dbType(aiResponseDTO.getDbType())
+                .dbCach(aiResponseDTO.getDbCach())
                 .sCommonts(BusinessCode.COMMONTS.getMessage())
                 .timestamp(System.currentTimeMillis())
                 .textLength((aiText + systemText).length())
@@ -127,11 +127,12 @@ langchain4j:
     # 聊天模型配置（用于一般对话）
     base-url: http://112.82.245.194:11434
     chat-model-name: qwen2.5:7b-instruct
+#    chat-model-name: qwen3:14b
 #    chat-model-name: qwen3.5:9b
     # SQL/代码模型配置（专门用于代码和SQL生成）
     sql-model-name: qwen2.5-coder:7b
+#    sql-model-name: SimonPu/qwen3-coder:30B-Instruct_Q4_K_XL
 #    sql-model-name: qwen2.5-coder:32b
-#    sql-model-name: mdq100/qwen3.5-coder:35b
     # 或者如果两个模型在同一服务器，可以使用同一个URL
 #  ollama:
@@ -140,7 +141,9 @@ langchain4j:
 #    chat-model-name: qwen3.5:9b
 #    # SQL/代码模型配置（专门用于代码和SQL生成）
 #    sql-model-name: mdq100/qwen3.5-coder:35b
-
+tesseract:
+  # 这里填写你存放 tessdata 的目录路径，注意不是 tessdata 文件夹本身
+  datapath: D:/xlyweberp/Tesseract-OCR/tessdata
 mybatis:
   mapper-locations: classpath:mapper/*.xml
   type-aliases-package: com.xly.entity