(improvement)(project) Upgrade to version 0.9.2. (#1072)

Co-authored-by: jolunoluo

.github/workflows/mac-ci.yml

@@ -0,0 +1,35 @@
+name: supersonic mac CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: macos-latest  # Specify a macOS runner
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up JDK 8
+        uses: actions/setup-java@v2
+        with:
+          java-version: '8'
+          distribution: 'adopt'
+
+      - name: Cache Maven packages
+        uses: actions/cache@v2
+        with:
+          path: ~/Library/Caches/Maven  # macOS Maven cache path
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-m2
+
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml
+
+      - name: Test with Maven
+        run: mvn test

.github/workflows/ubuntu-ci.yml

@@ -0,0 +1,31 @@
+name: supersonic ubuntu CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 8
+      uses: actions/setup-java@v2
+      with:
+        java-version: '8'
+        distribution: 'adopt'
+    - name: Cache Maven packages
+      uses: actions/cache@v2
+      with:
+        path: ~/.m2
+        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+        restore-keys: ${{ runner.os }}-m2
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml
+    - name: Test with Maven
+      run: mvn test

.github/workflows/windows-ci.yml

@@ -0,0 +1,35 @@
+name: supersonic windows CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: windows-latest  # Specify a Windows runner
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up JDK 8
+        uses: actions/setup-java@v2
+        with:
+          java-version: '8'
+          distribution: 'adopt'
+
+      - name: Cache Maven packages
+        uses: actions/cache@v2
+        with:
+          path: ~\.m2  # Windows uses a backslash for paths
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-m2
+
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml
+
+      - name: Test with Maven
+        run: mvn test

.gitignore

@@ -8,6 +8,7 @@ log/
 *.bin
 *.log
 *.tar.gz
+*.zip
 *.lib
 assembly/runtime/*
 **/dist/
@@ -15,4 +16,7 @@ assembly/runtime/*
 /assembly/deploy
 /runtime
 **/.flattened-pom.xml
-__pycache__/
+chm_db/
+__pycache__/
+/dict
+assembly/build/*-SNAPSHOT

CHANGELOG.md

@@ -3,25 +3,88 @@
 - All notable changes to this project will be documented in this file.
 - "Breaking Changes" describes any changes that may break existing functionality or cause
   compatibility issues with previous versions.
+
+## SuperSonic [0.9.2] - 2024-06-01
+
+### Added
+- support multiple rounds of dialogue
+- add term configuration and identification to help LLM learn private domain knowledge
+- support configuring LLM parameters in the agent
+- metric market supports searching in natural language
+
+### Updated
+- introducing WorkFlow, Mapper, Parser, and Corrector support jump execution
+- Introducing the concept of Model-Set to simplify Domain management
+- overall optimization and upgrade of system pages
+- optimize startup script
+
+## SuperSonic [0.9.0] - 2024-04-03
+
+### Added
+- add tag abstraction and enhance tag marketplace management.
+- headless-server provides Chat API interface.
+
+### Updated
+- migrate chat-core core component to headless-core.
+
+## SuperSonic [0.8.6] - 2024-02-23
+
+### Added
+- support view abstraction to Headless.
+- add the Metric API to Headless and optimizing the Headless API.
+- add integration tests to Headless.
+- add TimeCorrector to Chat.
+
+## SuperSonic [0.8.4] - 2024-01-19
+
+### Added
+- support creating derived metrics.
+  - Support creating metrics using three methods: by measure, metric, and field expressions.
+- added support for postgresql data source.
+- code adjustment and abstract optimization for chat and headless.
+
+## SuperSonic [0.8.2] - 2023-12-18
+
+### Added
+- rewrite Python service with Java project, default to Java implementation.
+- support setting the SQL generation method for large models in the interface.
+- optimization of metric market experience.
+- optimization of semantic modeling canvas experience.
+- code structure adjustment and abstraction optimization for chat.
+
+## SuperSonic [0.7.5] - 2023-10-13
+
+### Added
+- add SQL generation improvement optimization, support LLM SQL, Logic SQL, and Physical SQL display.
+- add showcase functionality to support recommending similar questions.
+- add frontend modification of filtering conditions and re-querying feature.
+- support nested query functionality in semantic.
+- support switching queries between multiple parsers in the frontend.
+
+### Updated
+- optimizing the build and deployment of the project.
+- overall optimization of the SQL Corrector functionality.
+
+### Fixed
+- fix execute error on mysql <=5.7
   
-  ## SuperSonic [0.7.4] - 2023-09-10
+## SuperSonic [0.7.4] - 2023-09-10
   
-  ### Added
+### Added
-  - add llm parser config
+- add llm parser config
-  - add datasource agg_time option
+- add datasource agg_time option
-  - add function name adaptor in clickhouse
+- add function name adaptor in clickhouse
-  - add dimension and metric show in dsl
+- add dimension and metric show in dsl
   
-  
+### Updated
-  ### Updated
+- update user guide doc
-  - update user guide doc
+- update query building of plugin in default model
-  - update query building of plugin in default model
+- update some core API constructs to keep naming consistency
-  - update some core API constructs to keep naming consistency
+- update ConfigureDemo config
-  - update ConfigureDemo config
+- update the association mechanism so that invisible dimensions and metrics will no longer be associated
-  - update the association mechanism so that invisible dimensions and metrics will no longer be associated
+
-  
+### Fixed
-  ### Fixed
+- fix hasAggregateFunction logic in SqlParserSelectHelper
-  - fix hasAggregateFunction logic in SqlParserSelectHelper
 
 ## SuperSonic [0.7.3] - 2023-08-29
 

README.md

@@ -1,30 +1,40 @@
 [中文介绍](README_CN.md) | [文档中心](https://github.com/tencentmusic/supersonic/wiki)
 
-# SuperSonic (超音数)
+![Java CI](https://github.com/tencentmusic/supersonic/workflows/supersonic%20CI/badge.svg)
 
-**SuperSonic is an out-of-the-box yet highly extensible framework for building a data chatbot**. SuperSonic provides a chat interface that empowers users to query data using natural language and visualize the results with suitable charts. To enable such experience, the only thing necessary is to build logical semantic models (definition of metrics/dimensions/entities, along with their meaning, context and relationships) on top of physical data models, and no data modification or copying is required. Meanwhile, SuperSonic is designed to be pluggable, allowing new functionalities to be added through plugins and core components to be integrated with other systems.
+# SuperSonic
+
+SuperSonic is the next-generation BI platform that integrates **Chat BI** (powered by LLM) and **Headless BI** (powered by semantic layer) paradigms. This integration ensures that Chat BI has access to the same curated and governed semantic data models as traditional BI. Furthermore, the implementation of both paradigms benefits from the integration: 
+
+- Chat BI's Text2SQL gets augmented with context-retrieval from semantic models.
+- Headless BI's query interface gets extended with natural language API.
+
+<img src="./docs/images/supersonic_ideas.png" height="75%" width="75%" align="center"/>
+
+SuperSonic provides a **Chat BI interface** that empowers users to query data using natural language and visualize the results with suitable charts. To enable such experience, the only thing necessary is to build logical semantic models (definition of metric/dimension/tag, along with their meaning and relationships) through a **Headless BI interface**. Meanwhile, SuperSonic is designed to be extensible and composable, allowing custom implementations to be added and configured with Java SPI.
 
 <img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
 
 ## Motivation
 
-The emergence of Large Language Model (LLM) like ChatGPT is reshaping the way information is retrieved. In the field of data analytics, both academia and industry are primarily focused on leveraging LLM to convert natural language queries into SQL queries. While some works show promising results, they are still not applicable to real-world scenarios.
+The emergence of Large Language Model (LLM) like ChatGPT is reshaping the way information is retrieved, leading to a new paradigm in the field of data analytics known as Chat BI. To implement Chat BI, both academia and industry are primarily focused on harnessing the power of LLMs to convert natural language into SQL, commonly referred to as Text2SQL or NL2SQL. While some approaches show promising results, their **reliability** falls short for large-scale real-world applications.
 
-From our perspective, the key to filling the real-world gap lies in three aspects: 
+Meanwhile, another emerging paradigm called Headless BI, which focuses on constructing unified semantic data models, has garnered significant attention. Headless BI is implemented through a universal semantic layer that exposes consistent data semantics via an open API.
-1. Complement the LLM-based semantic parser with rule-based semantic parsers to improve **efficiency**(in terms of latency and cost).
-2. Augment semantic parsing with schema mappers(as a kind of preprocessor) and semantic correctors(as a kind of postprocessor) to improve **accuracy** and **stability**.
-3. Introduce a semantic layer encapsulating underlying data context(joins, formulas, etc) to reduce **complexity**.
 
-With these ideas in mind, we develop SuperSonic as a practical reference implementation and use it to power our real-world products. Additionally, to facilitate further development of data chatbot, we decide to open source SuperSonic as an extensible framework.
+From our perspective, the integration of Chat BI and Headless BI has the potential to enhance the Text2SQL generation in two dimensions:
+
+1. Incorporate data semantics (such as business terms, column values, etc.) into the prompt, enabling LLM to better understand the semantics and **reduce hallucination**.
+2. Offload the generation of advanced SQL syntax (such as join, formula, etc.) from LLM to the semantic layer to **reduce complexity**. 
+
+With these ideas in mind, we develop SuperSonic as a practical reference implementation and use it to power our real-world products. Additionally, to facilitate further development we decide to open source SuperSonic as an extensible framework.
 
 ## Out-of-the-box Features
 
-- Built-in CUI(Chat User Interface) for *business users* to enter data queries
+- Built-in Chat BI interface for *business users* to enter natural language queries
-- Built-in GUI(Graphical User Interface) for *analytics engineers* to build semantic models
+- Built-in Headless BI interface for *analytics engineers* to build semantic data models
-- Built-in GUI for *system administrators* to manage chat agents and third-party plugins
+- Built-in rule-based semantic parser to improve efficiency in certain scenarios (e.g. demonstration, integration testing)
-- Support input auto-completion as well as query recommendation
+- Built-in support for input auto-completion, multi-turn conversation as well as post-query recommendation
-- Support multi-turn conversation and history context management 
+- Built-in support for three-level data access control: dataset-level, column-level and row-level
-- Support four-level permission control: domain-level, model-level, column-level and row-level
 
 ## Extensible Components
 
@@ -36,11 +46,11 @@ The high-level architecture and main process flow is as follows:
 
 - **Schema Mapper:** identifies references to schema elements(metrics/dimensions/entities/values) in user queries. It matches the query text against the knowledge base.
 
-- **Semantic Parser:** understands user queries and extracts semantic information. It consists of a combination of rule-based and model-based parsers, each of which deals with specific scenarios.
+- **Semantic Parser:** understands user queries and generates semantic query statement. It consists of a combination of rule-based and model-based parsers, each of which deals with specific scenarios.
 
-- **Semantic Corrector:** checks validity of extracted semantic information and performs correction and optimization if needed.
+- **Semantic Corrector:** checks validity of semantic query statement and performs correction and optimization if needed.
 
-- **Semantic Layer:** performs execution according to extracted semantic information. It generates SQL queries and executes them against physical data models.
+- **Semantic Translator:** converts semantic query statement into SQL statement that can be executed against physical data models.
 
 - **Chat Plugin:** extends functionality with third-party tools. The LLM is going to select the most suitable one, given all configured plugins with function description and sample questions.
 
@@ -49,15 +59,15 @@ The high-level architecture and main process flow is as follows:
 SuperSonic comes with sample semantic models as well as chat conversations that can be used as a starting point. Please follow the steps: 
 
 - Download the latest prebuilt binary from the [release page](https://github.com/tencentmusic/supersonic/releases)
-- Run script "bin/start-standalone.sh" to start services (one java process and one python process)
+- Run script "assembly/bin/supersonic-daemon.sh start" to start a standalone Java service
 - Visit http://localhost:9080 in the browser to start exploration
 
-## Build and Delopment
+## Build and Development
 
 Please refer to project [wiki](https://github.com/tencentmusic/supersonic/wiki). 
 
 ## WeChat Contact
 
-Please join the chat group to suggest feedbacks or ideas:
+Please follow SuperSonic wechat official account:
 
-<img src="./docs/images/wechat_contact.jpeg" height="40%" width="40%" align="center"/> 
+<img src="./docs/images/supersonic_wechat_oa.png" height="50%" width="50%" align="center"/> 

README_CN.md

@@ -1,53 +1,61 @@
-# 超音数（SuperSonic）
+# SuperSonic
 
-**超音数是一个开箱即用且易于扩展的数据问答对话框架**。通过超音数的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。超音数不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（指标/维度/实体的定义，以及他们的业务含义、相互间关系等），即可开启数据问答体验。与此同时，超音数被设计为可插拔式的框架，允许以插件形式来扩展新功能，或者将核心组件与其他系统集成。
+**SuperSonic融合Chat BI（powered by LLM）和Headless BI（powered by 语义层）打造新一代的BI平台**。这种融合确保了Chat BI能够与传统BI一样访问统一化治理的语义数据模型。此外，两种BI新范式都从中获得收益：
+
+- Chat BI的Text2SQL生成通过检索语义数据模型得到增强。
+- Headless BI的查询接口通过支持自然语言API得到拓展。
+
+<img src="./docs/images/supersonic_ideas.png" height="75%" width="75%" align="center"/>
+
+通过SuperSonic的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。SuperSonic不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（定义指标/维度/实体/标签，以及它们的业务含义、相互关系等），即可开启数据问答体验。与此同时，SuperSonic被设计为可插拔的框架，采用Java SPI机制来扩展定制功能。
 
 <img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
 
 ## 项目动机
 
-大型语言模型（LLMs）如ChatGPT的出现正在重塑信息检索的方式。在数据分析领域，学术界和工业界主要关注利用深度学习模型将自然语言查询转换为SQL查询。虽然一些工作显示出有前景的结果，但它们还并不适用于实际场景。
+大型语言模型（LLM）如ChatGPT的出现正在重塑信息检索的方式，引领数据分析领域的一种新范式，被称为Chat BI。为了实现Chat BI，学术界和工业界主要关注利用LLM的能力将自然语言转换为SQL，通常称为Text2SQL或NL2SQL。尽管一些方法显示出有希望的结果，但它们在大规模实际应用中的可靠性还不足。
 
-在我们看来，为了在实际场景发挥价值，有三个关键点：
+与此同时，另一种新兴范式被称为Headless BI，它专注于构建统一的语义数据模型，并引起了广泛的关注。Headless BI通过一个通用的语义层来实现，通过开放的API公开一致的数据语义。
-1. 在基于大模型语义解析器基础上，增加基于规则的解析器，提升语义解析的**效率**。
-2. 加入模式映射器和语义修正器，来增强语义解析能力，提升语义解析的**准确性**和**稳定性**。
-3. 引入语义模型层，封装底层数据的上下文（关联、公式等），降低语义解析的**复杂性**。
 
-为了验证上述想法，我们开发了超音数项目，并将其应用在实际的内部产品中。与此同时，我们将超音数作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
+从我们的角度来看，Chat BI和Headless BI的融合有潜力在两个方面增强Text2SQL的能力：
+
+1. 将数据语义（如业务术语、列值等）纳入提示词中，使LLM能够更好地理解语义，以**减少幻觉**。
+2. 将高级SQL语法（如连接、公式等）的生成从LLM卸载到语义层，以**减少复杂度**。
+
+为了验证上述想法，我们开发了SuperSonic项目，并将其应用在实际的内部产品中。与此同时，我们将SuperSonic作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
 
 ## 开箱即用的特性
 
-- 内置对话界面以便*业务用户*输入数据查询。
+- 内置Chat BI界面以便*业务用户*输入数据查询。
-- 内置图形界面以便*分析工程师*构建语义模型。
+- 内置Headless BI界面以便*分析工程师*构建语义模型。
-- 内置图形界面以便*系统管理员*管理第三方插件和对话助理。
+- 内置基于规则的语义解析器，在特定场景（比如DEMO演示、集成测试）可以提升推理效率。
-- 支持文本输入的联想和查询问题的推荐。
+- 支持文本输入联想、多轮对话、查询后问题推荐等高级特征。
-- 支持多轮对话，根据语境自动切换上下文。
+- 支持三级权限控制：数据集级、列级、行级。
-- 支持四级权限控制：主题域级、模型级、列级、行级。
 
 ## 易于扩展的组件
 
-超音数的整体架构和主流程如下图所示：
+SuperSonic的整体架构和主流程如下图所示：
 
 <img src="./docs/images/supersonic_components.png" height="65%" width="65%" align="center"/> 
 
-- **知识库(Knowledge Base)：** 定期从语义模型中提取相关的模式信息，构建词典和索引，以便后续的模式映射。
+- **模型知识库(Knowledge Base)：** 定期从语义模型中提取相关的模式信息，构建词典和索引，以便后续的模式映射。
 
 - **模式映射器(Schema Mapper)：** 将自然语言文本在知识库中进行匹配，为后续的语义解析提供相关信息。
 
-- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，其由一组基于规则和基于模型的解析器组成，每个解析器可应对不同的特定场景。
+- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，生成语义查询语句S2SQL。
 
-- **语义修正器(Semantic Corrector)：** 检查语义信息的合法性，对不合法的信息做修正和优化处理。
+- **语义修正器(Semantic Corrector)：** 检查语义查询语句的合法性，对不合法的信息做修正和优化处理。
 
-- **语义模型层(Semantic Layer)：** 根据语义信息生成物理SQL执行查询。
+- **语义翻译器(Semantic Translator)：** 将语义查询语句翻译成可在物理数据模型上执行的SQL语句。
 
 - **问答插件(Chat Plugin)：** 通过第三方工具扩展功能。给定所有配置的插件及其功能描述和示例问题，大语言模型将选择最合适的插件。
 
 ## 快速体验
 
-超音数自带样例的语义模型和问答对话，只需以下三步即可快速体验：
+SuperSonic自带样例的语义模型和问答对话，只需以下三步即可快速体验：
 
 - 从[release page](https://github.com/tencentmusic/supersonic/releases)下载预先构建好的发行包
-- 运行 "bin/start-standalone.sh"启动服务（一个Java进程和一个Python进程）
+- 运行 "assembly/bin/supersonic-daemon.sh start"启动standalone模式的Java服务
 - 在浏览器访问http://localhost:9080 开启探索
 
 ## 如何构建和部署
@@ -56,6 +64,6 @@
 
 ## 微信联系方式
 
-欢迎加入微信群反馈建议：
+欢迎关注微信公众号：
 
-<img src="./docs/images/wechat_contact.jpeg" height="40%" width="40%" align="center"/> 
+<img src="./docs/images/supersonic_wechat_oa.png" height="50%" width="50%" align="center"/> 

assembly/bin/supersonic-build.bat

@@ -1,30 +1,98 @@
 @echo off
-setlocal
+setlocal enabledelayedexpansion
+chcp 65001
 
-set "sbinDir=%~dp0"
+call supersonic-common.bat %*
-set "baseDir=%~dp0.."
+
-set "buildDir=%baseDir%\build"
+set "service=%~1"
+
+cd %projectDir%
+if "%service%"=="" (
+    set service=%standalone_service%
+)
+
+call mvn help:evaluate -Dexpression=project.version > temp.txt
+for /f "delims=" %%i in (temp.txt) do (
+    set line=%%i
+    if not "!line:~0,1!"=="[" (
+        set MVN_VERSION=!line!
+    )
+)
+del temp.txt
+cd %baseDir%
 
 
-rem 1. build semantic chat service
+if "%service%"=="%pyllm_service%" (
-del /q "%buildDir%\*.tar.gz" 2>NUL
+   echo start installing python modules required by supersonic-pyllm: %pip_path%
-
+   %pip_path% install -r %projectDir%\headless\python\requirements.txt"
-call mvn -f "%baseDir%\..\pom.xml" clean package -DskipTests
+   echo install python modules success
-
+   goto :EOF
-rem 2. move package to build
+) else if "%service%"=="webapp" (
-echo f|xcopy "%baseDir%\..\launchers\standalone\target\*.tar.gz" "%buildDir%\supersonic-standalone.tar.gz"
+   call :buildWebapp
-echo f|xcopy "%baseDir%\..\launchers\semantic\target\*.tar.gz" "%buildDir%\supersonic-semantic.tar.gz"
+   tar xvf supersonic-webapp.tar.gz
-echo f|xcopy "%baseDir%\..\launchers\chat\target\*.tar.gz" "%buildDir%\supersonic-chat.tar.gz"
+   move /y supersonic-webapp webapp
-
+   move /y webapp %projectDir%\launchers\%STANDALONE_SERVICE%\target\classes
-rem 3. build webapp
+   goto :EOF
-cd "%baseDir%\..\webapp"
+) else (
-call start-fe-prod.bat
+   call :buildJavaService
-copy /y "%baseDir%\..\webapp\supersonic-webapp.tar.gz" "%buildDir%\"
+   call :buildWebapp
+   call :packageRelease
+   goto :EOF
+)
 
 
-cd "%buildDir%"
+:buildJavaService
-tar -zxvf supersonic-webapp.tar.gz
+   set "model_name=%service%"
-move supersonic-webapp webapp
+   echo "starting building supersonic-%model_name% service"
-move webapp ..\..\launchers\standalone\target\classes
+   call mvn -f %projectDir%\launchers\%model_name% clean package -DskipTests
+   IF ERRORLEVEL 1 (
+      ECHO Failed to build backend Java modules.
+      EXIT /B 1
+   )
+   copy /y %projectDir%\launchers\%model_name%\target\*.tar.gz %buildDir%\
+   echo "finished building supersonic-%model_name% service"
+   goto :EOF
+
+
+:buildWebapp
+   echo "starting building supersonic webapp"
+   cd %projectDir%\webapp
+   call start-fe-prod.bat
+   copy /y supersonic-webapp.tar.gz %buildDir%\
+   rem check build result
+   IF ERRORLEVEL 1 (
+        ECHO Failed to build frontend webapp.
+        EXIT /B 1
+   )
+   echo "finished building supersonic webapp"
+   goto :EOF
+
+
+:packageRelease
+   set "model_name=%service%"
+   set "release_dir=supersonic-%model_name%-%MVN_VERSION%"
+   set "service_name=launchers-%model_name%-%MVN_VERSION%"
+   echo "starting packaging supersonic release"
+   cd %buildDir%
+   if exist %release_dir% rmdir /s /q %release_dir%
+   if exist %release_dir%.zip del %release_dir%.zip
+   mkdir %release_dir%
+   rem package webapp
+   tar xvf supersonic-webapp.tar.gz
+   move /y supersonic-webapp webapp
+   echo {"env": ""} > webapp\supersonic.config.json
+   move /y webapp %release_dir%
+   rem package java service
+   tar xvf %service_name%-bin.tar.gz
+   for /d %%D in ("%service_name%\*") do (
+       move "%%D" "%release_dir%"
+   )
+   rem generate zip file
+   powershell Compress-Archive -Path %release_dir% -DestinationPath %release_dir%.zip
+   del %service_name%-bin.tar.gz
+   del supersonic-webapp.tar.gz
+   rmdir /s /q %service_name%
+   echo "finished packaging supersonic release"
+   goto :EOF
 
 endlocal

assembly/bin/supersonic-build.sh

@@ -1,29 +1,80 @@
 #!/usr/bin/env bash
 
 sbinDir=$(cd "$(dirname "$0")"; pwd)
-baseDir=$(cd "$sbinDir/.." && pwd -P)
+chmod +x $sbinDir/supersonic-common.sh
-runtimeDir=$baseDir/runtime
+source $sbinDir/supersonic-common.sh
-buildDir=$baseDir/build
+cd $projectDir
+MVN_VERSION=$(mvn help:evaluate -Dexpression=project.version | grep -e '^[^\[]')
 
 cd $baseDir
+service=$1
+if [ -z "$service"  ]; then
+  service=${STANDALONE_SERVICE}
+fi
 
-#1. build semantic chat service
+function buildJavaService {
-rm -fr ${buildDir}/*.tar.gz
+  model_name=$1
-rm -fr dist
+  echo "starting building supersonic-${model_name} service"
+  mvn -f $projectDir clean package -DskipTests
+  if [ $? -ne 0 ]; then
+      echo "Failed to build backend Java modules."
+      exit 1
+  fi
+  cp $projectDir/launchers/${model_name}/target/*.tar.gz ${buildDir}/
+  echo "finished building supersonic-${model_name} service"
+}
 
-mvn -f $baseDir/../ clean package -DskipTests
+function buildWebapp {
+  echo "starting building supersonic webapp"
+  chmod +x $projectDir/webapp/start-fe-prod.sh
+  cd $projectDir/webapp
+  sh ./start-fe-prod.sh
+  cp -fr  ./supersonic-webapp.tar.gz ${buildDir}/
+  # check build result
+  if [ $? -ne 0 ]; then
+      echo "Failed to build frontend webapp."
+      exit 1
+  fi
+  echo "finished building supersonic webapp"
+}
 
-#2. move package to build
+function packageRelease {
-cp $baseDir/../launchers/standalone/target/*.tar.gz ${buildDir}/supersonic.tar.gz
+  model_name=$1
+  release_dir=supersonic-${model_name}-${MVN_VERSION}
+  service_name=launchers-${model_name}-${MVN_VERSION}
+  echo "starting packaging supersonic release"
+  cd $buildDir
+  mkdir $release_dir
+  # package webapp
+  tar xvf supersonic-webapp.tar.gz
+  mv supersonic-webapp webapp
+  json='{"env": "''"}'
+  echo $json > webapp/supersonic.config.json
+  mv webapp $release_dir/
+  # package java service
+  tar xvf $service_name-bin.tar.gz
+  mv $service_name/* $release_dir/
+  # generate zip file
+  zip -r $release_dir.zip $release_dir
+  # delete intermediate files
+  rm supersonic-webapp.tar.gz $service_name-bin.tar.gz
+  rm -rf webapp $service_name $release_dir
+  echo "finished packaging supersonic release"
+}
 
-#3. build webapp
+#1. build backend services
-chmod +x $baseDir/../webapp/start-fe-prod.sh
+if [ "$service" == $PYLLM_SERVICE ]; then
-cd ../webapp
+  echo "start installing python modules required by supersonic-pyllm: ${pip_path}"
-sh ./start-fe-prod.sh
+  requirementPath=$projectDir/headless/python/requirements.txt
-cp -fr  ./supersonic-webapp.tar.gz ${buildDir}/
+  ${pip_path} install -r ${requirementPath}
-
+  echo "install python modules success"
-
+elif [ "$service" == "webapp" ]; then
-cd $buildDir
+  buildWebapp
-tar xvf supersonic-webapp.tar.gz
+  target_path=$projectDir/launchers/$STANDALONE_SERVICE/target/classes
-mv supersonic-webapp webapp
+  tar xvf $projectDir/webapp/supersonic-webapp.tar.gz -C $target_path
-mv webapp ../../launchers/standalone/target/classes
+  mv $target_path/supersonic-webapp $target_path/webapp
+else
+  buildJavaService $service
+  buildWebapp
+  packageRelease $service
+fi

assembly/bin/supersonic-common.bat

@@ -0,0 +1,9 @@
+set "sbinDir=%~dp0"
+set "baseDir=%~dp0.."
+set "buildDir=%baseDir%\build"
+set "main_class=com.tencent.supersonic.StandaloneLauncher"
+set "python_path=python"
+set "pip_path=pip3"
+set "standalone_service=standalone"
+set "pyllm_service=pyllm"
+set "projectDir=%baseDir%\.."

assembly/bin/supersonic-common.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+# environment parameters
+python_path=${PYTHON_PATH:-"python3"}
+pip_path=${PIP_PATH:-"pip3"}
+
+sbinDir=$(cd "$(dirname "$0")"; pwd)
+baseDir=$(cd "$sbinDir/.." && pwd -P)
+runtimeDir=$baseDir/runtime
+buildDir=$baseDir/build
+projectDir=$baseDir/..
+
+readonly CHAT_APP_NAME="supersonic_chat"
+readonly HEADLESS_APP_NAME="supersonic_headless"
+readonly PYLLM_APP_NAME="supersonic_pyllm"
+readonly STANDALONE_APP_NAME="supersonic_standalone"
+
+readonly CHAT_SERVICE="chat"
+readonly HEADLESS_SERVICE="headless"
+readonly PYLLM_SERVICE="pyllm"
+readonly STANDALONE_SERVICE="standalone"
+
+readonly PYLLM_HOST="127.0.0.1"
+readonly PYLLM_PORT="9092"

assembly/bin/supersonic-daemon.bat

@@ -1,120 +1,102 @@
 @echo off
 setlocal
+chcp 65001
 
-set "sbinDir=%~dp0"
+call supersonic-common.bat %*
-set "baseDir=%~dp0.."
+call %sbinDir%/../conf/supersonic-env.bat %*
-set "runtimeDir=%baseDir%\..\runtime"
-set "buildDir=%baseDir%\build"
 
 set "command=%~1"
-set "module=%~2"
+set "service=%~2"
-
+if "%service%"=="" (
-set "APP_NAME=standalone-service"
+   set "service=%standalone_service%"
-set "MAIN_CLASS=com.tencent.supersonic.StandaloneLauncher"
+)
-
+set "model_name=%service%"
-set "python_path=python"
+IF "%service%"=="pyllm" (
-set "pip_path=pip3.9"
+  set "llmProxy=PythonLLMProxy"
-set "llm_host=127.0.0.1"
+  set "model_name=%standalone_service%"
-set "llm_port=9092"
-set "start_name=api_service"
-
-set "llm_path=%baseDir%\..\chat\core\src\main\python"
-
-if "%module%"=="" (
-   set "module=standalone"
-) else if "%module%"=="semantic" (
-   set "APP_NAME=semantic-service"
-   set "MAIN_CLASS=com.tencent.supersonic.SemanticLauncher"
-) else if "%module%"=="chat" (
-   set "APP_NAME=chat-service"
-   set "MAIN_CLASS=com.tencent.supersonic.ChatLauncher"
 )
 
-if "%command%"=="" (
+cd %baseDir%
-   set "command=restart"
-)
-
-set "libDir=%runtimeDir%\supersonic-%module%\lib"
-set "confDir=%runtimeDir%\supersonic-%module%\conf"
-set "webDir=%runtimeDir%\supersonic-%module%\webapp"
-set "CLASSPATH=%confDir%;%webDir%;%libDir%\*"
-set "java-command=-Dfile.encoding=UTF-8 -Duser.language=Zh -Duser.region=CN -Duser.timezone=GMT+08 -Xms1024m -Xmx2048m -cp %CLASSPATH% %MAIN_CLASS%"
-
-
-if "%command%"=="stop" (
-    call:STOP
-    goto :EOF
-)
 
 if "%command%"=="restart" (
-     call:STOP
+   call :stop
-)
+   call :start
-
+   goto :EOF
-::1. clear file
+) else if "%command%"=="start" (
-rd /s /q "%runtimeDir%"
+   call :start
-mkdir "%runtimeDir%"
+   goto :EOF
-
+) else if "%command%"=="stop" (
-if "%module%"=="llmparser" (
+   call :stop
-   tar -zxvf "%buildDir%\supersonic-standalone.tar.gz" -C "%runtimeDir%"
+   goto :EOF
-   for /d %%f in ("%runtimeDir%\launchers-standalone-*") do (
+) else if "%command%"=="reload" (
-       move "%%f" "%runtimeDir%\supersonic-standalone"
+   call :reloadExamples
-   )
+   goto :EOF
-   cd "%runtimeDir%"
+) else (
-   "%pip_path%" install -r "%llm_path%\requirements.txt"
+   echo "Use command {start|stop|restart} to run."
-   "%python_path%" -c "import langchain,fastapi,chromadb,tiktoken,uvicorn" >nul 2>&1
-   cd "%runtimeDir%\supersonic-standalone\llm\llm"
-   start "" /B uvicorn %start_name%:app --port %llm_port% --host %llm_host%  > "%runtimeDir%\supersonic-standalone\llm\llm.log" 2>&1
-   echo "llm service started, see logs/error with logs/error command"
    goto :EOF
 )
 
-tar -zxvf "%buildDir%\supersonic-%module%.tar.gz" -C "%runtimeDir%"
-for /d %%f in ("%runtimeDir%\launchers-%module%-*") do (
-    move "%%f" "%runtimeDir%\supersonic-%module%"
-)
 
-if not exist "%runtimeDir%\supersonic-%module%\logs" mkdir "%runtimeDir%\supersonic-%module%\logs"
+: start
-
+   if "%service%"=="%pyllm_service%" (
-tar -zxvf "%buildDir%\supersonic-webapp.tar.gz" -C "%buildDir%"
+         call :runPythonService
-if not exist "%runtimeDir%\supersonic-%module%\webapp" mkdir "%runtimeDir%\supersonic-%module%\webapp"
+         call :runJavaService
-xcopy /s /e /h /y "%buildDir%\supersonic-webapp\*" "%runtimeDir%\supersonic-%module%\webapp"
+         goto :EOF
-if not exist "%runtimeDir%\supersonic-%module%\conf\webapp" mkdir "%runtimeDir%\supersonic-%module%\conf\webapp"
+   )
-xcopy /s /e /h /y "%runtimeDir%\supersonic-%module%\webapp\*" "%runtimeDir%\supersonic-%module%\conf\webapp"
+   call :runJavaService
-rd /s /q "%buildDir%\supersonic-webapp"
+   goto :EOF
-
-::3. start service
-::start standalone service
-if "%command%"=="start" (
-    call:START
-    goto :EOF
-)
-
-if "%command%"=="restart" (
-    call:START
-    goto :EOF
-)
-
-:START
-    if "%module%"=="standalone" (
-          cd "%runtimeDir%"
-          "%pip_path%" install -r "%llm_path%\requirements.txt"
-          "%python_path%" -c "import langchain,fastapi,chromadb,tiktoken,uvicorn" >nul 2>&1
-          cd "%runtimeDir%\supersonic-standalone\llm\llm"
-          start "" /B uvicorn %start_name%:app --port %llm_port% --host %llm_host%  > "%runtimeDir%\supersonic-standalone\llm\llm.log" 2>&1
-          echo "llm service started, see logs/error with logs/error command"
-    )
-    start "supersonic" /B java %java-command%>"%runtimeDir%\supersonic-%module%\logs\info-%module%.log" 2>&1
-    echo "%module% service started, see logs/error with logs/error command"
-    goto :EOF
 
 
-:STOP
+: stop
-    for /f "tokens=2" %%i in ('tasklist ^| findstr /i "python"') do (
+   call :stopPythonService
-                     taskkill /PID %%i /F
+   call :stopJavaService
-                     echo "llm Process (PID = %%i) is killed."
+   goto :EOF
-    )
+
-    for /f "tokens=2" %%i in ('tasklist ^| findstr /i "java"') do (
+
-                taskkill /PID %%i /F
+: reloadExamples
-                echo "%module% Process (PID = %%i) is killed."
+   set "pythonRunDir=%baseDir%\pyllm"
-    )
+   cd "%pythonRunDir%\sql"
-    goto :EOF
+   start  %python_path% examples_reload_run.py
+   goto :EOF
+
+
+: runJavaService
+   echo 'java service starting, see logs in logs/'
+   set "libDir=%baseDir%\lib"
+   set "confDir=%baseDir%\conf"
+   set "webDir=%baseDir%\webapp"
+   set "logDir=%baseDir%\logs"
+   set "classpath=%baseDir%;%webDir%;%libDir%\*;%confDir%"
+   set "java-command=-Dfile.encoding=UTF-8 -Duser.language=Zh -Duser.region=CN -Duser.timezone=GMT+08 -Xms1024m -Xmx2048m -cp %CLASSPATH% %MAIN_CLASS%"
+   if not exist %logDir% mkdir %logDir%
+   start /B java %java-command% >nul 2>&1
+   timeout /t 10 >nul
+   echo 'java service started'
+   goto :EOF
+
+
+: runPythonService
+   echo 'python service starting, see logs in pyllm\pyllm.log'
+   set "pythonRunDir=%baseDir%\pyllm"
+   start /B %python_path% %pythonRunDir%\supersonic_pyllm.py  > %pythonRunDir%\pyllm.log 2>&1
+   timeout /t 10 >nul
+   echo 'python service started'
+   goto :EOF
+
+
+: stopPythonService
+   for /f "tokens=2" %%i in ('tasklist ^| findstr /i "python"') do (
+           taskkill /PID %%i /F
+           echo "python service (PID = %%i) is killed."
+   )
+   goto :EOF
+
+
+: stopJavaService
+   for /f "tokens=2" %%i in ('tasklist ^| findstr /i "java"') do (
+            taskkill /PID %%i /F
+            echo "java service (PID = %%i) is killed."
+   )
+   goto :EOF
+
+endlocal

assembly/bin/supersonic-daemon.sh

@@ -1,98 +1,180 @@
 #!/usr/bin/env bash
 
 sbinDir=$(cd "$(dirname "$0")"; pwd)
-baseDir=$(cd "$sbinDir/.." && pwd -P)
+source $sbinDir/supersonic-common.sh
-runtimeDir=$baseDir/../runtime
+
-buildDir=$baseDir/build
+set -a
+source $sbinDir/../conf/supersonic-env.sh
+set +a
 
 command=$1
 service=$2
+if [ -z "$service"  ]; then
+  service=${STANDALONE_SERVICE}
+fi
 
+model_name=$service
+if [ "$service" == "pyllm" ]; then
+  model_name=${STANDALONE_SERVICE}
+  export llmProxy=PythonLLMProxy
+fi
 cd $baseDir
-if [[ "$service" == "semantic" || -z "$service"  ]] && [ "$command" != "stop"  ]; then
-   #1. clear file
-   mkdir -p ${runtimeDir}
-   rm -fr ${runtimeDir}/*
 
-   #2. package lib
+function setMainClass {
-   tar -zxvf ${buildDir}/supersonic.tar.gz  -C ${runtimeDir}
+  if [ "$service" == $CHAT_SERVICE ]; then
-   mv ${runtimeDir}/launchers-standalone-* ${runtimeDir}/supersonic-standalone
+    main_class="com.tencent.supersonic.ChatLauncher"
-   tar -zxvf ${buildDir}/supersonic-webapp.tar.gz  -C ${buildDir}
+  elif [ "$service" == $HEADLESS_SERVICE ]; then
-   mkdir -p ${runtimeDir}/supersonic-standalone/webapp
+    main_class="com.tencent.supersonic.HeadlessLauncher"
-   cp -fr  ${buildDir}/supersonic-webapp/* ${runtimeDir}/supersonic-standalone/webapp
+  else
-   rm -fr  ${buildDir}/supersonic-webapp
+    main_class="com.tencent.supersonic.StandaloneLauncher"
-fi
+  fi
-if [[ "$service" == "semantic"  ]]; then
+}
-   json=$(cat ${runtimeDir}/supersonic-semantic/webapp/supersonic.config.json)
-   json=$(echo $json | jq '.env="semantic"')
-   echo $json > ${runtimeDir}/supersonic-semantic/webapp/supersonic.config.json
-fi
 
-if [[ "$service" == "chat"  ]]; then
+function setAppName {
-   json=$(cat ${runtimeDir}/supersonic-chat/webapp/supersonic.config.json)
+  if [ "$service" == $CHAT_SERVICE ]; then
-   json=$(echo $json | jq '.env="chat"')
+    app_name=$CHAT_APP_NAME
-   echo $json > ${runtimeDir}/supersonic-chat/webapp/supersonic.config.json
+  elif [ "$service" == $HEADLESS_SERVICE ]; then
-fi
+    app_name=$HEADLESS_APP_NAME
-echo $command
+  else
-echo $service
+    app_name=$STANDALONE_APP_NAME
+  fi
+}
+
+function reloadExamples {
+  cd $baseDir/pyllm/sql
+  ${python_path} examples_reload_run.py
+}
+
+function runJavaService {
+  javaRunDir=$baseDir
+  local_app_name=$1
+  libDir=$baseDir/lib
+  confDir=$baseDir/conf
+
+  CLASSPATH=""
+  CLASSPATH=$CLASSPATH:$confDir
+
+  for jarPath in $libDir/*.jar; do
+   CLASSPATH=$CLASSPATH:$jarPath
+  done
+
+  export CLASSPATH
+  export LANG="zh_CN.UTF-8"
+
+  cd $javaRunDir
+  if [[ "$JAVA_HOME" == "" ]]; then
+    JAVA_HOME=$(ls /usr/jdk64/jdk* -d 2>/dev/null | xargs | awk '{print "'$local_app_name'"}')
+  fi
+  export PATH=$JAVA_HOME/bin:$PATH
+  command="-Dfile.encoding="UTF-8"  -Duser.language="Zh" -Duser.region="CN" -Duser.timezone="GMT+08" -Dapp_name=${local_app_name} -Xms1024m -Xmx2048m "$main_class
+
+  mkdir -p $javaRunDir/logs
+  if [[ "$is_test" == "true" ]]; then
+    java -Dspring.profiles.active="dev" $command >/dev/null 2>$javaRunDir/logs/error.log &
+  else
+    java  $command $javaRunDir >/dev/null 2>$javaRunDir/logs/error.log &
+  fi
+}
+
+function runPythonService {
+  pythonRunDir=$baseDir/pyllm
+  cd $pythonRunDir
+  nohup ${python_path} supersonic_pyllm.py  > $pythonRunDir/pyllm.log  2>&1   &
+  # add health check
+  for i in {1..10}
+  do
+    echo "pyllm health check attempt $i..."
+    response=$(curl -s http://${PYLLM_HOST}:${PYLLM_PORT}/health)
+    echo "pyllm health check response: $response"
+    status_ok="Healthy"
+    if [[ $response == *$status_ok* ]] ; then
+      echo "pyllm Health check passed."
+      break
+    else
+      if [ "$i" -eq 10 ]; then
+        echo "pyllm Health check failed after 10 attempts."
+        echo "May still downloading model files. Please check pyllm.log in runtime directory."
+      fi
+      echo "Retrying after 5 seconds..."
+      sleep 5
+    fi
+  done
+}
+
+function start()
+{
+  local_app_name=$1
+  pid=$(ps aux |grep ${local_app_name} | grep -v grep | awk '{print $2}')
+  if [[ "$pid" == "" ]]; then
+    if [[ ${local_app_name} == $PYLLM_APP_NAME ]]; then
+      runPythonService ${local_app_name}
+    else
+      runJavaService ${local_app_name}
+    fi
+  else
+    echo "Process (PID = $pid) is running."
+    return 1
+  fi
+}
+
+function stop()
+{
+  pid=$(ps aux | grep $1 | grep -v grep | awk '{print $2}')
+  if [[ "$pid" == "" ]]; then
+    echo "Process $1 is not running !"
+    return 1
+  else
+    kill -9 $pid
+    echo "Process (PID = $pid) is killed !"
+    return 0
+  fi
+}
+
+function reload()
+{
+  if [[ $1 == $PYLLM_APP_NAME ]]; then
+    reloadExamples
+  fi
+}
+
+setMainClass
+setAppName
 case "$command" in
   start)
-        if [[ "$service" == "semantic"  ]];then
+        if [ "$service" == $PYLLM_SERVICE ]; then
-          echo -e "Starting semantic"
+          echo  "Starting $PYLLM_APP_NAME"
-          sh ${runtimeDir}/supersonic-semantic/bin/service.sh start
+          start $PYLLM_APP_NAME
-        elif [[ "$service" == "chat"  ]];then
-          echo -e "Starting chat"
-          sh ${runtimeDir}/supersonic-chat/bin/service.sh start
-        elif [[ "$service" == "llmparser"  ]];then
-          echo -e "Starting LLM"
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh  start
-        elif [[ -z "$service"  ]]; then
-          echo -e "Starting supersonic"
-          sh ${runtimeDir}/supersonic-standalone/bin/service.sh start
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh start
-        else
-          echo "Use command {semantic|semantic||} to run."
         fi
+        echo  "Starting ${app_name}"
+        start ${app_name}
+        echo  "Start success"
         ;;
   stop)
-        if [[ "$service" == "semantic"  ]];then
+        echo  "Stopping $app_name"
-          echo -e "Stopping semantic"
+        stop $app_name
-          sh ${runtimeDir}/supersonic-semantic/bin/service.sh stop
+        echo  "Stopping $PYLLM_APP_NAME"
-        elif [[ "$service" == "chat"  ]];then
+        stop $PYLLM_APP_NAME
-          echo -e "Stopping chat"
+        echo  "Stop success"
-          sh ${runtimeDir}/supersonic-chat/bin/service.sh stop
+        ;;
-        elif [[ "$service" == "llmparser"  ]];then
+  reload)
-          echo -e "Stopping LLM"
+        echo  "Reloading ${app_name}"
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh  stop
+        reload ${app_name}
-        elif [[ -z "$service"  ]]; then
+        echo  "Reload success"
-          echo -e "Stopping supersonic"
-          sh ${runtimeDir}/supersonic-standalone/bin/service.sh stop
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh stop
-        else
-          echo "Use command {semantic|semantic||} to run."
-        fi
         ;;
   restart)
-        if [[ "$service" == "semantic"  ]];then
+        if [ "$service" == $PYLLM_SERVICE ]; then
-          echo -e "Restarting semantic"
+          echo  "Stopping $PYLLM_APP_NAME"
-          sh ${runtimeDir}/supersonic-semantic/bin/service.sh restart
+          stop $PYLLM_APP_NAME
-        elif [[ "$service" == "chat"  ]];then
+          echo  "Starting $PYLLM_APP_NAME"
-          echo -e "Restarting chat"
+          start $PYLLM_APP_NAME
-          sh ${runtimeDir}/supersonic-chat/bin/service.sh restart
-        elif [[ "$service" == "llmparser"  ]];then
-          echo -e "Restarting LLM"
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh  restart
-        elif [[ -z "$service"  ]]; then
-          echo -e "Restarting supersonic"
-          sh ${runtimeDir}/supersonic-standalone/bin/service.sh restart
-          sh ${runtimeDir}/supersonic-standalone/llm/bin/service.sh restart
-        else
-          echo "Use command {semantic|semantic||} to run."
         fi
+        echo  "Stopping ${app_name}"
+        stop ${app_name}
+        echo  "Starting ${app_name}"
+        start ${app_name}
+        echo  "Restart success"
         ;;
   *)
-        echo "Use command {start|stop|status|restart} to run."
+        echo "Use command {start|stop|restart} to run."
         exit 1
 esac
-
-exit 0

assembly/build/build.xml

@@ -6,14 +6,6 @@
         <format>tar.gz</format>
     </formats>
     <fileSets>
-
-        <fileSet>
-            <directory>${project.basedir}/src/main/bin</directory>
-            <outputDirectory>bin</outputDirectory>
-            <fileMode>0777</fileMode>
-            <directoryMode>0755</directoryMode>
-        </fileSet>
-
         <fileSet>
             <directory>${project.basedir}/src/main/resources</directory>
             <outputDirectory>conf</outputDirectory>
@@ -29,8 +21,14 @@
             </includes>
         </fileSet>
         <fileSet>
-            <directory>${project.basedir}/../../chat/core/src/main/python</directory>
+            <directory>${project.basedir}/../../headless/python</directory>
-            <outputDirectory>llm</outputDirectory>
+            <outputDirectory>pyllm</outputDirectory>
+            <fileMode>0777</fileMode>
+            <directoryMode>0755</directoryMode>
+        </fileSet>
+        <fileSet>
+            <directory>${project.basedir}/../../assembly/bin</directory>
+            <outputDirectory>bin</outputDirectory>
             <fileMode>0777</fileMode>
             <directoryMode>0755</directoryMode>
         </fileSet>

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/adaptor/UserAdaptor.java

@@ -7,6 +7,9 @@ import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 import java.util.List;
 import java.util.Set;
 
+/**
+ * UserAdaptor defines some interfaces for obtaining user and organization information
+ */
 public interface UserAdaptor {
 
     List<String> getUserNames();

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/config/AuthenticationConfig.java

@@ -24,4 +24,13 @@ public class AuthenticationConfig {
     @Value("${authentication.token.http.header.key:Authorization}")
     private String tokenHttpHeaderKey;
 
+    @Value("${authentication.app.appId:appId}")
+    private String appId;
+
+    @Value("${authentication.app.timestamp:timestamp}")
+    private String timestamp;
+
+    @Value("${authentication.app.signature:signature}")
+    private String signature;
+
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/constant/UserConstants.java

@@ -12,6 +12,8 @@ public class UserConstants {
 
     public static final String TOKEN_USER_EMAIL = "token_user_email";
 
+    public static final String TOKEN_IS_ADMIN = "token_is_admin";
+
     public static final String TOKEN_ALGORITHM = "HS512";
 
     public static final String TOKEN_CREATE_TIME = "token_create_time";

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/pojo/Organization.java

@@ -1,11 +1,15 @@
 package com.tencent.supersonic.auth.api.authentication.pojo;
 
 import com.google.common.collect.Lists;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.util.List;
 
 @Data
+@AllArgsConstructor
+@NoArgsConstructor
 public class Organization {
 
     private String id;

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/pojo/User.java

@@ -18,17 +18,31 @@ public class User {
 
     private String email;
 
-    public static User get(Long id, String name, String displayName, String email) {
+    private Integer isAdmin;
-        return new User(id, name, displayName, email);
+
+    public static User get(Long id, String name, String displayName, String email, Integer isAdmin) {
+        return new User(id, name, displayName, email, isAdmin);
+    }
+
+    public static User get(Long id, String name) {
+        return new User(id, name, name, name, 0);
     }
 
     public static User getFakeUser() {
-        return new User(1L, "admin", "admin", "admin@email");
+        return new User(1L, "admin", "admin", "admin@email", 1);
+    }
+
+    public static User getAppUser(int appId) {
+        String name = String.format("app_%s", appId);
+        return new User(1L, name, name, "", 1);
     }
 
     public String getDisplayName() {
         return StringUtils.isBlank(displayName) ? name : displayName;
     }
 
+    public boolean isSuperAdmin() {
+        return isAdmin != null && isAdmin == 1;
+    }
 
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/pojo/UserWithPassword.java

@@ -9,13 +9,14 @@ public class UserWithPassword extends User {
 
     private String password;
 
-    public UserWithPassword(Long id, String name, String displayName, String email, String password) {
+    public UserWithPassword(Long id, String name, String displayName, String email, String password, Integer isAdmin) {
-        super(id, name, displayName, email);
+        super(id, name, displayName, email, isAdmin);
         this.password = password;
     }
 
-    public static UserWithPassword get(Long id, String name, String displayName, String email, String password) {
+    public static UserWithPassword get(Long id, String name, String displayName,
-        return new UserWithPassword(id, name, displayName, email, password);
+                                       String email, String password, Integer isAdmin) {
+        return new UserWithPassword(id, name, displayName, email, password, isAdmin);
     }
 
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/service/UserService.java

@@ -4,11 +4,15 @@ import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import java.util.List;
 import java.util.Set;
 
 public interface UserService {
 
+    User getCurrentUser(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse);
+
     List<String> getUserNames();
 
     List<User> getUserList();

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/utils/UserHolder.java

@@ -2,6 +2,11 @@ package com.tencent.supersonic.auth.api.authentication.utils;
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.service.UserStrategy;
+import com.tencent.supersonic.common.pojo.SystemConfig;
+import com.tencent.supersonic.common.service.SystemConfigService;
+import com.tencent.supersonic.common.util.ContextUtils;
+import org.springframework.util.CollectionUtils;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
@@ -14,7 +19,14 @@ public final class UserHolder {
     }
 
     public static User findUser(HttpServletRequest request, HttpServletResponse response) {
-        return REPO.findUser(request, response);
+        User user = REPO.findUser(request, response);
+        SystemConfigService sysParameterService = ContextUtils.getBean(SystemConfigService.class);
+        SystemConfig systemConfig = sysParameterService.getSystemConfig();
+        if (!CollectionUtils.isEmpty(systemConfig.getAdmins())
+                && systemConfig.getAdmins().contains(user.getName())) {
+            user.setIsAdmin(1);
+        }
+        return user;
     }
 
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthGroup.java

@@ -6,7 +6,7 @@ import lombok.Data;
 @Data
 public class AuthGroup {
 
-    private String modelId;
+    private Long modelId;
     private String name;
     private Integer groupId;
     private List<AuthRule> authRules;

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthRes.java

@@ -7,13 +7,13 @@ import lombok.ToString;
 @ToString
 public class AuthRes {
 
-    private String modelId;
+    private Long modelId;
     private String name;
 
     public AuthRes() {
     }
 
-    public AuthRes(String modelId, String name) {
+    public AuthRes(Long modelId, String name) {
         this.modelId = modelId;
         this.name = name;
     }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/request/QueryAuthResReq.java

@@ -1,11 +1,13 @@
 package com.tencent.supersonic.auth.api.authorization.request;
 
+import com.google.common.collect.Lists;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
-import java.util.ArrayList;
-import java.util.List;
-
 import lombok.Data;
 import lombok.ToString;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
 
 @Data
 @ToString
@@ -15,5 +17,17 @@ public class QueryAuthResReq {
 
     private List<AuthRes> resources;
 
-    private String modelId;
+    private Long modelId;
+
+    private List<Long> modelIds;
+
+    public List<Long> getModelIds() {
+        if (!CollectionUtils.isEmpty(modelIds)) {
+            return modelIds;
+        }
+        if (modelId != null) {
+            return Lists.newArrayList(modelId);
+        }
+        return Lists.newArrayList();
+    }
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/service/AuthService.java

@@ -10,7 +10,7 @@ public interface AuthService {
 
     List<AuthGroup> queryAuthGroups(String domainId, Integer groupId);
 
-    void updateAuthGroup(AuthGroup group);
+    void addOrUpdateAuthGroup(AuthGroup group);
 
     void removeAuthGroup(AuthGroup group);
 

auth/authentication/pom.xml

@@ -33,12 +33,6 @@
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis</artifactId>
-        </dependency>
-
-
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
@@ -52,12 +46,7 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
-        <dependency>
+
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis-spring</artifactId>
-            <version>${mybatis-spring.version}</version>
-            <scope>compile</scope>
-        </dependency>
         <dependency>
             <groupId>com.github.pagehelper</groupId>
             <artifactId>pagehelper</artifactId>

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/adaptor/DefaultUserAdaptor.java

@@ -16,6 +16,9 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+/**
+ * DefaultUserAdaptor provides a default method to obtain user and organization information
+ */
 public class DefaultUserAdaptor implements UserAdaptor {
 
     private List<UserDO> getUserDOList() {
@@ -41,7 +44,17 @@ public class DefaultUserAdaptor implements UserAdaptor {
 
     @Override
     public List<Organization> getOrganizationTree() {
-        return Lists.newArrayList();
+        Organization superSonic = new Organization("1", "0",
+                "SuperSonic", "SuperSonic", Lists.newArrayList(), true);
+        Organization hr = new Organization("2", "1",
+                "Hr", "SuperSonic/Hr", Lists.newArrayList(), false);
+        Organization sales = new Organization("3", "1",
+                "Sales", "SuperSonic/Sales", Lists.newArrayList(), false);
+        Organization marketing = new Organization("4", "1",
+                "Marketing", "SuperSonic/Marketing", Lists.newArrayList(), false);
+        List<Organization> subOrganization = Lists.newArrayList(hr, sales, marketing);
+        superSonic.setSubOrganizations(subOrganization);
+        return Lists.newArrayList(superSonic);
     }
 
     private User convert(UserDO userDO) {
@@ -71,7 +84,7 @@ public class DefaultUserAdaptor implements UserAdaptor {
         }
         if (userDO.getPassword().equals(userReq.getPassword())) {
             UserWithPassword user = UserWithPassword.get(userDO.getId(), userDO.getName(), userDO.getDisplayName(),
-                    userDO.getEmail(), userDO.getPassword());
+                    userDO.getEmail(), userDO.getPassword(), userDO.getIsAdmin());
             return userTokenUtils.generateToken(user);
         }
         throw new RuntimeException("password not correct, please try again");

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/AuthenticationInterceptor.java

@@ -5,16 +5,17 @@ import com.tencent.supersonic.auth.api.authentication.constant.UserConstants;
 import com.tencent.supersonic.auth.authentication.service.UserServiceImpl;
 import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
 import com.tencent.supersonic.common.util.S2ThreadContext;
-import java.lang.reflect.Field;
-import java.util.Arrays;
-import java.util.List;
-import javax.servlet.http.HttpServletRequest;
 import org.apache.catalina.connector.RequestFacade;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.util.Strings;
 import org.apache.tomcat.util.http.MimeHeaders;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.multipart.support.StandardMultipartHttpServletRequest;
 import org.springframework.web.servlet.HandlerInterceptor;
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.List;
 
 
 public abstract class AuthenticationInterceptor implements HandlerInterceptor {
@@ -29,7 +30,6 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
 
     protected S2ThreadContext s2ThreadContext;
 
-
     protected boolean isExcludedUri(String uri) {
         String excludePathStr = authenticationConfig.getExcludePath();
         if (Strings.isEmpty(excludePathStr)) {
@@ -59,6 +59,10 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
         return "true".equalsIgnoreCase(internal);
     }
 
+    protected boolean isAppRequest(HttpServletRequest request) {
+        String appId = request.getHeader(authenticationConfig.getAppId());
+        return StringUtils.isNotBlank(appId);
+    }
 
     protected void reflectSetparam(HttpServletRequest request, String key, String value) {
         try {

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/DefaultAuthenticationInterceptor.java

@@ -10,12 +10,12 @@ import com.tencent.supersonic.common.pojo.exception.AccessException;
 import com.tencent.supersonic.common.util.ContextUtils;
 import com.tencent.supersonic.common.util.S2ThreadContext;
 import com.tencent.supersonic.common.util.ThreadContext;
-import java.lang.reflect.Method;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.method.HandlerMethod;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.lang.reflect.Method;
 
 @Slf4j
 public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor {
@@ -35,7 +35,10 @@ public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor
             setFakerUser(request);
             return true;
         }
-
+        if (isAppRequest(request)) {
+            setFakerUser(request);
+            return true;
+        }
         if (handler instanceof HandlerMethod) {
             HandlerMethod handlerMethod = (HandlerMethod) handler;
             Method method = handlerMethod.getMethod();
@@ -76,5 +79,4 @@ public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor
         s2ThreadContext.set(threadContext);
     }
 
-
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/dataobject/UserDO.java

@@ -1,99 +1,129 @@
 package com.tencent.supersonic.auth.authentication.persistence.dataobject;
 
 public class UserDO {
-
     /**
-     *
+     * 
      */
     private Long id;
 
     /**
-     *
+     * 
      */
     private String name;
 
     /**
-     *
+     * 
      */
     private String password;
 
     /**
-     *
+     * 
      */
     private String displayName;
 
     /**
-     *
+     * 
      */
     private String email;
 
     /**
-     * @return id
+     * 
+     */
+    private Integer isAdmin;
+
+    /**
+     * 
+     * @return id 
      */
     public Long getId() {
         return id;
     }
 
     /**
-     * @param id
+     * 
+     * @param id 
      */
     public void setId(Long id) {
         this.id = id;
     }
 
     /**
-     * @return name
+     * 
+     * @return name 
      */
     public String getName() {
         return name;
     }
 
     /**
-     * @param name
+     * 
+     * @param name 
      */
     public void setName(String name) {
         this.name = name == null ? null : name.trim();
     }
 
     /**
-     * @return password
+     * 
+     * @return password 
      */
     public String getPassword() {
         return password;
     }
 
     /**
-     * @param password
+     * 
+     * @param password 
      */
     public void setPassword(String password) {
         this.password = password == null ? null : password.trim();
     }
 
     /**
-     * @return display_name
+     * 
+     * @return display_name 
      */
     public String getDisplayName() {
         return displayName;
     }
 
     /**
-     * @param displayName
+     * 
+     * @param displayName 
      */
     public void setDisplayName(String displayName) {
         this.displayName = displayName == null ? null : displayName.trim();
     }
 
     /**
-     * @return email
+     * 
+     * @return email 
      */
     public String getEmail() {
         return email;
     }
 
     /**
-     * @param email
+     * 
+     * @param email 
      */
     public void setEmail(String email) {
         this.email = email == null ? null : email.trim();
     }
+
+    /**
+     * 
+     * @return is_admin 
+     */
+    public Integer getIsAdmin() {
+        return isAdmin;
+    }
+
+    /**
+     * 
+     * @param isAdmin 
+     */
+    public void setIsAdmin(Integer isAdmin) {
+        this.isAdmin = isAdmin;
+    }
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/dataobject/UserDOExample.java

@@ -4,7 +4,6 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class UserDOExample {
-
     /**
      * s2_user
      */
@@ -31,6 +30,7 @@ public class UserDOExample {
     protected Integer limitEnd;
 
     /**
+     *
      * @mbg.generated
      */
     public UserDOExample() {
@@ -38,13 +38,7 @@ public class UserDOExample {
     }
 
     /**
-     * @mbg.generated
+     *
-     */
-    public String getOrderByClause() {
-        return orderByClause;
-    }
-
-    /**
      * @mbg.generated
      */
     public void setOrderByClause(String orderByClause) {
@@ -52,13 +46,15 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
-    public boolean isDistinct() {
+    public String getOrderByClause() {
-        return distinct;
+        return orderByClause;
     }
 
     /**
+     *
      * @mbg.generated
      */
     public void setDistinct(boolean distinct) {
@@ -66,6 +62,15 @@ public class UserDOExample {
     }
 
     /**
+     *
+     * @mbg.generated
+     */
+    public boolean isDistinct() {
+        return distinct;
+    }
+
+    /**
+     *
      * @mbg.generated
      */
     public List<Criteria> getOredCriteria() {
@@ -73,6 +78,7 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
     public void or(Criteria criteria) {
@@ -80,6 +86,7 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
     public Criteria or() {
@@ -89,6 +96,7 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
     public Criteria createCriteria() {
@@ -100,6 +108,7 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
     protected Criteria createCriteriaInternal() {
@@ -108,6 +117,7 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
     public void clear() {
@@ -117,6 +127,15 @@ public class UserDOExample {
     }
 
     /**
+     *
+     * @mbg.generated
+     */
+    public void setLimitStart(Integer limitStart) {
+        this.limitStart=limitStart;
+    }
+
+    /**
+     *
      * @mbg.generated
      */
     public Integer getLimitStart() {
@@ -124,31 +143,25 @@ public class UserDOExample {
     }
 
     /**
+     *
      * @mbg.generated
      */
-    public void setLimitStart(Integer limitStart) {
+    public void setLimitEnd(Integer limitEnd) {
-        this.limitStart = limitStart;
+        this.limitEnd=limitEnd;
     }
 
     /**
+     *
      * @mbg.generated
      */
     public Integer getLimitEnd() {
         return limitEnd;
     }
 
-    /**
-     * @mbg.generated
-     */
-    public void setLimitEnd(Integer limitEnd) {
-        this.limitEnd = limitEnd;
-    }
-
     /**
      * s2_user null
      */
     protected abstract static class GeneratedCriteria {
-
         protected List<Criterion> criteria;
 
         protected GeneratedCriteria() {
@@ -528,6 +541,66 @@ public class UserDOExample {
             addCriterion("email not between", value1, value2, "email");
             return (Criteria) this;
         }
+
+        public Criteria andIsAdminIsNull() {
+            addCriterion("is_admin is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminIsNotNull() {
+            addCriterion("is_admin is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminEqualTo(Integer value) {
+            addCriterion("is_admin =", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminNotEqualTo(Integer value) {
+            addCriterion("is_admin <>", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminGreaterThan(Integer value) {
+            addCriterion("is_admin >", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminGreaterThanOrEqualTo(Integer value) {
+            addCriterion("is_admin >=", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminLessThan(Integer value) {
+            addCriterion("is_admin <", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminLessThanOrEqualTo(Integer value) {
+            addCriterion("is_admin <=", value, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminIn(List<Integer> values) {
+            addCriterion("is_admin in", values, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminNotIn(List<Integer> values) {
+            addCriterion("is_admin not in", values, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminBetween(Integer value1, Integer value2) {
+            addCriterion("is_admin between", value1, value2, "isAdmin");
+            return (Criteria) this;
+        }
+
+        public Criteria andIsAdminNotBetween(Integer value1, Integer value2) {
+            addCriterion("is_admin not between", value1, value2, "isAdmin");
+            return (Criteria) this;
+        }
     }
 
     /**
@@ -544,7 +617,6 @@ public class UserDOExample {
      * s2_user null
      */
     public static class Criterion {
-
         private String condition;
 
         private Object value;
@@ -561,6 +633,38 @@ public class UserDOExample {
 
         private String typeHandler;
 
+        public String getCondition() {
+            return condition;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Object getSecondValue() {
+            return secondValue;
+        }
+
+        public boolean isNoValue() {
+            return noValue;
+        }
+
+        public boolean isSingleValue() {
+            return singleValue;
+        }
+
+        public boolean isBetweenValue() {
+            return betweenValue;
+        }
+
+        public boolean isListValue() {
+            return listValue;
+        }
+
+        public String getTypeHandler() {
+            return typeHandler;
+        }
+
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -596,37 +700,5 @@ public class UserDOExample {
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
-
-        public String getCondition() {
-            return condition;
-        }
-
-        public Object getValue() {
-            return value;
-        }
-
-        public Object getSecondValue() {
-            return secondValue;
-        }
-
-        public boolean isNoValue() {
-            return noValue;
-        }
-
-        public boolean isSingleValue() {
-            return singleValue;
-        }
-
-        public boolean isBetweenValue() {
-            return betweenValue;
-        }
-
-        public boolean isListValue() {
-            return listValue;
-        }
-
-        public String getTypeHandler() {
-            return typeHandler;
-        }
     }
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/repository/Impl/UserRepositoryImpl.java

@@ -20,7 +20,6 @@ public class UserRepositoryImpl implements UserRepository {
         this.userDOMapper = userDOMapper;
     }
 
-
     @Override
     public List<UserDO> getUserList() {
         return userDOMapper.selectByExample(new UserDOExample());
@@ -40,5 +39,4 @@ public class UserRepositoryImpl implements UserRepository {
         return userDOOptional.orElse(null);
     }
 
-
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/rest/UserController.java

@@ -5,18 +5,18 @@ import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 import com.tencent.supersonic.auth.api.authentication.service.UserService;
-import com.tencent.supersonic.auth.api.authentication.utils.UserHolder;
-import java.util.List;
-import java.util.Set;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.List;
+import java.util.Set;
 
 @RestController
 @RequestMapping("/api/auth/user")
@@ -29,10 +29,9 @@ public class UserController {
         this.userService = userService;
     }
 
-
     @GetMapping("/getCurrentUser")
     public User getCurrentUser(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
-        return UserHolder.findUser(httpServletRequest, httpServletResponse);
+        return userService.getCurrentUser(httpServletRequest, httpServletResponse);
     }
 
     @GetMapping("/getUserNames")
@@ -70,5 +69,4 @@ public class UserController {
         return userService.login(userCmd);
     }
 
-
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/service/UserServiceImpl.java

@@ -4,15 +4,38 @@ import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 import com.tencent.supersonic.auth.api.authentication.service.UserService;
+import com.tencent.supersonic.auth.api.authentication.utils.UserHolder;
 import com.tencent.supersonic.auth.authentication.utils.ComponentFactory;
+import com.tencent.supersonic.common.pojo.SystemConfig;
+import com.tencent.supersonic.common.service.SystemConfigService;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import java.util.List;
 import java.util.Set;
 
-import org.springframework.stereotype.Service;
-
 @Service
 public class UserServiceImpl implements UserService {
 
+    private SystemConfigService sysParameterService;
+
+    public UserServiceImpl(SystemConfigService sysParameterService) {
+        this.sysParameterService = sysParameterService;
+    }
+
+    @Override
+    public User getCurrentUser(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
+        User user = UserHolder.findUser(httpServletRequest, httpServletResponse);
+        if (user != null) {
+            SystemConfig systemConfig = sysParameterService.getSystemConfig();
+            if (!CollectionUtils.isEmpty(systemConfig.getAdmins())
+                    && systemConfig.getAdmins().contains(user.getName())) {
+                user.setIsAdmin(1);
+            }
+        }
+        return user;
+    }
 
     @Override
     public List<String> getUserNames() {

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/strategy/FakeUserStrategy.java

@@ -20,5 +20,4 @@ public class FakeUserStrategy implements UserStrategy {
         return User.getFakeUser();
     }
 
-
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/utils/UserTokenUtils.java

@@ -2,6 +2,7 @@ package com.tencent.supersonic.auth.authentication.utils;
 
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_ALGORITHM;
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_CREATE_TIME;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_IS_ADMIN;
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_PREFIX;
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_TIME_OUT;
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_DISPLAY_NAME;
@@ -42,6 +43,7 @@ public class UserTokenUtils {
         claims.put(TOKEN_USER_PASSWORD, StringUtils.isEmpty(user.getPassword()) ? "" : user.getPassword());
         claims.put(TOKEN_USER_DISPLAY_NAME, user.getDisplayName());
         claims.put(TOKEN_CREATE_TIME, System.currentTimeMillis());
+        claims.put(TOKEN_IS_ADMIN, user.getIsAdmin());
         return generate(claims);
     }
 
@@ -52,10 +54,10 @@ public class UserTokenUtils {
         claims.put(TOKEN_USER_PASSWORD, "admin");
         claims.put(TOKEN_USER_DISPLAY_NAME, "admin");
         claims.put(TOKEN_CREATE_TIME, System.currentTimeMillis());
+        claims.put(TOKEN_IS_ADMIN, 1);
         return generate(claims);
     }
 
-
     public User getUser(HttpServletRequest request) {
         String token = request.getHeader(authenticationConfig.getTokenHttpHeaderKey());
         final Claims claims = getClaims(token);
@@ -63,7 +65,9 @@ public class UserTokenUtils {
         String userName = String.valueOf(claims.get(TOKEN_USER_NAME));
         String email = String.valueOf(claims.get(TOKEN_USER_EMAIL));
         String displayName = String.valueOf(claims.get(TOKEN_USER_DISPLAY_NAME));
-        return User.get(userId, userName, displayName, email);
+        Integer isAdmin = claims.get(TOKEN_IS_ADMIN) == null
+                ? 0 : Integer.parseInt(claims.get(TOKEN_IS_ADMIN).toString());
+        return User.get(userId, userName, displayName, email, isAdmin);
     }
 
     public UserWithPassword getUserWithPassword(HttpServletRequest request) {
@@ -79,7 +83,9 @@ public class UserTokenUtils {
         String email = String.valueOf(claims.get(TOKEN_USER_EMAIL));
         String displayName = String.valueOf(claims.get(TOKEN_USER_DISPLAY_NAME));
         String password = String.valueOf(claims.get(TOKEN_USER_PASSWORD));
-        return UserWithPassword.get(userId, userName, displayName, email, password);
+        Integer isAdmin = claims.get(TOKEN_IS_ADMIN) == null
+                ? 0 : Integer.parseInt(claims.get(TOKEN_IS_ADMIN).toString());
+        return UserWithPassword.get(userId, userName, displayName, email, password, isAdmin);
     }
 
     private Claims getClaims(String token) {
@@ -113,5 +119,4 @@ public class UserTokenUtils {
                 .compact();
     }
 
-
 }

auth/authentication/src/main/resources/mapper/UserDOMapper.xml

@@ -2,11 +2,12 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.tencent.supersonic.auth.authentication.persistence.mapper.UserDOMapper">
   <resultMap id="BaseResultMap" type="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
-    <id column="id" jdbcType="BIGINT" property="id" />
+    <result column="id" jdbcType="BIGINT" property="id" />
     <result column="name" jdbcType="VARCHAR" property="name" />
     <result column="password" jdbcType="VARCHAR" property="password" />
     <result column="display_name" jdbcType="VARCHAR" property="displayName" />
     <result column="email" jdbcType="VARCHAR" property="email" />
+    <result column="is_admin" jdbcType="INTEGER" property="isAdmin" />
   </resultMap>
   <sql id="Example_Where_Clause">
     <where>
@@ -38,7 +39,7 @@
     </where>
   </sql>
   <sql id="Base_Column_List">
-    id, name, password, display_name, email
+    id, name, password, display_name, email, is_admin
   </sql>
   <select id="selectByExample" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample" resultMap="BaseResultMap">
     select
@@ -57,21 +58,13 @@
       limit #{limitStart} , #{limitEnd}
     </if>
   </select>
-  <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
-    select 
-    <include refid="Base_Column_List" />
-    from s2_user
-    where id = #{id,jdbcType=BIGINT}
-  </select>
-  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
-    delete from s2_user
-    where id = #{id,jdbcType=BIGINT}
-  </delete>
   <insert id="insert" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
     insert into s2_user (id, name, password, 
-      display_name, email)
+      display_name, email, is_admin
+      )
     values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
-      #{displayName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR})
+      #{displayName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR}, #{isAdmin,jdbcType=INTEGER}
+      )
   </insert>
   <insert id="insertSelective" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
     insert into s2_user
@@ -91,6 +84,9 @@
       <if test="email != null">
         email,
       </if>
+      <if test="isAdmin != null">
+        is_admin,
+      </if>
     </trim>
     <trim prefix="values (" suffix=")" suffixOverrides=",">
       <if test="id != null">
@@ -108,6 +104,9 @@
       <if test="email != null">
         #{email,jdbcType=VARCHAR},
       </if>
+      <if test="isAdmin != null">
+        #{isAdmin,jdbcType=INTEGER},
+      </if>
     </trim>
   </insert>
   <select id="countByExample" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample" resultType="java.lang.Long">
@@ -116,30 +115,4 @@
       <include refid="Example_Where_Clause" />
     </if>
   </select>
-  <update id="updateByPrimaryKeySelective" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
-    update s2_user
-    <set>
-      <if test="name != null">
-        name = #{name,jdbcType=VARCHAR},
-      </if>
-      <if test="password != null">
-        password = #{password,jdbcType=VARCHAR},
-      </if>
-      <if test="displayName != null">
-        display_name = #{displayName,jdbcType=VARCHAR},
-      </if>
-      <if test="email != null">
-        email = #{email,jdbcType=VARCHAR},
-      </if>
-    </set>
-    where id = #{id,jdbcType=BIGINT}
-  </update>
-  <update id="updateByPrimaryKey" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
-    update s2_user
-    set name = #{name,jdbcType=VARCHAR},
-      password = #{password,jdbcType=VARCHAR},
-      display_name = #{displayName,jdbcType=VARCHAR},
-      email = #{email,jdbcType=VARCHAR}
-    where id = #{id,jdbcType=BIGINT}
-  </update>
 </mapper>

auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/rest/AuthController.java

@@ -40,7 +40,7 @@ public class AuthController {
     @PostMapping("/createGroup")
     public void newAuthGroup(@RequestBody AuthGroup group) {
         group.setGroupId(null);
-        authService.updateAuthGroup(group);
+        authService.addOrUpdateAuthGroup(group);
     }
 
     @PostMapping("/removeGroup")
@@ -58,7 +58,7 @@ public class AuthController {
         if (group.getGroupId() == null || group.getGroupId() == 0) {
             throw new RuntimeException("groupId is empty");
         }
-        authService.updateAuthGroup(group);
+        authService.addOrUpdateAuthGroup(group);
     }
 
     /**

auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/service/AuthServiceImpl.java

@@ -1,6 +1,7 @@
-package com.tencent.supersonic.auth.authorization.application;
+package com.tencent.supersonic.auth.authorization.service;
 
 import com.google.common.base.Strings;
+import com.google.common.collect.Lists;
 import com.google.gson.Gson;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.service.UserService;
@@ -13,7 +14,6 @@ import com.tencent.supersonic.auth.api.authorization.service.AuthService;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
@@ -48,12 +48,12 @@ public class AuthServiceImpl implements AuthService {
     public List<AuthGroup> queryAuthGroups(String modelId, Integer groupId) {
         return load().stream()
                 .filter(group -> (Objects.isNull(groupId) || groupId.equals(group.getGroupId()))
-                        && modelId.equals(group.getModelId()))
+                        && modelId.equals(group.getModelId().toString()))
                 .collect(Collectors.toList());
     }
 
     @Override
-    public void updateAuthGroup(AuthGroup group) {
+    public void addOrUpdateAuthGroup(AuthGroup group) {
         Gson g = new Gson();
         if (group.getGroupId() == null) {
             int nextGroupId = 1;
@@ -76,21 +76,17 @@ public class AuthServiceImpl implements AuthService {
         jdbcTemplate.update("delete from s2_auth_groups where group_id = ?", group.getGroupId());
     }
 
-
     @Override
     public AuthorizedResourceResp queryAuthorizedResources(QueryAuthResReq req, User user) {
         Set<String> userOrgIds = userService.getUserAllOrgId(user.getName());
-        if (!CollectionUtils.isEmpty(userOrgIds)) {
+        List<AuthGroup> groups = getAuthGroups(req.getModelIds(), user.getName(), new ArrayList<>(userOrgIds));
-            req.setDepartmentIds(new ArrayList<>(userOrgIds));
-        }
-        List<AuthGroup> groups = getAuthGroups(req, user.getName());
         AuthorizedResourceResp resource = new AuthorizedResourceResp();
-        Map<String, List<AuthGroup>> authGroupsByModelId = groups.stream()
+        Map<Long, List<AuthGroup>> authGroupsByModelId = groups.stream()
                 .collect(Collectors.groupingBy(AuthGroup::getModelId));
-        Map<String, List<AuthRes>> reqAuthRes = req.getResources().stream()
+        Map<Long, List<AuthRes>> reqAuthRes = req.getResources().stream()
                 .collect(Collectors.groupingBy(AuthRes::getModelId));
 
-        for (String modelId : reqAuthRes.keySet()) {
+        for (Long modelId : reqAuthRes.keySet()) {
             List<AuthRes> reqResourcesList = reqAuthRes.get(modelId);
             AuthResGrp rg = new AuthResGrp();
             if (authGroupsByModelId.containsKey(modelId)) {
@@ -113,8 +109,11 @@ public class AuthServiceImpl implements AuthService {
             }
         }
 
-        if (StringUtils.isNotEmpty(req.getModelId())) {
+        if (!CollectionUtils.isEmpty(req.getModelIds())) {
-            List<AuthGroup> authGroups = authGroupsByModelId.get(req.getModelId());
+            List<AuthGroup> authGroups = Lists.newArrayList();
+            for (Long modelId : authGroupsByModelId.keySet()) {
+                authGroups.addAll(authGroupsByModelId.getOrDefault(modelId, Lists.newArrayList()));
+            }
             if (!CollectionUtils.isEmpty(authGroups)) {
                 for (AuthGroup group : authGroups) {
                     if (group.getDimensionFilters() != null
@@ -130,17 +129,17 @@ public class AuthServiceImpl implements AuthService {
         return resource;
     }
 
-    private List<AuthGroup> getAuthGroups(QueryAuthResReq req, String userName) {
+    private List<AuthGroup> getAuthGroups(List<Long> modelIds, String userName, List<String> departmentIds) {
         List<AuthGroup> groups = load().stream()
                 .filter(group -> {
-                    if (!Objects.equals(group.getModelId(), req.getModelId())) {
+                    if (CollectionUtils.isEmpty(modelIds) || !modelIds.contains(group.getModelId())) {
                         return false;
                     }
                     if (!CollectionUtils.isEmpty(group.getAuthorizedUsers()) && group.getAuthorizedUsers()
                             .contains(userName)) {
                         return true;
                     }
-                    for (String departmentId : req.getDepartmentIds()) {
+                    for (String departmentId : departmentIds) {
                         if (!CollectionUtils.isEmpty(group.getAuthorizedDepartmentIds())
                                 && group.getAuthorizedDepartmentIds().contains(departmentId)) {
                             return true;
@@ -148,7 +147,7 @@ public class AuthServiceImpl implements AuthService {
                     }
                     return false;
                 }).collect(Collectors.toList());
-        log.info("user:{} department:{} authGroups:{}", userName, req.getDepartmentIds(), groups);
+        log.info("user:{} department:{} authGroups:{}", userName, departmentIds, groups);
         return groups;
     }
 

chat/api/pom.xml

@@ -23,7 +23,7 @@
         </dependency>
         <dependency>
             <groupId>com.tencent.supersonic</groupId>
-            <artifactId>semantic-api</artifactId>
+            <artifactId>headless-api</artifactId>
             <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticCorrector.java

@@ -1,13 +0,0 @@
-package com.tencent.supersonic.chat.api.component;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import net.sf.jsqlparser.JSQLParserException;
-
-/**
- * A semantic corrector checks validity of extracted semantic information and
- * performs correction and optimization if needed.
- */
-public interface SemanticCorrector {
-
-    void correct(SemanticCorrectInfo semanticCorrectInfo) throws JSQLParserException;
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticLayer.java

@@ -1,43 +0,0 @@
-package com.tencent.supersonic.chat.api.component;
-
-import com.github.pagehelper.PageInfo;
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.ModelSchema;
-import com.tencent.supersonic.common.pojo.enums.AuthType;
-import com.tencent.supersonic.semantic.api.model.request.PageDimensionReq;
-import com.tencent.supersonic.semantic.api.model.request.PageMetricReq;
-import com.tencent.supersonic.semantic.api.model.response.DomainResp;
-import com.tencent.supersonic.semantic.api.model.response.DimensionResp;
-import com.tencent.supersonic.semantic.api.model.response.ModelResp;
-import com.tencent.supersonic.semantic.api.model.response.MetricResp;
-import com.tencent.supersonic.semantic.api.model.response.QueryResultWithSchemaResp;
-import com.tencent.supersonic.semantic.api.query.request.QueryDslReq;
-import com.tencent.supersonic.semantic.api.query.request.QueryMultiStructReq;
-import com.tencent.supersonic.semantic.api.query.request.QueryStructReq;
-
-import java.util.List;
-
-/**
- * A semantic layer provides a simplified and consistent view of data from multiple sources.
- * It abstracts away the complexity of the underlying data sources and provides a unified view
- * of the data that is easier to understand and use.
- * <p>
- * The interface defines methods for getting metadata as well as querying data in the semantic layer.
- * Implementations of this interface should provide concrete implementations that interact with the
- * underlying data sources and return results in a consistent format. Or it can be implemented
- * as proxy to a remote semantic service.
- * </p>
- */
-public interface SemanticLayer {
-
-    QueryResultWithSchemaResp queryByStruct(QueryStructReq queryStructReq, User user);
-    QueryResultWithSchemaResp queryByMultiStruct(QueryMultiStructReq queryMultiStructReq, User user);
-    QueryResultWithSchemaResp queryByDsl(QueryDslReq queryDslReq, User user);
-    List<ModelSchema> getModelSchema();
-    List<ModelSchema> getModelSchema(List<Long> ids);
-    ModelSchema getModelSchema(Long model, Boolean cacheEnable);
-    PageInfo<DimensionResp> getDimensionPage(PageDimensionReq pageDimensionCmd);
-    PageInfo<MetricResp> getMetricPage(PageMetricReq pageMetricCmd);
-    List<DomainResp> getDomainList(User user);
-    List<ModelResp> getModelList(AuthType authType, Long domainId, User user);
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticParser.java

@@ -1,15 +0,0 @@
-package com.tencent.supersonic.chat.api.component;
-
-
-import com.tencent.supersonic.chat.api.pojo.ChatContext;
-import com.tencent.supersonic.chat.api.pojo.QueryContext;
-
-/**
- * A semantic parser understands user queries and extracts semantic information.
- * It could leverage either rule-based or LLM-based approach to identify query intent
- * and extract related semantic items from the query.
- */
-public interface SemanticParser {
-
-    void parse(QueryContext queryContext, ChatContext chatContext);
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticQuery.java

@@ -1,20 +0,0 @@
-package com.tencent.supersonic.chat.api.component;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.response.QueryResult;
-import org.apache.calcite.sql.parser.SqlParseException;
-
-/**
- * A semantic query executes specific type of query based on the results of semantic parsing.
- */
-public interface SemanticQuery {
-
-    String getQueryMode();
-
-    QueryResult execute(User user) throws SqlParseException;
-
-    SemanticParseInfo getParseInfo();
-
-    void setParseInfo(SemanticParseInfo parseInfo);
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/ModelSchema.java

@@ -1,47 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import lombok.Data;
-
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Set;
-
-@Data
-public class ModelSchema {
-
-    private SchemaElement model;
-    private Set<SchemaElement> metrics = new HashSet<>();
-    private Set<SchemaElement> dimensions = new HashSet<>();
-    private Set<SchemaElement> dimensionValues = new HashSet<>();
-    private SchemaElement entity = new SchemaElement();
-
-    public SchemaElement getElement(SchemaElementType elementType, long elementID) {
-        Optional<SchemaElement> element = Optional.empty();
-
-        switch (elementType) {
-            case ENTITY:
-                element = Optional.ofNullable(entity);
-                break;
-            case MODEL:
-                element = Optional.of(model);
-                break;
-            case METRIC:
-                element = metrics.stream().filter(e -> e.getId() == elementID).findFirst();
-                break;
-            case DIMENSION:
-                element = dimensions.stream().filter(e -> e.getId() == elementID).findFirst();
-                break;
-            case VALUE:
-                element = dimensionValues.stream().filter(e -> e.getId() == elementID).findFirst();
-                break;
-            default:
-        }
-
-        if (element.isPresent()) {
-            return element.get();
-        } else {
-            return null;
-        }
-    }
-
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/QueryContext.java

@@ -1,22 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import com.tencent.supersonic.chat.api.component.SemanticQuery;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Data
-@NoArgsConstructor
-public class QueryContext {
-
-    private QueryReq request;
-    private List<SemanticQuery> candidateQueries = new ArrayList<>();
-    private SchemaMapInfo mapInfo = new SchemaMapInfo();
-
-    public QueryContext(QueryReq request) {
-        this.request = request;
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaMapInfo.java

@@ -1,31 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-public class SchemaMapInfo {
-
-    private Map<Long, List<SchemaElementMatch>> modelElementMatches = new HashMap<>();
-
-    public Set<Long> getMatchedModels() {
-        return modelElementMatches.keySet();
-    }
-
-    public List<SchemaElementMatch> getMatchedElements(Long model) {
-        return modelElementMatches.get(model);
-    }
-
-    public Map<Long, List<SchemaElementMatch>> getModelElementMatches() {
-        return modelElementMatches;
-    }
-
-    public void setModelElementMatches(Map<Long, List<SchemaElementMatch>> modelElementMatches) {
-        this.modelElementMatches = modelElementMatches;
-    }
-
-    public void setMatchedElements(Long model, List<SchemaElementMatch> elementMatches) {
-        modelElementMatches.put(model, elementMatches);
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SemanticSchema.java

@@ -1,54 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-public class SemanticSchema implements Serializable {
-    private List<ModelSchema> modelSchemaList;
-
-    public SemanticSchema(List<ModelSchema> modelSchemaList) {
-        this.modelSchemaList = modelSchemaList;
-    }
-
-    public void add(ModelSchema schema) {
-        modelSchemaList.add(schema);
-    }
-
-    public Map<Long, String> getModelIdToName() {
-        return modelSchemaList.stream()
-                .collect(Collectors.toMap(a -> a.getModel().getId(), a -> a.getModel().getName(), (k1, k2) -> k1));
-    }
-
-    public List<SchemaElement> getDimensionValues() {
-        List<SchemaElement> dimensionValues = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> dimensionValues.addAll(d.getDimensionValues()));
-        return dimensionValues;
-    }
-
-    public List<SchemaElement> getDimensions() {
-        List<SchemaElement> dimensions = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> dimensions.addAll(d.getDimensions()));
-        return dimensions;
-    }
-
-    public List<SchemaElement> getMetrics() {
-        List<SchemaElement> metrics = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> metrics.addAll(d.getMetrics()));
-        return metrics;
-    }
-
-    public List<SchemaElement> getModels() {
-        List<SchemaElement> models = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> models.add(d.getModel()));
-        return models;
-    }
-
-    public List<SchemaElement> getEntities() {
-        List<SchemaElement> entities = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> entities.add(d.getEntity()));
-        return entities;
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatConfigBaseReq.java

@@ -16,22 +16,17 @@ public class ChatConfigBaseReq {
 
     private Long modelId;
 
-    /**
-     * the chatDetailConfig about the model
-     */
-    private ChatDetailConfigReq chatDetailConfig;
-
-    /**
-     * the chatAggConfig about the model
-     */
-    private ChatAggConfigReq chatAggConfig;
-
 
     /**
      * the recommended questions about the model
      */
     private List<RecommendedQuestionReq> recommendedQuestions;
 
+    /**
+     *  the llm examples about the model
+     */
+    private String llmExamples;
+
     /**
      * available status
      */

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatDefaultConfigReq.java

@@ -1,7 +1,6 @@
 package com.tencent.supersonic.chat.api.pojo.request;
 
 
-import com.tencent.supersonic.common.pojo.Constants;
 import lombok.Data;
 
 import java.util.ArrayList;
@@ -13,26 +12,5 @@ public class ChatDefaultConfigReq {
     private List<Long> dimensionIds = new ArrayList<>();
     private List<Long> metricIds = new ArrayList<>();
 
-    /**
-     * default time span unit
-     */
-    private Integer unit = 1;
-
-    /**
-     * default time type: day
-     * DAY, WEEK, MONTH, YEAR
-     */
-    private String period = Constants.DAY;
-
-    private TimeMode timeMode = TimeMode.LAST;
-
-    public enum TimeMode {
-        /**
-         * date mode
-         * LAST   - a certain time
-         * RECENT - a period time
-         */
-        LAST, RECENT
-    }
 
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatExecuteReq.java

@@ -0,0 +1,21 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ChatExecuteReq {
+    private User user;
+    private Long queryId;
+    private Integer chatId;
+    private int parseId;
+    private String queryText;
+    private boolean saveAnswer;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatParseReq.java

@@ -1,15 +1,19 @@
 package com.tencent.supersonic.chat.api.pojo.request;
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.headless.api.pojo.SchemaMapInfo;
+import com.tencent.supersonic.headless.api.pojo.request.QueryFilters;
 import lombok.Data;
 
 @Data
-public class QueryReq {
+public class ChatParseReq {
     private String queryText;
     private Integer chatId;
-    private Long modelId = 0L;
+    private Integer agentId;
+    private Integer topN = 10;
     private User user;
     private QueryFilters queryFilters;
     private boolean saveAnswer = true;
-    private Integer agentId;
+    private SchemaMapInfo mapInfo = new SchemaMapInfo();
+
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatQueryDataReq.java

@@ -0,0 +1,22 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.common.pojo.DateConf;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.request.QueryFilter;
+import lombok.Data;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Data
+public class ChatQueryDataReq {
+    private User user;
+    private Set<SchemaElement> metrics = new HashSet<>();
+    private Set<SchemaElement> dimensions = new HashSet<>();
+    private Set<QueryFilter> dimensionFilters = new HashSet<>();
+    private Set<QueryFilter> metricFilters = new HashSet<>();
+    private DateConf dateInfo;
+    private Long queryId;
+    private Integer parseId;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/PageQueryInfoReq.java

@@ -1,6 +1,7 @@
 package com.tencent.supersonic.chat.api.pojo.request;
 
 import lombok.Data;
+import java.util.List;
 
 @Data
 public class PageQueryInfoReq {
@@ -11,27 +12,9 @@ public class PageQueryInfoReq {
 
     private String userName;
 
-    public int getPageSize() {
+    private List<Long> ids;
-        return pageSize;
-    }
 
-    public void setPageSize(int pageSize) {
+    public Integer getLimitStart() {
-        this.pageSize = pageSize;
+        return this.pageSize * (this.current - 1);
-    }
-
-    public int getCurrent() {
-        return current;
-    }
-
-    public void setCurrent(int current) {
-        this.current = current;
-    }
-
-    public String getUserName() {
-        return userName;
-    }
-
-    public void setUserName(String userName) {
-        this.userName = userName;
     }
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/PluginQueryReq.java

@@ -13,7 +13,7 @@ public class PluginQueryReq {
 
     private String type;
 
-    private String model;
+    private String dataSet;
 
     private String pattern;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryDataReq.java

@@ -1,25 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.request;
-
-
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.common.pojo.DateConf;
-import com.tencent.supersonic.common.pojo.Order;
-import com.tencent.supersonic.common.pojo.enums.AggregateTypeEnum;
-import java.util.HashSet;
-import java.util.Set;
-import lombok.Data;
-
-@Data
-public class QueryDataReq {
-    String queryMode;
-    SchemaElement model;
-    Set<SchemaElement> metrics = new HashSet<>();
-    Set<SchemaElement> dimensions = new HashSet<>();
-    Set<QueryFilter> dimensionFilters = new HashSet<>();
-    Set<QueryFilter> metricFilters = new HashSet<>();
-    private AggregateTypeEnum aggType = AggregateTypeEnum.NONE;
-    private Set<Order> orders = new HashSet<>();
-    private DateConf dateInfo;
-    private Long limit;
-    private Boolean nativeQuery = false;
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryFilter.java

@@ -1,40 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.request;
-
-import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
-import java.util.Objects;
-import lombok.Data;
-import lombok.ToString;
-
-@Data
-@ToString(callSuper = true)
-public class QueryFilter {
-
-    private String bizName;
-
-    private String name;
-
-    private FilterOperatorEnum operator = FilterOperatorEnum.EQUALS;
-
-    private Object value;
-
-    private Long elementID;
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-        QueryFilter filter = (QueryFilter) o;
-        return Objects.equals(bizName, filter.bizName) && Objects.equals(name, filter.name)
-                && operator == filter.operator && Objects.equals(value, filter.value) && Objects.equals(
-                elementID, filter.elementID);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(bizName, name, operator, value, elementID);
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/RecommendReq.java

@@ -1,12 +1,13 @@
 package com.tencent.supersonic.chat.api.pojo.request;
 
+
 import lombok.Data;
 
 @Data
-public class DimensionValueReq {
+public class RecommendReq {
+
     private Long modelId;
 
-    private String bizName;
+    private Long metricId;
 
-    private Object value;
+}
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/SimilarQueryReq.java

@@ -0,0 +1,25 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class SimilarQueryReq {
+
+    private Long queryId;
+
+    private Integer parseId;
+
+    private String queryText;
+
+    private Long dataSetId;
+
+    private Integer agentId;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatConfigResp.java

@@ -23,6 +23,8 @@ public class ChatConfigResp {
 
     private List<RecommendedQuestionReq> recommendedQuestions;
 
+    private String llmExamples;
+
     /**
      * available status
      */

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatDefaultRichConfigResp.java

@@ -1,9 +1,9 @@
 package com.tencent.supersonic.chat.api.pojo.response;
 
 
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.request.ChatDefaultConfigReq;
 import com.tencent.supersonic.common.pojo.Constants;
+import com.tencent.supersonic.common.pojo.enums.TimeMode;
 import lombok.Data;
 
 import java.util.List;
@@ -21,11 +21,11 @@ public class ChatDefaultRichConfigResp {
     private Integer unit = 1;
 
     /**
-     * default time type: day
+     * default time type:
      * DAY, WEEK, MONTH, YEAR
      */
     private String period = Constants.DAY;
 
-    private ChatDefaultConfigReq.TimeMode timeMode;
+    private TimeMode timeMode;
 
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/DataInfo.java

@@ -1,12 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.response;
-
-import lombok.Data;
-
-@Data
-public class DataInfo {
-
-    private Integer itemId;
-    private String name;
-    private String bizName;
-    private String value;
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/DictLatestTaskResp.java

@@ -1,12 +1,16 @@
-package com.tencent.supersonic.knowledge.dictionary;
+package com.tencent.supersonic.chat.api.pojo.response;
-
 
 import com.tencent.supersonic.common.pojo.enums.TaskStatusEnum;
-import java.util.Date;
 import lombok.Data;
+import lombok.ToString;
 
+import java.util.Date;
+
+@ToString
 @Data
-public class DimValueDictInfo {
+public class DictLatestTaskResp {
+
+    private Long dimId;
 
     private Long id;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/EntityRichInfoResp.java

@@ -1,6 +1,6 @@
 package com.tencent.supersonic.chat.api.pojo.response;
 
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
 
 import java.util.List;
 import lombok.Data;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ModelInfo.java

@@ -1,12 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.response;
-
-import java.io.Serializable;
-import java.util.List;
-import lombok.Data;
-
-@Data
-public class ModelInfo extends DataInfo implements Serializable {
-
-    private List<String> words;
-    private String primaryEntityBizName;
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ParseResp.java

@@ -1,30 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.response;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import lombok.Data;
-import lombok.Getter;
-import lombok.Builder;
-import lombok.NoArgsConstructor;
-import lombok.AllArgsConstructor;
-
-import java.util.List;
-
-@Data
-@Getter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class ParseResp {
-    private Integer chatId;
-    private String queryText;
-    private Long queryId;
-    private ParseState state;
-    private List<SemanticParseInfo> selectedParses;
-    private List<SemanticParseInfo> candidateParses;
-
-    public enum ParseState {
-        COMPLETED,
-        PENDING,
-        FAILED
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/QueryRecallResp.java

@@ -0,0 +1,11 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class QueryRecallResp {
+    private List<SimilarQueryRecallResp> solvedQueryRecallRespList;
+    private Long queryTimeCost;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/QueryResp.java

@@ -1,7 +1,11 @@
 package com.tencent.supersonic.chat.api.pojo.response;
 
-import java.util.Date;
+import com.tencent.supersonic.headless.api.pojo.SemanticParseInfo;
+import com.tencent.supersonic.headless.api.pojo.response.QueryResult;
 import lombok.Data;
+import java.util.Date;
+import java.util.List;
+
 
 @Data
 public class QueryResp {
@@ -13,4 +17,7 @@ public class QueryResp {
     private String feedback;
     private String queryText;
     private QueryResult queryResult;
+    private List<SemanticParseInfo> parseInfos;
+    private List<SimilarQueryRecallResp> similarQueries;
+
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/RecommendResp.java

@@ -1,6 +1,6 @@
 package com.tencent.supersonic.chat.api.pojo.response;
 
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
 import lombok.Data;
 
 import java.util.List;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/SimilarQueryRecallResp.java

@@ -0,0 +1,15 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class SimilarQueryRecallResp {
+
+    private Long queryId;
+
+    private String queryText;
+
+}

chat/core/pom.xml

@@ -1,149 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>chat</artifactId>
-        <groupId>com.tencent.supersonic</groupId>
-        <version>${revision}</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>chat-core</artifactId>
-
-    <properties>
-        <maven.compiler.source>8</maven.compiler.source>
-        <maven.compiler.target>8</maven.compiler.target>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>org.testng</groupId>
-            <artifactId>testng</artifactId>
-            <version>${org.testng.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-compress</artifactId>
-            <version>${commons.compress.version}</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>org.mybatis.spring.boot</groupId>
-            <artifactId>mybatis-spring-boot-starter</artifactId>
-            <version>${mybatis-spring.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.alibaba</groupId>
-            <artifactId>druid</artifactId>
-            <version>${alibaba.druid.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis-spring</artifactId>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.mybatis.spring.boot</groupId>
-            <artifactId>mybatis-spring-boot-starter-test</artifactId>
-            <version>${mybatis.test.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>com.github.pagehelper</groupId>
-            <artifactId>pagehelper-spring-boot-starter</artifactId>
-            <version>${pagehelper.spring.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <version>${h2.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>chat-knowledge</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>semantic-api</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>semantic-query</artifactId>
-            <version>${project.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>chat-api</artifactId>
-            <version>${project.version}</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>semantic-query</artifactId>
-            <version>${project.version}</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>com.github.xkzhangsan</groupId>
-            <artifactId>xk-time</artifactId>
-            <version>${xk.time.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-inline</artifactId>
-            <version>${mockito-inline.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-    </dependencies>
-
-</project>

chat/core/src/main/java/com/tencent/supersonic/chat/agent/Agent.java

@@ -1,49 +0,0 @@
-package com.tencent.supersonic.chat.agent;
-
-
-import com.alibaba.fastjson.JSONObject;
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.agent.tool.AgentToolType;
-import com.tencent.supersonic.common.pojo.RecordInfo;
-import java.util.Objects;
-import lombok.Data;
-import org.springframework.util.CollectionUtils;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Data
-public class Agent extends RecordInfo {
-
-    private Integer id;
-    private Integer enableSearch;
-    private String name;
-    private String description;
-
-    //0 offline, 1 online
-    private Integer status;
-    private List<String> examples;
-    private String agentConfig;
-    public List<String> getTools(AgentToolType type) {
-        Map map = JSONObject.parseObject(agentConfig, Map.class);
-        if (CollectionUtils.isEmpty(map) || map.get("tools") == null) {
-            return Lists.newArrayList();
-        }
-        List<Map> toolList = (List) map.get("tools");
-        return toolList.stream()
-                .filter(tool -> {
-                            if (Objects.isNull(type)) {
-                                return true;
-                            }
-                            return type.name().equals(tool.get("type"));
-                        }
-                )
-                .map(JSONObject::toJSONString)
-                .collect(Collectors.toList());
-    }
-
-    public boolean enableSearch() {
-        return enableSearch != null && enableSearch == 1;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/agent/tool/AgentToolType.java

@@ -1,8 +0,0 @@
-package com.tencent.supersonic.chat.agent.tool;
-
-public enum AgentToolType {
-    RULE,
-    DSL,
-    PLUGIN,
-    INTERPRET
-}

chat/core/src/main/java/com/tencent/supersonic/chat/agent/tool/DslTool.java

@@ -1,14 +0,0 @@
-package com.tencent.supersonic.chat.agent.tool;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class DslTool extends AgentTool {
-
-    private List<Long> modelIds;
-
-    private List<String> exampleQuestions;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/agent/tool/MetricInterpretTool.java

@@ -1,16 +0,0 @@
-package com.tencent.supersonic.chat.agent.tool;
-
-import com.tencent.supersonic.chat.parser.llm.interpret.MetricOption;
-import lombok.Data;
-
-import java.util.List;
-
-
-@Data
-public class MetricInterpretTool extends AgentTool {
-
-    private Long modelId;
-
-    private List<MetricOption> metricOptions;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/agent/tool/RuleQueryTool.java

@@ -1,20 +0,0 @@
-package com.tencent.supersonic.chat.agent.tool;
-
-
-import lombok.Data;
-import org.apache.commons.collections.CollectionUtils;
-
-import java.util.List;
-
-@Data
-public class RuleQueryTool extends AgentTool {
-
-    private List<Long> modelIds;
-
-    private List<String> queryModes;
-
-    public boolean isContainsAllModel() {
-        return CollectionUtils.isNotEmpty(modelIds) && modelIds.contains(-1L);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/config/EntityInternalDetail.java

@@ -1,14 +0,0 @@
-package com.tencent.supersonic.chat.config;
-
-
-import com.tencent.supersonic.semantic.api.model.response.DimSchemaResp;
-import com.tencent.supersonic.semantic.api.model.response.MetricSchemaResp;
-import java.util.List;
-import lombok.Data;
-
-@Data
-public class EntityInternalDetail {
-
-    List<DimSchemaResp> dimensionList;
-    List<MetricSchemaResp> metricList;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/config/FunctionCallInfoConfig.java

@@ -1,15 +0,0 @@
-package com.tencent.supersonic.chat.config;
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-public class FunctionCallInfoConfig {
-    @Value("${functionCall.url:}")
-    private String url;
-
-    @Value("${funtionCall.plugin.select.path:/plugin_selection}")
-    private String pluginSelectPath;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/config/LLMConfig.java

@@ -1,19 +0,0 @@
-package com.tencent.supersonic.chat.config;
-
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-public class LLMConfig {
-
-
-    @Value("${llm.url:}")
-    private String url;
-
-    @Value("${query2sql.path:/query2sql}")
-    private String queryToSqlPath;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/config/OptimizationConfig.java

@@ -1,43 +0,0 @@
-package com.tencent.supersonic.chat.config;
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.PropertySource;
-
-@Configuration
-@Data
-@PropertySource("classpath:optimization.properties")
-//@ComponentScan(basePackages = "com.tencent.supersonic.chat")
-public class OptimizationConfig {
-
-    @Value("${one.detection.size}")
-    private Integer oneDetectionSize;
-    @Value("${one.detection.max.size}")
-    private Integer oneDetectionMaxSize;
-
-    @Value("${metric.dimension.min.threshold}")
-    private Double metricDimensionMinThresholdConfig;
-
-    @Value("${metric.dimension.threshold}")
-    private Double metricDimensionThresholdConfig;
-
-    @Value("${dimension.value.threshold}")
-    private Double dimensionValueThresholdConfig;
-
-    @Value("${function.bonus.threshold}")
-    private Double functionBonusThreshold;
-
-    @Value("${long.text.threshold}")
-    private Double longTextThreshold;
-
-    @Value("${short.text.threshold}")
-    private Double shortTextThreshold;
-
-    @Value("${query.text.length.threshold}")
-    private Integer queryTextLengthThreshold;
-
-    @Value("${candidate.threshold}")
-    private Double candidateThreshold;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/BaseSemanticCorrector.java

@@ -1,33 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.component.SemanticCorrector;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.knowledge.service.SchemaService;
-import com.tencent.supersonic.semantic.api.model.enums.TimeDimensionEnum;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public abstract class BaseSemanticCorrector implements SemanticCorrector {
-    public static final String DATE_FIELD = "数据日期";
-    protected Map<String, String> getFieldToBizName(Long modelId) {
-
-        SemanticSchema semanticSchema = ContextUtils.getBean(SchemaService.class).getSemanticSchema();
-
-        List<SchemaElement> dbAllFields = new ArrayList<>();
-        dbAllFields.addAll(semanticSchema.getMetrics());
-        dbAllFields.addAll(semanticSchema.getDimensions());
-
-        Map<String, String> result = dbAllFields.stream()
-                .filter(entry -> entry.getModel().equals(modelId))
-                .collect(Collectors.toMap(SchemaElement::getName, a -> a.getBizName(), (k1, k2) -> k1));
-        result.put(DATE_FIELD, TimeDimensionEnum.DAY.getName());
-        return result;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/DateFieldCorrector.java

@@ -1,27 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.chat.parser.llm.dsl.DSLDateHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import java.util.List;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class DateFieldCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-
-        String sql = semanticCorrectInfo.getSql();
-        List<String> whereFields = SqlParserSelectHelper.getWhereFields(sql);
-        if (CollectionUtils.isEmpty(whereFields) || !whereFields.contains(DATE_FIELD)) {
-            String currentDate = DSLDateHelper.getReferenceDate(semanticCorrectInfo.getParseInfo().getModelId());
-            sql = SqlParserUpdateHelper.addWhere(sql, DATE_FIELD, currentDate);
-        }
-        semanticCorrectInfo.setPreSql(semanticCorrectInfo.getSql());
-        semanticCorrectInfo.setSql(sql);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/FieldCorrector.java

@@ -1,18 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public class FieldCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        String preSql = semanticCorrectInfo.getSql();
-        semanticCorrectInfo.setPreSql(preSql);
-        String sql = SqlParserUpdateHelper.replaceFields(preSql,
-                getFieldToBizName(semanticCorrectInfo.getParseInfo().getModelId()));
-        semanticCorrectInfo.setSql(sql);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/FieldNameCorrector.java

@@ -1,49 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.chat.parser.llm.dsl.DSLParseResult;
-import com.tencent.supersonic.chat.query.llm.dsl.LLMReq;
-import com.tencent.supersonic.chat.query.llm.dsl.LLMReq.ElementValue;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class FieldNameCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-
-        Object context = semanticCorrectInfo.getParseInfo().getProperties().get(Constants.CONTEXT);
-        if (Objects.isNull(context)) {
-            return;
-        }
-
-        DSLParseResult dslParseResult = JsonUtil.toObject(JsonUtil.toString(context), DSLParseResult.class);
-        if (Objects.isNull(dslParseResult) || Objects.isNull(dslParseResult.getLlmReq())) {
-            return;
-        }
-        LLMReq llmReq = dslParseResult.getLlmReq();
-        List<ElementValue> linking = llmReq.getLinking();
-        if (CollectionUtils.isEmpty(linking)) {
-            return;
-        }
-
-        Map<String, Set<String>> fieldValueToFieldNames = linking.stream().collect(
-                Collectors.groupingBy(ElementValue::getFieldValue,
-                        Collectors.mapping(ElementValue::getFieldName, Collectors.toSet())));
-
-        String preSql = semanticCorrectInfo.getSql();
-        semanticCorrectInfo.setPreSql(preSql);
-        String sql = SqlParserUpdateHelper.replaceFieldNameByValue(preSql, fieldValueToFieldNames);
-        semanticCorrectInfo.setSql(sql);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/FieldValueCorrector.java

@@ -1,81 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaValueMap;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import com.tencent.supersonic.knowledge.service.SchemaService;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.logging.log4j.util.Strings;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class FieldValueCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        SemanticSchema semanticSchema = ContextUtils.getBean(SchemaService.class).getSemanticSchema();
-        Long modelId = semanticCorrectInfo.getParseInfo().getModel().getId();
-        List<SchemaElement> dimensions = semanticSchema.getDimensions().stream()
-                .filter(schemaElement -> modelId.equals(schemaElement.getModel()))
-                .collect(Collectors.toList());
-
-        if (CollectionUtils.isEmpty(dimensions)) {
-            return;
-        }
-
-        Map<String, Map<String, String>> aliasAndBizNameToTechName = getAliasAndBizNameToTechName(dimensions);
-        String preSql = semanticCorrectInfo.getSql();
-        semanticCorrectInfo.setPreSql(preSql);
-        String sql = SqlParserUpdateHelper.replaceValue(preSql, aliasAndBizNameToTechName);
-        semanticCorrectInfo.setSql(sql);
-        return;
-    }
-
-
-    private Map<String, Map<String, String>> getAliasAndBizNameToTechName(List<SchemaElement> dimensions) {
-        if (CollectionUtils.isEmpty(dimensions)) {
-            return new HashMap<>();
-        }
-
-        Map<String, Map<String, String>> result = new HashMap<>();
-
-        for (SchemaElement dimension : dimensions) {
-            if (Objects.isNull(dimension)
-                    || Strings.isEmpty(dimension.getBizName())
-                    || CollectionUtils.isEmpty(dimension.getSchemaValueMaps())) {
-                continue;
-            }
-            String bizName = dimension.getBizName();
-
-            Map<String, String> aliasAndBizNameToTechName = new HashMap<>();
-
-            for (SchemaValueMap valueMap : dimension.getSchemaValueMaps()) {
-                if (Objects.isNull(valueMap) || Strings.isEmpty(valueMap.getTechName())) {
-                    continue;
-                }
-                if (Strings.isNotEmpty(valueMap.getBizName())) {
-                    aliasAndBizNameToTechName.put(valueMap.getBizName(), valueMap.getTechName());
-                }
-                if (!CollectionUtils.isEmpty(valueMap.getAlias())) {
-                    valueMap.getAlias().stream().forEach(alias -> {
-                        if (Strings.isNotEmpty(alias)) {
-                            aliasAndBizNameToTechName.put(alias, valueMap.getTechName());
-                        }
-                    });
-                }
-            }
-            if (!CollectionUtils.isEmpty(aliasAndBizNameToTechName)) {
-                result.put(bizName, aliasAndBizNameToTechName);
-            }
-        }
-        return result;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/FunctionAliasCorrector.java

@@ -1,16 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public class FunctionAliasCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        String replaceAlias = SqlParserUpdateHelper.replaceAlias(semanticCorrectInfo.getSql());
-        semanticCorrectInfo.setSql(replaceAlias);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/FunctionCorrector.java

@@ -1,17 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public class FunctionCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        String preSql = semanticCorrectInfo.getSql();
-        semanticCorrectInfo.setPreSql(preSql);
-        String sql = SqlParserUpdateHelper.replaceFunction(preSql);
-        semanticCorrectInfo.setSql(sql);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/QueryFilterAppend.java

@@ -1,48 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilters;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.util.StringUtil;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.expression.Expression;
-import net.sf.jsqlparser.parser.CCJSqlParserUtil;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-
-@Slf4j
-public class QueryFilterAppend extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) throws JSQLParserException {
-        String queryFilter = getQueryFilter(semanticCorrectInfo.getQueryFilters());
-        String preSql = semanticCorrectInfo.getSql();
-
-        if (StringUtils.isNotEmpty(queryFilter)) {
-            log.info("add queryFilter to preSql :{}", queryFilter);
-            Expression expression = CCJSqlParserUtil.parseCondExpression(queryFilter);
-            String sql = SqlParserUpdateHelper.addWhere(preSql, expression);
-            semanticCorrectInfo.setPreSql(preSql);
-            semanticCorrectInfo.setSql(sql);
-        }
-    }
-
-    private String getQueryFilter(QueryFilters queryFilters) {
-        if (Objects.isNull(queryFilters) || CollectionUtils.isEmpty(queryFilters.getFilters())) {
-            return null;
-        }
-        return queryFilters.getFilters().stream()
-                .map(filter -> {
-                    String bizNameWrap = StringUtil.getSpaceWrap(filter.getBizName());
-                    String operatorWrap = StringUtil.getSpaceWrap(filter.getOperator().getValue());
-                    String valueWrap = StringUtil.getCommaWrap(filter.getValue().toString());
-                    return bizNameWrap + operatorWrap + valueWrap;
-                })
-                .collect(Collectors.joining(Constants.AND_UPPER));
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/SelectFieldAppendCorrector.java

@@ -1,38 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import com.tencent.supersonic.semantic.api.model.enums.TimeDimensionEnum;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class SelectFieldAppendCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        String preSql = semanticCorrectInfo.getSql();
-        if (SqlParserSelectHelper.hasAggregateFunction(preSql)) {
-            return;
-        }
-        Set<String> selectFields = new HashSet<>(SqlParserSelectHelper.getSelectFields(preSql));
-        Set<String> whereFields = new HashSet<>(SqlParserSelectHelper.getWhereFields(preSql));
-
-        if (CollectionUtils.isEmpty(selectFields) || CollectionUtils.isEmpty(whereFields)) {
-            return;
-        }
-
-        whereFields.addAll(SqlParserSelectHelper.getOrderByFields(preSql));
-        whereFields.removeAll(selectFields);
-        whereFields.remove(TimeDimensionEnum.DAY.getName());
-        whereFields.remove(TimeDimensionEnum.WEEK.getName());
-        whereFields.remove(TimeDimensionEnum.MONTH.getName());
-        String replaceFields = SqlParserUpdateHelper.addFieldsToSelect(preSql, new ArrayList<>(whereFields));
-        semanticCorrectInfo.setPreSql(preSql);
-        semanticCorrectInfo.setSql(replaceFields);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/corrector/TableNameCorrector.java

@@ -1,21 +0,0 @@
-package com.tencent.supersonic.chat.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticCorrectInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserUpdateHelper;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public class TableNameCorrector extends BaseSemanticCorrector {
-
-    public static final String TABLE_PREFIX = "t_";
-
-    @Override
-    public void correct(SemanticCorrectInfo semanticCorrectInfo) {
-        Long modelId = semanticCorrectInfo.getParseInfo().getModelId();
-        String preSql = semanticCorrectInfo.getSql();
-        semanticCorrectInfo.setPreSql(preSql);
-        String sql = SqlParserUpdateHelper.replaceTable(preSql, TABLE_PREFIX + modelId);
-        semanticCorrectInfo.setSql(sql);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/FuzzyNameMapper.java

@@ -1,179 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.component.SchemaMapper;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.QueryContext;
-import com.tencent.supersonic.chat.config.OptimizationConfig;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.knowledge.service.SchemaService;
-import com.tencent.supersonic.knowledge.utils.HanlpHelper;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class FuzzyNameMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContext queryContext) {
-
-        log.debug("before db mapper,mapInfo:{}", queryContext.getMapInfo());
-
-        List<Term> terms = HanlpHelper.getTerms(queryContext.getRequest().getQueryText());
-
-        SemanticSchema semanticSchema = ContextUtils.getBean(SchemaService.class).getSemanticSchema();
-
-        detectAndAddToSchema(queryContext, terms, semanticSchema.getDimensions(), SchemaElementType.DIMENSION);
-
-        detectAndAddToSchema(queryContext, terms, semanticSchema.getMetrics(), SchemaElementType.METRIC);
-
-        log.debug("after db mapper,mapInfo:{}", queryContext.getMapInfo());
-    }
-
-    private void detectAndAddToSchema(QueryContext queryContext, List<Term> terms, List<SchemaElement> models,
-            SchemaElementType schemaElementType) {
-        try {
-
-            Map<String, Set<SchemaElement>> modelResultSet = getResultSet(queryContext, terms, models);
-
-            addToSchemaMapInfo(modelResultSet, queryContext.getMapInfo(), schemaElementType);
-
-        } catch (Exception e) {
-            log.error("detectAndAddToSchema error", e);
-        }
-    }
-
-    private Map<String, Set<SchemaElement>> getResultSet(QueryContext queryContext, List<Term> terms,
-            List<SchemaElement> models) {
-
-        String queryText = queryContext.getRequest().getQueryText();
-
-        MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
-        Set<Long> modelIds = mapperHelper.getModelIds(queryContext.getRequest());
-
-        Double metricDimensionThresholdConfig = getThreshold(queryContext, mapperHelper);
-
-        Map<String, Set<SchemaElement>> nameToItems = getNameToItems(models);
-
-        Map<Integer, Integer> regOffsetToLength = terms.stream().sorted(Comparator.comparing(Term::length))
-                .collect(Collectors.toMap(Term::getOffset, term -> term.word.length(), (value1, value2) -> value2));
-
-        Map<String, Set<SchemaElement>> modelResultSet = new HashMap<>();
-        for (Integer startIndex = 0; startIndex <= queryText.length() - 1; ) {
-            for (Integer endIndex = startIndex; endIndex <= queryText.length(); ) {
-                endIndex = mapperHelper.getStepIndex(regOffsetToLength, endIndex);
-                if (endIndex > queryText.length()) {
-                    continue;
-                }
-                String detectSegment = queryText.substring(startIndex, endIndex);
-
-                for (Entry<String, Set<SchemaElement>> entry : nameToItems.entrySet()) {
-                    String name = entry.getKey();
-                    Set<SchemaElement> schemaElements = entry.getValue();
-                    if (!name.contains(detectSegment)
-                            || mapperHelper.getSimilarity(detectSegment, name) < metricDimensionThresholdConfig) {
-                        continue;
-                    }
-                    if (!CollectionUtils.isEmpty(modelIds)) {
-                        schemaElements = schemaElements.stream()
-                                .filter(schemaElement -> modelIds.contains(schemaElement.getModel()))
-                                .collect(Collectors.toSet());
-                    }
-                    Set<SchemaElement> preSchemaElements = modelResultSet.putIfAbsent(detectSegment, schemaElements);
-                    if (Objects.nonNull(preSchemaElements)) {
-                        preSchemaElements.addAll(schemaElements);
-                    }
-                }
-            }
-            startIndex = mapperHelper.getStepIndex(regOffsetToLength, startIndex);
-        }
-        return modelResultSet;
-    }
-
-    private Double getThreshold(QueryContext queryContext, MapperHelper mapperHelper) {
-
-        OptimizationConfig optimizationConfig = ContextUtils.getBean(OptimizationConfig.class);
-        Double metricDimensionThresholdConfig = optimizationConfig.getMetricDimensionThresholdConfig();
-        Double metricDimensionMinThresholdConfig = optimizationConfig.getMetricDimensionMinThresholdConfig();
-
-        Map<Long, List<SchemaElementMatch>> modelElementMatches = queryContext.getMapInfo()
-                .getModelElementMatches();
-        boolean existElement = modelElementMatches.entrySet().stream()
-                .anyMatch(entry -> entry.getValue().size() >= 1);
-
-        if (!existElement) {
-            double halfThreshold = metricDimensionThresholdConfig / 2;
-
-            metricDimensionThresholdConfig = halfThreshold >= metricDimensionMinThresholdConfig ? halfThreshold
-                    : metricDimensionMinThresholdConfig;
-            log.info("ModelElementMatches:{} , not exist Element metricDimensionThresholdConfig reduce by half:{}",
-                    modelElementMatches, metricDimensionThresholdConfig);
-        }
-        return metricDimensionThresholdConfig;
-    }
-
-    private Map<String, Set<SchemaElement>> getNameToItems(List<SchemaElement> models) {
-        return models.stream().collect(
-                Collectors.toMap(SchemaElement::getName, a -> {
-                    Set<SchemaElement> result = new HashSet<>();
-                    result.add(a);
-                    return result;
-                }, (k1, k2) -> {
-                    k1.addAll(k2);
-                    return k1;
-                }));
-    }
-
-    private void addToSchemaMapInfo(Map<String, Set<SchemaElement>> mapResultRowSet, SchemaMapInfo schemaMap,
-            SchemaElementType schemaElementType) {
-        if (Objects.isNull(mapResultRowSet) || mapResultRowSet.size() <= 0) {
-            return;
-        }
-        MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
-
-        for (Map.Entry<String, Set<SchemaElement>> entry : mapResultRowSet.entrySet()) {
-            String detectWord = entry.getKey();
-            Set<SchemaElement> schemaElements = entry.getValue();
-            for (SchemaElement schemaElement : schemaElements) {
-
-                List<SchemaElementMatch> elements = schemaMap.getMatchedElements(schemaElement.getModel());
-                if (CollectionUtils.isEmpty(elements)) {
-                    elements = new ArrayList<>();
-                    schemaMap.setMatchedElements(schemaElement.getModel(), elements);
-                }
-                Set<Long> regElementSet = elements.stream()
-                        .filter(elementMatch -> schemaElementType.equals(elementMatch.getElement().getType()))
-                        .map(elementMatch -> elementMatch.getElement().getId())
-                        .collect(Collectors.toSet());
-
-                if (regElementSet.contains(schemaElement.getId())) {
-                    continue;
-                }
-                SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
-                        .element(schemaElement)
-                        .word(schemaElement.getName())
-                        .detectWord(detectWord)
-                        .frequency(10000L)
-                        .similarity(mapperHelper.getSimilarity(detectWord, schemaElement.getName()))
-                        .build();
-                log.info("schemaElementType:{},add to schema, elementMatch {}", schemaElementType, schemaElementMatch);
-                elements.add(schemaElementMatch);
-            }
-        }
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/HanlpDictMapper.java

@@ -1,144 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.component.SchemaMapper;
-import com.tencent.supersonic.chat.api.pojo.ModelSchema;
-import com.tencent.supersonic.chat.api.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.service.SemanticService;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import com.tencent.supersonic.knowledge.dictionary.MapResult;
-import com.tencent.supersonic.knowledge.dictionary.builder.BaseWordBuilder;
-import com.tencent.supersonic.knowledge.dictionary.builder.WordBuilderFactory;
-import com.tencent.supersonic.knowledge.utils.HanlpHelper;
-import com.tencent.supersonic.knowledge.utils.NatureHelper;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.BeanUtils;
-
-@Slf4j
-public class HanlpDictMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContext queryContext) {
-
-        String queryText = queryContext.getRequest().getQueryText();
-        List<Term> terms = HanlpHelper.getTerms(queryText);
-
-        for (Term term : terms) {
-            log.info("word:{},nature:{},frequency:{}", term.word, term.nature.toString(), term.getFrequency());
-        }
-
-        QueryMatchStrategy matchStrategy = ContextUtils.getBean(QueryMatchStrategy.class);
-        MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
-        Set<Long> detectModelIds = mapperHelper.getModelIds(queryContext.getRequest());
-
-        Map<MatchText, List<MapResult>> matchResult = matchStrategy.match(queryContext.getRequest(), terms,
-                detectModelIds);
-
-        List<MapResult> matches = getMatches(matchResult);
-
-        HanlpHelper.transLetterOriginal(matches);
-
-        log.info("queryContext:{},matches:{}", queryContext, matches);
-
-        convertTermsToSchemaMapInfo(matches, queryContext.getMapInfo(), terms);
-    }
-
-
-    private void convertTermsToSchemaMapInfo(List<MapResult> mapResults, SchemaMapInfo schemaMap, List<Term> terms) {
-        if (CollectionUtils.isEmpty(mapResults)) {
-            return;
-        }
-
-        Map<String, Long> wordNatureToFrequency = terms.stream().collect(
-                Collectors.toMap(entry -> entry.getWord() + entry.getNature(),
-                        term -> Long.valueOf(term.getFrequency()), (value1, value2) -> value2));
-
-        for (MapResult mapResult : mapResults) {
-            for (String nature : mapResult.getNatures()) {
-                Long modelId = NatureHelper.getModelId(nature);
-                if (Objects.isNull(modelId)) {
-                    continue;
-                }
-                SchemaElementType elementType = NatureHelper.convertToElementType(nature);
-                if (Objects.isNull(elementType)) {
-                    continue;
-                }
-
-                SemanticService schemaService = ContextUtils.getBean(SemanticService.class);
-                ModelSchema modelSchema = schemaService.getModelSchema(modelId);
-
-                BaseWordBuilder baseWordBuilder = WordBuilderFactory.get(DictWordType.getNatureType(nature));
-                Long elementID = baseWordBuilder.getElementID(nature);
-                Long frequency = wordNatureToFrequency.get(mapResult.getName() + nature);
-
-                SchemaElement elementDb = modelSchema.getElement(elementType, elementID);
-                if (Objects.isNull(elementDb)) {
-                    log.info("element is null, elementType:{},elementID:{}", elementType, elementID);
-                    continue;
-                }
-                SchemaElement element = new SchemaElement();
-                BeanUtils.copyProperties(elementDb, element);
-                element.setAlias(getAlias(elementDb));
-                if (element.getType().equals(SchemaElementType.VALUE)) {
-                    element.setName(mapResult.getName());
-                }
-                SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
-                        .element(element)
-                        .frequency(frequency)
-                        .word(mapResult.getName())
-                        .similarity(mapResult.getSimilarity())
-                        .detectWord(mapResult.getDetectWord())
-                        .build();
-
-                Map<Long, List<SchemaElementMatch>> modelElementMatches = schemaMap.getModelElementMatches();
-                List<SchemaElementMatch> schemaElementMatches = modelElementMatches.putIfAbsent(modelId,
-                        new ArrayList<>());
-                if (schemaElementMatches == null) {
-                    schemaElementMatches = modelElementMatches.get(modelId);
-                }
-                schemaElementMatches.add(schemaElementMatch);
-            }
-        }
-    }
-
-    private List<MapResult> getMatches(Map<MatchText, List<MapResult>> matchResult) {
-        List<MapResult> matches = new ArrayList<>();
-        if (Objects.isNull(matchResult)) {
-            return matches;
-        }
-        Optional<List<MapResult>> first = matchResult.entrySet().stream()
-                .filter(entry -> CollectionUtils.isNotEmpty(entry.getValue()))
-                .map(entry -> entry.getValue()).findFirst();
-
-        if (first.isPresent()) {
-            matches = first.get();
-        }
-        return matches;
-    }
-
-    public List<String> getAlias(SchemaElement element) {
-        if (!SchemaElementType.VALUE.equals(element.getType())) {
-            return element.getAlias();
-        }
-        if (CollectionUtils.isNotEmpty(element.getAlias()) && StringUtils.isNotEmpty(element.getName())) {
-            return element.getAlias().stream()
-                    .filter(aliasItem -> aliasItem.contains(element.getName()))
-                    .collect(Collectors.toList());
-        }
-        return element.getAlias();
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/MapperHelper.java

@@ -1,115 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.hankcs.hanlp.algorithm.EditDistance;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.chat.config.OptimizationConfig;
-import com.tencent.supersonic.chat.service.AgentService;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.knowledge.utils.NatureHelper;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.Data;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-/**
- * Mapper helper
- */
-
-@Data
-@Service
-@Slf4j
-public class MapperHelper {
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    public Integer getStepIndex(Map<Integer, Integer> regOffsetToLength, Integer index) {
-        Integer subRegLength = regOffsetToLength.get(index);
-        if (Objects.nonNull(subRegLength)) {
-            index = index + subRegLength;
-        } else {
-            index++;
-        }
-        return index;
-    }
-
-    public Integer getStepOffset(List<Integer> termList, Integer index) {
-        for (int j = 0; j < termList.size() - 1; j++) {
-            if (termList.get(j) <= index && termList.get(j + 1) > index) {
-                return termList.get(j);
-            }
-        }
-        return index;
-    }
-
-    public double getThresholdMatch(List<String> natures) {
-        if (existDimensionValues(natures)) {
-            return optimizationConfig.getDimensionValueThresholdConfig();
-        }
-        return optimizationConfig.getMetricDimensionThresholdConfig();
-    }
-
-    /***
-     * exist dimension values
-     * @param natures
-     * @return
-     */
-    public boolean existDimensionValues(List<String> natures) {
-        for (String nature : natures) {
-            if (NatureHelper.isDimensionValueModelId(nature)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /***
-     * get similarity
-     * @param detectSegment
-     * @param matchName
-     * @return
-     */
-    public double getSimilarity(String detectSegment, String matchName) {
-        String detectSegmentLower = detectSegment == null ? null : detectSegment.toLowerCase();
-        String matchNameLower = matchName == null ? null : matchName.toLowerCase();
-        return 1 - (double) EditDistance.compute(detectSegmentLower, matchNameLower) / Math.max(matchName.length(),
-                detectSegment.length());
-    }
-
-    public Set<Long> getModelIds(QueryReq request) {
-
-        Long modelId = request.getModelId();
-
-        AgentService agentService = ContextUtils.getBean(AgentService.class);
-
-        Set<Long> detectModelIds = agentService.getDslToolsModelIds(request.getAgentId(), null);
-        //contains all
-        if (agentService.containsAllModel(detectModelIds)) {
-            if (Objects.nonNull(modelId) && modelId > 0) {
-                Set<Long> result = new HashSet<>();
-                result.add(modelId);
-                return result;
-            }
-            return new HashSet<>();
-        }
-
-        if (Objects.nonNull(detectModelIds)) {
-            detectModelIds = detectModelIds.stream().filter(entry -> entry > 0).collect(Collectors.toSet());
-        }
-
-        if (Objects.nonNull(modelId) && modelId > 0 && Objects.nonNull(detectModelIds)) {
-            if (detectModelIds.contains(modelId)) {
-                Set<Long> result = new HashSet<>();
-                result.add(modelId);
-                return result;
-            }
-        }
-        return detectModelIds;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/MatchStrategy.java

@@ -1,17 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.knowledge.dictionary.MapResult;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * match strategy
- */
-public interface MatchStrategy {
-
-    Map<MatchText, List<MapResult>> match(QueryReq queryReq, List<Term> terms, Set<Long> detectModelId);
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/QueryFilterMapper.java

@@ -1,91 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.component.SchemaMapper;
-import com.tencent.supersonic.chat.api.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilter;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilters;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.common.pojo.Constants;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Slf4j
-public class QueryFilterMapper implements SchemaMapper {
-
-    private Long frequency = 9999999L;
-    private double similarity = 1.0;
-
-    @Override
-    public void map(QueryContext queryContext) {
-        QueryReq queryReq = queryContext.getRequest();
-        Long modelId = queryReq.getModelId();
-        if (modelId == null || modelId <= 0) {
-            return;
-        }
-        SchemaMapInfo schemaMapInfo = queryContext.getMapInfo();
-        clearOtherSchemaElementMatch(modelId, schemaMapInfo);
-        List<SchemaElementMatch> schemaElementMatches = schemaMapInfo.getMatchedElements(modelId);
-        if (schemaElementMatches == null) {
-            schemaElementMatches = Lists.newArrayList();
-            schemaMapInfo.setMatchedElements(modelId, schemaElementMatches);
-        }
-        addValueSchemaElementMatch(schemaElementMatches, queryReq.getQueryFilters());
-    }
-
-    private void clearOtherSchemaElementMatch(Long modelId, SchemaMapInfo schemaMapInfo) {
-        for (Map.Entry<Long, List<SchemaElementMatch>> entry : schemaMapInfo.getModelElementMatches().entrySet()) {
-            if (!entry.getKey().equals(modelId)) {
-                entry.getValue().clear();
-            }
-        }
-    }
-
-    private List<SchemaElementMatch> addValueSchemaElementMatch(List<SchemaElementMatch> candidateElementMatches,
-                                                           QueryFilters queryFilter) {
-        if (queryFilter == null || CollectionUtils.isEmpty(queryFilter.getFilters())) {
-            return candidateElementMatches;
-        }
-        for (QueryFilter filter : queryFilter.getFilters()) {
-            if (checkExistSameValueSchemaElementMatch(filter, candidateElementMatches)) {
-                continue;
-            }
-            SchemaElement element = SchemaElement.builder()
-                    .id(filter.getElementID())
-                    .name(String.valueOf(filter.getValue()))
-                    .type(SchemaElementType.VALUE)
-                    .bizName(filter.getBizName())
-                    .build();
-            SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
-                    .element(element)
-                    .frequency(frequency)
-                    .word(String.valueOf(filter.getValue()))
-                    .similarity(similarity)
-                    .detectWord(Constants.EMPTY)
-                    .build();
-            candidateElementMatches.add(schemaElementMatch);
-        }
-        return candidateElementMatches;
-    }
-
-    private boolean checkExistSameValueSchemaElementMatch(QueryFilter queryFilter,
-                                                          List<SchemaElementMatch> schemaElementMatches) {
-        List<SchemaElementMatch> valueSchemaElements = schemaElementMatches.stream().filter(schemaElementMatch ->
-                        SchemaElementType.VALUE.equals(schemaElementMatch.getElement().getType()))
-                .collect(Collectors.toList());
-        for (SchemaElementMatch schemaElementMatch : valueSchemaElements) {
-            if (schemaElementMatch.getElement().getId().equals(queryFilter.getElementID())
-                    && schemaElementMatch.getWord().equals(String.valueOf(queryFilter.getValue()))) {
-                return true;
-            }
-        }
-        return false;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/mapper/QueryMatchStrategy.java

@@ -1,163 +0,0 @@
-package com.tencent.supersonic.chat.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.chat.config.OptimizationConfig;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.knowledge.dictionary.MapResult;
-import com.tencent.supersonic.knowledge.service.SearchService;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.compress.utils.Lists;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-/**
- * match strategy implement
- */
-@Service
-@Slf4j
-public class QueryMatchStrategy implements MatchStrategy {
-
-    @Autowired
-    private MapperHelper mapperHelper;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Override
-    public Map<MatchText, List<MapResult>> match(QueryReq queryReq, List<Term> terms, Set<Long> detectModelIds) {
-        String text = queryReq.getQueryText();
-        if (Objects.isNull(terms) || StringUtils.isEmpty(text)) {
-            return null;
-        }
-
-        Map<Integer, Integer> regOffsetToLength = terms.stream().sorted(Comparator.comparing(Term::length))
-                .collect(Collectors.toMap(Term::getOffset, term -> term.word.length(), (value1, value2) -> value2));
-
-        List<Integer> offsetList = terms.stream().sorted(Comparator.comparing(Term::getOffset))
-                .map(term -> term.getOffset()).collect(Collectors.toList());
-
-        log.debug("retryCount:{},terms:{},regOffsetToLength:{},offsetList:{},detectModelIds:{}", terms,
-                regOffsetToLength, offsetList, detectModelIds);
-
-        List<MapResult> detects = detect(queryReq, regOffsetToLength, offsetList, detectModelIds);
-        Map<MatchText, List<MapResult>> result = new HashMap<>();
-
-        result.put(MatchText.builder().regText(text).detectSegment(text).build(), detects);
-        return result;
-    }
-
-    private List<MapResult> detect(QueryReq queryReq, Map<Integer, Integer> regOffsetToLength, List<Integer> offsetList,
-            Set<Long> detectModelIds) {
-        String text = queryReq.getQueryText();
-        List<MapResult> results = Lists.newArrayList();
-
-        for (Integer index = 0; index <= text.length() - 1; ) {
-
-            Set<MapResult> mapResultRowSet = new LinkedHashSet();
-
-            for (Integer i = index; i <= text.length(); ) {
-                int offset = mapperHelper.getStepOffset(offsetList, index);
-                i = mapperHelper.getStepIndex(regOffsetToLength, i);
-                if (i <= text.length()) {
-                    List<MapResult> mapResults = detectByStep(queryReq, detectModelIds, index, i, offset);
-                    selectMapResultInOneRound(mapResultRowSet, mapResults);
-                }
-            }
-            index = mapperHelper.getStepIndex(regOffsetToLength, index);
-            results.addAll(mapResultRowSet);
-        }
-        return results;
-    }
-
-    private void selectMapResultInOneRound(Set<MapResult> mapResultRowSet, List<MapResult> mapResults) {
-        for (MapResult mapResult : mapResults) {
-            if (mapResultRowSet.contains(mapResult)) {
-                boolean isDeleted = mapResultRowSet.removeIf(
-                        entry -> {
-                            boolean deleted = getMapKey(mapResult).equals(getMapKey(entry))
-                                    && entry.getDetectWord().length() < mapResult.getDetectWord().length();
-                            if (deleted) {
-                                log.info("deleted entry:{}", entry);
-                            }
-                            return deleted;
-                        }
-                );
-                if (isDeleted) {
-                    log.info("deleted, add mapResult:{}", mapResult);
-                    mapResultRowSet.add(mapResult);
-                }
-            } else {
-                mapResultRowSet.add(mapResult);
-            }
-        }
-    }
-
-    private String getMapKey(MapResult a) {
-        return a.getName() + Constants.UNDERLINE + String.join(Constants.UNDERLINE, a.getNatures());
-    }
-
-    private List<MapResult> detectByStep(QueryReq queryReq, Set<Long> detectModelIds, Integer index, Integer i,
-            int offset) {
-        String text = queryReq.getQueryText();
-        Integer agentId = queryReq.getAgentId();
-        String detectSegment = text.substring(index, i);
-
-        // step1. pre search
-        Integer oneDetectionMaxSize = optimizationConfig.getOneDetectionMaxSize();
-        LinkedHashSet<MapResult> mapResults = SearchService.prefixSearch(detectSegment, oneDetectionMaxSize, agentId,
-                detectModelIds).stream().collect(Collectors.toCollection(LinkedHashSet::new));
-        // step2. suffix search
-        LinkedHashSet<MapResult> suffixMapResults = SearchService.suffixSearch(detectSegment, oneDetectionMaxSize,
-                agentId, detectModelIds).stream().collect(Collectors.toCollection(LinkedHashSet::new));
-
-        mapResults.addAll(suffixMapResults);
-
-        if (CollectionUtils.isEmpty(mapResults)) {
-            return new ArrayList<>();
-        }
-        // step3. merge pre/suffix result
-        mapResults = mapResults.stream().sorted((a, b) -> -(b.getName().length() - a.getName().length()))
-                .collect(Collectors.toCollection(LinkedHashSet::new));
-
-        // step4. filter by similarity
-        mapResults = mapResults.stream()
-                .filter(term -> mapperHelper.getSimilarity(detectSegment, term.getName())
-                        >= mapperHelper.getThresholdMatch(term.getNatures()))
-                .filter(term -> CollectionUtils.isNotEmpty(term.getNatures()))
-                .collect(Collectors.toCollection(LinkedHashSet::new));
-
-        log.info("after isSimilarity parseResults:{}", mapResults);
-
-        mapResults = mapResults.stream().map(parseResult -> {
-            parseResult.setOffset(offset);
-            parseResult.setSimilarity(mapperHelper.getSimilarity(detectSegment, parseResult.getName()));
-            return parseResult;
-        }).collect(Collectors.toCollection(LinkedHashSet::new));
-
-        // step5. take only one dimension or 10 metric/dimension value per rond.
-        List<MapResult> dimensionMetrics = mapResults.stream()
-                .filter(entry -> mapperHelper.existDimensionValues(entry.getNatures()))
-                .collect(Collectors.toList())
-                .stream()
-                .limit(1)
-                .collect(Collectors.toList());
-
-        if (CollectionUtils.isNotEmpty(dimensionMetrics)) {
-            return dimensionMetrics;
-        } else {
-            return mapResults.stream().limit(optimizationConfig.getOneDetectionSize()).collect(Collectors.toList());
-        }
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/parser/SatisfactionChecker.java

@@ -1,49 +0,0 @@
-package com.tencent.supersonic.chat.parser;
-
-
-import com.tencent.supersonic.chat.api.component.SemanticQuery;
-import com.tencent.supersonic.chat.api.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.config.OptimizationConfig;
-import com.tencent.supersonic.chat.query.llm.dsl.DslQuery;
-import com.tencent.supersonic.common.util.ContextUtils;
-import lombok.extern.slf4j.Slf4j;
-
-/**
- * This checker can be used by semantic parsers to check if query intent
- * has already been satisfied by current candidate queries. If so, current
- * parser could be skipped.
- */
-@Slf4j
-public class SatisfactionChecker {
-
-    // check all the parse info in candidate
-    public static boolean check(QueryContext queryContext) {
-        for (SemanticQuery query : queryContext.getCandidateQueries()) {
-            if (query.getQueryMode().equals(DslQuery.QUERY_MODE)) {
-                continue;
-            }
-            if (checkThreshold(queryContext.getRequest().getQueryText(), query.getParseInfo())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private static boolean checkThreshold(String queryText, SemanticParseInfo semanticParseInfo) {
-        int queryTextLength = queryText.replaceAll(" ", "").length();
-        double degree = semanticParseInfo.getScore() / queryTextLength;
-        OptimizationConfig optimizationConfig = ContextUtils.getBean(OptimizationConfig.class);
-        if (queryTextLength > optimizationConfig.getQueryTextLengthThreshold()) {
-            if (degree < optimizationConfig.getLongTextThreshold()) {
-                return false;
-            }
-        } else if (degree < optimizationConfig.getShortTextThreshold()) {
-            return false;
-        }
-        log.info("queryMode:{}, degree:{}, parse info:{}",
-                semanticParseInfo.getQueryMode(), degree, semanticParseInfo);
-        return true;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/parser/llm/dsl/DSLDateHelper.java

@@ -1,55 +0,0 @@
-package com.tencent.supersonic.chat.parser.llm.dsl;
-
-import com.tencent.supersonic.chat.api.pojo.request.ChatConfigFilter;
-import com.tencent.supersonic.chat.api.pojo.request.ChatDefaultConfigReq;
-import com.tencent.supersonic.chat.api.pojo.response.ChatConfigResp;
-import com.tencent.supersonic.chat.service.ConfigService;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.DatePeriodEnum;
-import com.tencent.supersonic.common.util.DateUtils;
-import java.util.List;
-import java.util.Objects;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-
-public class DSLDateHelper {
-
-    public static String getReferenceDate(Long modelId) {
-        String chatDetailDate = getChatDetailDate(modelId);
-        if (StringUtils.isNotBlank(chatDetailDate)) {
-            return chatDetailDate;
-        }
-        return DateUtils.getBeforeDate(0);
-    }
-
-    private static String getChatDetailDate(Long modelId) {
-        if (Objects.isNull(modelId)) {
-            return null;
-        }
-        ChatConfigFilter filter = new ChatConfigFilter();
-        filter.setModelId(modelId);
-
-        List<ChatConfigResp> configResps = ContextUtils.getBean(ConfigService.class).search(filter, null);
-        if (CollectionUtils.isEmpty(configResps)) {
-            return null;
-        }
-        ChatConfigResp chatConfigResp = configResps.get(0);
-        if (Objects.isNull(chatConfigResp.getChatDetailConfig()) || Objects.isNull(
-                chatConfigResp.getChatDetailConfig().getChatDefaultConfig())) {
-            return null;
-        }
-
-        ChatDefaultConfigReq chatDefaultConfig = chatConfigResp.getChatDetailConfig().getChatDefaultConfig();
-        Integer unit = chatDefaultConfig.getUnit();
-        String period = chatDefaultConfig.getPeriod();
-        if (Objects.nonNull(unit)) {
-            DatePeriodEnum datePeriodEnum = DatePeriodEnum.get(period);
-            if (Objects.isNull(datePeriodEnum)) {
-                return DateUtils.getBeforeDate(unit);
-            } else {
-                return DateUtils.getBeforeDate(unit, datePeriodEnum);
-            }
-        }
-        return null;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/parser/llm/dsl/DSLParseResult.java

@@ -1,25 +0,0 @@
-package com.tencent.supersonic.chat.parser.llm.dsl;
-
-import com.tencent.supersonic.chat.agent.tool.DslTool;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.chat.query.llm.dsl.LLMReq;
-import com.tencent.supersonic.chat.query.llm.dsl.LLMResp;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class DSLParseResult {
-
-    private LLMReq llmReq;
-
-    private LLMResp llmResp;
-
-    private QueryReq request;
-
-    private DslTool dslTool;
-}