(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

@@ -1,4 +1,4 @@
-name: supersonic CI
+name: supersonic ubuntu CI
 
 on:
   push:

.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/
@@ -17,4 +18,5 @@ assembly/runtime/*
 **/.flattened-pom.xml
 chm_db/
 __pycache__/
-/dict
+/dict
+assembly/build/*-SNAPSHOT

CHANGELOG.md

@@ -4,6 +4,37 @@
 - "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

README.md

@@ -2,31 +2,39 @@
 
 ![Java CI](https://github.com/tencentmusic/supersonic/workflows/supersonic%20CI/badge.svg)
 
-# SuperSonic (超音数)
+# SuperSonic
 
-**SuperSonic is the next-generation LLM-powered data analytics platform that integrates ChatBI and HeadlessBI**. 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 entities/metrics/dimensions/tags, 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 **highly extensible**, allowing custom functionalities to be added and configured with Java SPI.
+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 into SQL (so called Text2SQL or NL2SQL). While some approaches exhibit promising results, their **reliability** and **efficiency** are insufficient for real-world applications.  
+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: 
-1. Integrate ChatBI with HeadlessBI encapsulating underlying data context (joins, keys, formulas, etc) to **reduce complexity**.
-2. Augment the LLM with schema mappers(as a kind of preprocessor) and semantic correctors(as a kind of postprocessor) to **mitigate hallucination**.
-3. Utilize rule-based schema parsers when necessary to **improve efficiency**(in terms of latency and cost).
+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.
 
-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 ChatBI, 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 ChatBI interface for *business users* to enter natural language queries
-- Built-in HeadlessBI interface for *analytics engineers* to build semantic models
-- Built-in GUI for *system administrators* to manage chat agents and third-party plugins
-- Support input auto-completion as well as query recommendation
-- Support multi-turn conversation and history context management 
-- Support four-level permission control: domain-level, model-level, column-level and row-level
+- Built-in Chat BI interface for *business users* to enter natural language queries
+- Built-in Headless BI interface for *analytics engineers* to build semantic data models
+- Built-in rule-based semantic parser to improve efficiency in certain scenarios (e.g. demonstration, integration testing)
+- Built-in support for input auto-completion, multi-turn conversation as well as post-query recommendation
+- Built-in support for three-level data access control: dataset-level, column-level and row-level
 
 ## Extensible Components
 
@@ -38,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 Interpreter:** performs execution according to extracted semantic information. It generates SQL statements 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.
 

README_CN.md

@@ -1,28 +1,36 @@
-# SuperSonic (超音数)
+# SuperSonic
 
-**SuperSonic融合ChatBI和HeadlessBI打造新一代的数据分析平台**。通过SuperSonic的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。SuperSonic不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（指标/维度/实体的定义，以及他们的业务含义、相互间关系等），即可开启数据问答体验。与此同时，SuperSonic被设计为可插拔的框架，采用Java SPI机制来扩展定制功能。
+**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。尽管一些方法显示出有希望的结果，但它们在大规模实际应用中的可靠性还不足。
 
-在我们看来，为了在实际场景发挥价值，有三个关键点：
-1. 融合HeadlessBI，通过统一语义层封装底层数据细节（关联、键值、公式等），降低SQL生成的**复杂度**。
-2. 通过一前一后的模式映射器和语义修正器，来缓解LLM常见的**幻觉**现象。
-3. 设计启发式的规则，在一些特定场景提升语义解析的**效率**。
+与此同时，另一种新兴范式被称为Headless BI，它专注于构建统一的语义数据模型，并引起了广泛的关注。Headless BI通过一个通用的语义层来实现，通过开放的API公开一致的数据语义。
+
+从我们的角度来看，Chat BI和Headless BI的融合有潜力在两个方面增强Text2SQL的能力：
+
+1. 将数据语义（如业务术语、列值等）纳入提示词中，使LLM能够更好地理解语义，以**减少幻觉**。
+2. 将高级SQL语法（如连接、公式等）的生成从LLM卸载到语义层，以**减少复杂度**。
 
 为了验证上述想法，我们开发了SuperSonic项目，并将其应用在实际的内部产品中。与此同时，我们将SuperSonic作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
 
 ## 开箱即用的特性
 
-- 内置ChatBI界面以便*业务用户*输入数据查询。
-- 内置HeadlessBI界面以便*分析工程师*构建语义模型。
-- 内置图形用户界面以便*系统管理员*管理第三方插件和对话助理。
-- 支持文本输入的联想和查询问题的推荐。
-- 支持多轮对话，根据语境自动切换上下文。
-- 支持四级权限控制：主题域级、模型级、列级、行级。
+- 内置Chat BI界面以便*业务用户*输入数据查询。
+- 内置Headless BI界面以便*分析工程师*构建语义模型。
+- 内置基于规则的语义解析器，在特定场景（比如DEMO演示、集成测试）可以提升推理效率。
+- 支持文本输入联想、多轮对话、查询后问题推荐等高级特征。
+- 支持三级权限控制：数据集级、列级、行级。
 
 ## 易于扩展的组件
 
@@ -34,11 +42,11 @@ SuperSonic的整体架构和主流程如下图所示：
 
 - **模式映射器(Schema Mapper)：** 将自然语言文本在知识库中进行匹配，为后续的语义解析提供相关信息。
 
-- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，其由一组基于规则和基于模型的解析器组成，每个解析器可应对不同的特定场景。
+- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，生成语义查询语句S2SQL。
 
-- **语义修正器(Semantic Corrector)：** 检查语义信息的合法性，对不合法的信息做修正和优化处理。
+- **语义修正器(Semantic Corrector)：** 检查语义查询语句的合法性，对不合法的信息做修正和优化处理。
 
-- **语义解释器(Semantic Interpreter)：** 根据语义信息生成物理SQL执行查询。
+- **语义翻译器(Semantic Translator)：** 将语义查询语句翻译成可在物理数据模型上执行的SQL语句。
 
 - **问答插件(Chat Plugin)：** 通过第三方工具扩展功能。给定所有配置的插件及其功能描述和示例问题，大语言模型将选择最合适的插件。
 

assembly/bin/supersonic-build.bat

@@ -1,72 +1,98 @@
 @echo off
-setlocal
+setlocal enabledelayedexpansion
 chcp 65001
-set "sbinDir=%~dp0"
-set "baseDir=%~dp0.."
-set "buildDir=%baseDir%\build"
-set "runtimeDir=%baseDir%\..\runtime"
-set "pip_path=pip3"
+
+call supersonic-common.bat %*
+
 set "service=%~1"
 
-
-rem 1. build backend java modules
-del /q "%buildDir%\*.tar.gz" 2>NUL
-call mvn -f "%baseDir%\..\pom.xml" clean package -DskipTests
-
-IF ERRORLEVEL 1 (
-    ECHO Failed to build backend Java modules.
-    EXIT /B 1
+cd %projectDir%
+if "%service%"=="" (
+    set service=%standalone_service%
 )
 
-rem 2. move package to build
-echo f|xcopy "%baseDir%\..\launchers\standalone\target\*.tar.gz" "%buildDir%\supersonic-standalone.tar.gz"
+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 3. build frontend webapp
-cd "%baseDir%\..\webapp"
-call start-fe-prod.bat
-copy /y "%baseDir%\..\webapp\supersonic-webapp.tar.gz" "%buildDir%\"
 
-IF ERRORLEVEL 1 (
-    ECHO Failed to build frontend webapp.
-    EXIT /B 1
+if "%service%"=="%pyllm_service%" (
+   echo start installing python modules required by supersonic-pyllm: %pip_path%
+   %pip_path% install -r %projectDir%\headless\python\requirements.txt"
+   echo install python modules success
+   goto :EOF
+) else if "%service%"=="webapp" (
+   call :buildWebapp
+   tar xvf supersonic-webapp.tar.gz
+   move /y supersonic-webapp webapp
+   move /y webapp %projectDir%\launchers\%STANDALONE_SERVICE%\target\classes
+   goto :EOF
+) else (
+   call :buildJavaService
+   call :buildWebapp
+   call :packageRelease
+   goto :EOF
 )
 
-rem 4. copy webapp to java classpath
-cd "%buildDir%"
-tar -zxvf supersonic-webapp.tar.gz
-move supersonic-webapp webapp
-move webapp ..\..\launchers\standalone\target\classes
 
-rem 5. build backend python modules
-if "%service%"=="pyllm" (
-    echo "start installing python modules with pip: ${pip_path}"
-    set requirementPath="%baseDir%/../chat/python/requirements.txt"
-    %pip_path% install -r %requirementPath%
-    echo "install python modules success"
-)
+:buildJavaService
+   set "model_name=%service%"
+   echo "starting building supersonic-%model_name% service"
+   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
 
-call :BUILD_RUNTIME
 
-:BUILD_RUNTIME
-  rem 6. reset runtime
-  IF EXIST "%runtimeDir%" (
-      echo begin to delete dir : %runtimeDir%
-      rd /s /q "%runtimeDir%"
-  ) ELSE (
-      echo %runtimeDir% does not exist, create directly
-  )
-  mkdir "%runtimeDir%"
-  tar -zxvf "%buildDir%\supersonic-standalone.tar.gz" -C "%runtimeDir%"
-  for /d %%f in ("%runtimeDir%\launchers-standalone-*") do (
-      move "%%f" "%runtimeDir%\supersonic-standalone"
-  )
+: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
 
-  rem 7. copy webapp to runtime
-  tar -zxvf "%buildDir%\supersonic-webapp.tar.gz" -C "%buildDir%"
-  if not exist "%runtimeDir%\supersonic-standalone\webapp" mkdir "%runtimeDir%\supersonic-standalone\webapp"
-  xcopy /s /e /h /y "%buildDir%\supersonic-webapp\*" "%runtimeDir%\supersonic-standalone\webapp"
-  if not exist "%runtimeDir%\supersonic-standalone\conf\webapp" mkdir "%runtimeDir%\supersonic-standalone\conf\webapp"
-  xcopy /s /e /h /y "%runtimeDir%\supersonic-standalone\webapp\*" "%runtimeDir%\supersonic-standalone\conf\webapp"
-  rd /s /q "%buildDir%\supersonic-webapp"
+
+: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,58 +1,80 @@
 #!/usr/bin/env bash
 
-set -x
 sbinDir=$(cd "$(dirname "$0")"; pwd)
 chmod +x $sbinDir/supersonic-common.sh
 source $sbinDir/supersonic-common.sh
+cd $projectDir
+MVN_VERSION=$(mvn help:evaluate -Dexpression=project.version | grep -e '^[^\[]')
+
 cd $baseDir
-
 service=$1
-#1. build backend java modules
-rm -fr ${buildDir}/*.tar.gz
-rm -fr dist
-set +x
-mvn -f $baseDir/../ clean package -DskipTests
-# check build result
-if [ $? -ne 0 ]; then
-    echo "Failed to build backend Java modules."
-    exit 1
+if [ -z "$service"  ]; then
+  service=${STANDALONE_SERVICE}
 fi
 
-#2. move package to build
-cp $baseDir/../launchers/headless/target/*.tar.gz ${buildDir}/supersonic-headless.tar.gz
-cp $baseDir/../launchers/chat/target/*.tar.gz ${buildDir}/supersonic-chat.tar.gz
-cp $baseDir/../launchers/standalone/target/*.tar.gz ${buildDir}/supersonic-standalone.tar.gz
+function buildJavaService {
+  model_name=$1
+  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"
+}
 
-#3. build frontend webapp
-chmod +x $baseDir/../webapp/start-fe-prod.sh
-cd ../webapp
-sh ./start-fe-prod.sh
-cp -fr  ./supersonic-webapp.tar.gz ${buildDir}/
+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"
+}
 
-# check build result
-if [ $? -ne 0 ]; then
-    echo "Failed to build frontend webapp."
-    exit 1
-fi
-#4. copy webapp to java classpath
-cd $buildDir
-tar xvf supersonic-webapp.tar.gz
-mv supersonic-webapp webapp
-cp -fr webapp ../../launchers/headless/target/classes
-cp -fr webapp ../../launchers/chat/target/classes
-cp -fr webapp ../../launchers/standalone/target/classes
-rm -fr  ${buildDir}/webapp
+function packageRelease {
+  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"
+}
 
-#5. build backend python modules
-if [ "$service" == "pyllm" ]; then
-  echo "start installing python modules with pip: ${pip_path}"
-  requirementPath=$baseDir/../chat/python/requirements.txt
+#1. build backend services
+if [ "$service" == $PYLLM_SERVICE ]; then
+  echo "start installing python modules required by supersonic-pyllm: ${pip_path}"
+  requirementPath=$projectDir/headless/python/requirements.txt
   ${pip_path} install -r ${requirementPath}
   echo "install python modules success"
-fi
-
-#6. reset runtime
-rm -fr $runtimeDir/supersonic*
-moveAllToRuntime
-setEnvToWeb chat
-setEnvToWeb headless
+elif [ "$service" == "webapp" ]; then
+  buildWebapp
+  target_path=$projectDir/launchers/$STANDALONE_SERVICE/target/classes
+  tar xvf $projectDir/webapp/supersonic-webapp.tar.gz -C $target_path
+  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

@@ -6,105 +6,19 @@ pip_path=${PIP_PATH:-"pip3"}
 
 sbinDir=$(cd "$(dirname "$0")"; pwd)
 baseDir=$(cd "$sbinDir/.." && pwd -P)
-runtimeDir=$baseDir/../runtime
+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"
-
-function setEnvToWeb {
-   model_name=$1
-   json='{"env": "'$model_name'"}'
-   echo $json > ${runtimeDir}/supersonic-${model_name}/webapp/supersonic.config.json
-   echo $json > $baseDir/../launchers/${model_name}/target/classes/webapp/supersonic.config.json
-}
-
-function moveToRuntime {
-  model_name=$1
-  file="${buildDir}/supersonic-${model_name}.tar.gz"
-  if [ -f "$file" ]; then
-    tar -zxvf "$file" -C ${runtimeDir}
-    mv ${runtimeDir}/launchers-${model_name}-* ${runtimeDir}/supersonic-${model_name}
-    mkdir -p ${runtimeDir}/supersonic-${model_name}/webapp
-    cp -fr ${buildDir}/webapp/* ${runtimeDir}/supersonic-${model_name}/webapp
-  else
-    echo "File $file does not exist. Skipping the move to runtime."
-  fi
-}
-
-function moveAllToRuntime {
-  mkdir -p ${runtimeDir}
-  tar xvf  ${buildDir}/supersonic-webapp.tar.gz  -C ${buildDir}
-  mv ${buildDir}/supersonic-webapp ${buildDir}/webapp
-
-  moveToRuntime chat
-  moveToRuntime headless
-  moveToRuntime standalone
-  rm -fr  ${buildDir}/webapp
-}
-
-# run java service
-function runJavaService {
-  javaRunDir=${runtimeDir}/supersonic-${model_name}
-  local_app_name=$1
-  libDir=$javaRunDir/lib
-  confDir=$javaRunDir/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
-}
-
-# run python service
-function runPythonService {
-  pythonRunDir=${runtimeDir}/supersonic-${model_name}/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
-}

assembly/bin/supersonic-daemon.bat

@@ -1,118 +1,102 @@
 @echo off
 setlocal
 chcp 65001
-set "sbinDir=%~dp0"
-set "baseDir=%~dp0.."
-set "runtimeDir=%baseDir%\..\runtime"
-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 "javaRunDir=%runtimeDir%\supersonic-standalone"
-set "pythonRunDir=%runtimeDir%\supersonic-standalone\pyllm"
+call supersonic-common.bat %*
+call %sbinDir%/../conf/supersonic-env.bat %*
 
 set "command=%~1"
 set "service=%~2"
-
 if "%service%"=="" (
    set "service=%standalone_service%"
 )
-
+set "model_name=%service%"
 IF "%service%"=="pyllm" (
-  SET "llmProxy=PythonLLMProxy"
+  set "llmProxy=PythonLLMProxy"
+  set "model_name=%standalone_service%"
 )
 
-call :BUILD_RUNTIME
+cd %baseDir%
 
 if "%command%"=="restart" (
-   call :STOP
-   call :START
+   call :stop
+   call :start
    goto :EOF
 ) else if "%command%"=="start" (
-   call :START
+   call :start
    goto :EOF
 ) else if "%command%"=="stop" (
-  call :STOP
-  goto :EOF
+   call :stop
+   goto :EOF
 ) else if "%command%"=="reload" (
-  call :RELOAD_EXAMPLE
-  goto :EOF
+   call :reloadExamples
+   goto :EOF
 ) else (
    echo "Use command {start|stop|restart} to run."
    goto :EOF
 )
 
-:START
-    if "%service%"=="%pyllm_service%" (
-         call :START_PYTHON
-         call :START_JAVA
+
+: start
+   if "%service%"=="%pyllm_service%" (
+         call :runPythonService
+         call :runJavaService
          goto :EOF
-    )
-    call :START_JAVA
-    goto :EOF
-
-:STOP
-    call :STOP_PYTHON
-    call :STOP_JAVA
-    goto :EOF
-
-:START_PYTHON
-   echo 'python service starting, see logs in pyllm/pyllm.log'
-   cd "%pythonRunDir%"
-   start /B %python_path% supersonic_pyllm.py  > %pythonRunDir%\pyllm.log 2>&1
-   timeout /t 10 >nul
-   echo 'python service started'
+   )
+   call :runJavaService
    goto :EOF
 
-:START_JAVA
-  echo 'java service starting, see logs in logs/'
-   cd "%javaRunDir%"
-   if not exist "%runtimeDir%\supersonic-standalone\logs" mkdir "%runtimeDir%\supersonic-standalone\logs"
-   set "libDir=%runtimeDir%\supersonic-standalone\lib"
-   set "confDir=%runtimeDir%\supersonic-standalone\conf"
-   set "webDir=%runtimeDir%\supersonic-standalone\webapp"
-   set "classpath=%confDir%;%webDir%;%libDir%\*"
+
+: stop
+   call :stopPythonService
+   call :stopJavaService
+   goto :EOF
+
+
+: reloadExamples
+   set "pythonRunDir=%baseDir%\pyllm"
+   cd "%pythonRunDir%\sql"
+   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
 
-:STOP_PYTHON
+
+: 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
 
-:STOP_JAVA
+
+: 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
 
-:RELOAD_EXAMPLE
-   cd "%runtimeDir%\supersonic-standalone\pyllm\sql"
-   start  %python_path% examples_reload_run.py
-   goto :EOF
-
-:BUILD_RUNTIME
-  rem 6. reset runtime
-  if exist "%runtimeDir%" goto :EOF
-  mkdir "%runtimeDir%"
-  tar -zxvf "%buildDir%\supersonic-standalone.tar.gz" -C "%runtimeDir%"
-  for /d %%f in ("%runtimeDir%\launchers-standalone-*") do (
-      move "%%f" "%runtimeDir%\supersonic-standalone"
-  )
-
-  rem 7. copy webapp to runtime
-  tar -zxvf "%buildDir%\supersonic-webapp.tar.gz" -C "%buildDir%"
-  if not exist "%runtimeDir%\supersonic-standalone\webapp" mkdir "%runtimeDir%\supersonic-standalone\webapp"
-  xcopy /s /e /h /y "%buildDir%\supersonic-webapp\*" "%runtimeDir%\supersonic-standalone\webapp"
-  if not exist "%runtimeDir%\supersonic-standalone\conf\webapp" mkdir "%runtimeDir%\supersonic-standalone\conf\webapp"
-  xcopy /s /e /h /y "%runtimeDir%\supersonic-standalone\webapp\*" "%runtimeDir%\supersonic-standalone\conf\webapp"
-  rd /s /q "%buildDir%\supersonic-webapp"
+endlocal

assembly/bin/supersonic-daemon.sh

@@ -1,16 +1,11 @@
 #!/usr/bin/env bash
 
-set -x
 sbinDir=$(cd "$(dirname "$0")"; pwd)
-chmod +x $sbinDir/supersonic-common.sh
 source $sbinDir/supersonic-common.sh
 
-# 1.init environment parameters
-if [ ! -d "$runtimeDir" ]; then
-    echo "the runtime dir does not exist move all to runtime"
-    moveAllToRuntime
-fi
-set +x
+set -a
+source $sbinDir/../conf/supersonic-env.sh
+set +a
 
 command=$1
 service=$2
@@ -18,44 +13,93 @@ if [ -z "$service"  ]; then
   service=${STANDALONE_SERVICE}
 fi
 
-app_name=$STANDALONE_APP_NAME
-main_class="com.tencent.supersonic.StandaloneLauncher"
 model_name=$service
-
 if [ "$service" == "pyllm" ]; then
   model_name=${STANDALONE_SERVICE}
   export llmProxy=PythonLLMProxy
 fi
-
 cd $baseDir
 
-# 2.set main class
 function setMainClass {
   if [ "$service" == $CHAT_SERVICE ]; then
     main_class="com.tencent.supersonic.ChatLauncher"
   elif [ "$service" == $HEADLESS_SERVICE ]; then
     main_class="com.tencent.supersonic.HeadlessLauncher"
+  else
+    main_class="com.tencent.supersonic.StandaloneLauncher"
   fi
 }
-setMainClass
-# 3.set app name
+
 function setAppName {
   if [ "$service" == $CHAT_SERVICE ]; then
     app_name=$CHAT_APP_NAME
   elif [ "$service" == $HEADLESS_SERVICE ]; then
     app_name=$HEADLESS_APP_NAME
-  elif [ "$service" == $PYLLM_SERVICE ]; then
-    app_name=$PYLLM_APP_NAME
+  else
+    app_name=$STANDALONE_APP_NAME
   fi
 }
-setAppName
 
 function reloadExamples {
-  pythonRunDir=${runtimeDir}/supersonic-${model_name}/pyllm
-  cd $pythonRunDir/sql
+  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()
 {
@@ -93,18 +137,16 @@ function reload()
   fi
 }
 
-# 4. execute command operation
+setMainClass
+setAppName
 case "$command" in
   start)
         if [ "$service" == $PYLLM_SERVICE ]; then
-          echo  "Starting $app_name"
-          start $app_name
-          echo  "Starting $STANDALONE_APP_NAME"
-          start $STANDALONE_APP_NAME
-        else
-          echo  "Starting $app_name"
-          start $app_name
+          echo  "Starting $PYLLM_APP_NAME"
+          start $PYLLM_APP_NAME
         fi
+        echo  "Starting ${app_name}"
+        start ${app_name}
         echo  "Start success"
         ;;
   stop)
@@ -121,20 +163,15 @@ case "$command" in
         ;;
   restart)
         if [ "$service" == $PYLLM_SERVICE ]; then
-          echo  "Stopping ${app_name}"
-          stop ${app_name}
-          echo  "Stopping ${STANDALONE_APP_NAME}"
-          stop $STANDALONE_APP_NAME
-          echo  "Starting ${app_name}"
-          start ${app_name}
-          echo  "Starting ${STANDALONE_APP_NAME}"
-          start $STANDALONE_APP_NAME
-        else
-          echo  "Stopping ${app_name}"
-          stop ${app_name}
-          echo  "Starting ${app_name}"
-          start ${app_name}
+          echo  "Stopping $PYLLM_APP_NAME"
+          stop $PYLLM_APP_NAME
+          echo  "Starting $PYLLM_APP_NAME"
+          start $PYLLM_APP_NAME
         fi
+        echo  "Stopping ${app_name}"
+        stop ${app_name}
+        echo  "Starting ${app_name}"
+        start ${app_name}
         echo  "Restart success"
         ;;
   *)

assembly/build/build.xml

@@ -21,11 +21,17 @@
             </includes>
         </fileSet>
         <fileSet>
-            <directory>${project.basedir}/../../chat/python</directory>
+            <directory>${project.basedir}/../../headless/python</directory>
             <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>
     </fileSets>
 
     <dependencySets>

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

@@ -24,6 +24,10 @@ public class User {
         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", 1);
     }

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

@@ -2,8 +2,8 @@ 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.SysParameter;
-import com.tencent.supersonic.common.service.SysParameterService;
+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;
 
@@ -20,10 +20,10 @@ public final class UserHolder {
 
     public static User findUser(HttpServletRequest request, HttpServletResponse response) {
         User user = REPO.findUser(request, response);
-        SysParameterService sysParameterService = ContextUtils.getBean(SysParameterService.class);
-        SysParameter sysParameter = sysParameterService.getSysParameter();
-        if (!CollectionUtils.isEmpty(sysParameter.getAdmins())
-                && sysParameter.getAdmins().contains(user.getName())) {
+        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/authentication/src/main/java/com/tencent/supersonic/auth/authentication/service/UserServiceImpl.java

@@ -6,8 +6,8 @@ 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.SysParameter;
-import com.tencent.supersonic.common.service.SysParameterService;
+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;
@@ -18,9 +18,9 @@ import java.util.Set;
 @Service
 public class UserServiceImpl implements UserService {
 
-    private SysParameterService sysParameterService;
+    private SystemConfigService sysParameterService;
 
-    public UserServiceImpl(SysParameterService sysParameterService) {
+    public UserServiceImpl(SystemConfigService sysParameterService) {
         this.sysParameterService = sysParameterService;
     }
 
@@ -28,9 +28,9 @@ public class UserServiceImpl implements UserService {
     public User getCurrentUser(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
         User user = UserHolder.findUser(httpServletRequest, httpServletResponse);
         if (user != null) {
-            SysParameter sysParameter = sysParameterService.getSysParameter();
-            if (!CollectionUtils.isEmpty(sysParameter.getAdmins())
-                    && sysParameter.getAdmins().contains(user.getName())) {
+            SystemConfig systemConfig = sysParameterService.getSystemConfig();
+            if (!CollectionUtils.isEmpty(systemConfig.getAdmins())
+                    && systemConfig.getAdmins().contains(user.getName())) {
                 user.setIsAdmin(1);
             }
         }

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

@@ -1,98 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import com.google.common.collect.Sets;
-import com.tencent.supersonic.common.pojo.ModelRela;
-import lombok.Data;
-import org.springframework.util.CollectionUtils;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-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 Set<SchemaElement> tags = new HashSet<>();
-    private SchemaElement entity = new SchemaElement();
-    private List<ModelRela> modelRelas = new ArrayList<>();
-
-    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;
-            case TAG:
-                element = tags.stream().filter(e -> e.getId() == elementID).findFirst();
-                break;
-            default:
-        }
-
-        if (element.isPresent()) {
-            return element.get();
-        } else {
-            return null;
-        }
-    }
-
-    public SchemaElement getElement(SchemaElementType elementType, String name) {
-        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 -> name.equals(e.getName())).findFirst();
-                break;
-            case DIMENSION:
-                element = dimensions.stream().filter(e -> name.equals(e.getName())).findFirst();
-                break;
-            case VALUE:
-                element = dimensionValues.stream().filter(e -> name.equals(e.getName())).findFirst();
-                break;
-            default:
-        }
-
-        if (element.isPresent()) {
-            return element.get();
-        } else {
-            return null;
-        }
-    }
-
-    public Set<Long> getModelClusterSet() {
-        if (CollectionUtils.isEmpty(modelRelas)) {
-            return Sets.newHashSet();
-        }
-        Set<Long> modelClusterSet = new HashSet<>();
-        modelRelas.forEach(modelRela -> {
-            modelClusterSet.add(modelRela.getToModelId());
-            modelClusterSet.add(modelRela.getFromModelId());
-        });
-        return modelClusterSet;
-    }
-
-}

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/SchemaModelClusterMapInfo.java

@@ -1,61 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import com.clickhouse.client.internal.apache.commons.compress.utils.Lists;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import lombok.Data;
-import org.springframework.util.CollectionUtils;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-@Data
-public class SchemaModelClusterMapInfo {
-
-    private Map<String, List<SchemaElementMatch>> modelElementMatches = new HashMap<>();
-
-    public Set<String> getMatchedModelClusters() {
-        return modelElementMatches.keySet();
-    }
-
-    public List<SchemaElementMatch> getMatchedElements(Long modelId) {
-        for (String key : modelElementMatches.keySet()) {
-            if (ModelCluster.getModelIdFromKey(key).contains(modelId)) {
-                return modelElementMatches.get(key);
-            }
-        }
-        return Lists.newArrayList();
-    }
-
-    public List<SchemaElementMatch> getMatchedElements(String modelCluster) {
-        return modelElementMatches.get(modelCluster);
-    }
-
-    public Map<String, List<SchemaElementMatch>> getModelElementMatches() {
-        return modelElementMatches;
-    }
-
-    public Map<String, List<SchemaElementMatch>> getElementMatchesByModelIds(Set<Long> modelIds) {
-        if (CollectionUtils.isEmpty(modelIds)) {
-            return modelElementMatches;
-        }
-        Map<String, List<SchemaElementMatch>> modelElementMatchesFiltered = new HashMap<>();
-        for (String key : modelElementMatches.keySet()) {
-            for (Long modelId : modelIds) {
-                if (ModelCluster.getModelIdFromKey(key).contains(modelId)) {
-                    modelElementMatchesFiltered.put(key, modelElementMatches.get(key));
-                }
-            }
-        }
-        return modelElementMatchesFiltered;
-    }
-
-    public void setModelElementMatches(Map<String, List<SchemaElementMatch>> modelElementMatches) {
-        this.modelElementMatches = modelElementMatches;
-    }
-
-    public void setMatchedElements(String modelCluster, List<SchemaElementMatch> elementMatches) {
-        modelElementMatches.put(modelCluster, elementMatches);
-    }
-}

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

@@ -1,189 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashMap;
-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 org.springframework.util.CollectionUtils;
-
-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 SchemaElement getElement(SchemaElementType elementType, long elementID) {
-        Optional<SchemaElement> element = Optional.empty();
-
-        switch (elementType) {
-            case ENTITY:
-                element = getElementsById(elementID, getEntities());
-                break;
-            case MODEL:
-                element = getElementsById(elementID, getModels());
-                break;
-            case METRIC:
-                element = getElementsById(elementID, getMetrics());
-                break;
-            case DIMENSION:
-                element = getElementsById(elementID, getDimensions());
-                break;
-            case VALUE:
-                element = getElementsById(elementID, getDimensionValues());
-                break;
-            default:
-        }
-
-        if (element.isPresent()) {
-            return element.get();
-        } else {
-            return null;
-        }
-    }
-
-    public SchemaElement getElementByName(SchemaElementType elementType, String name) {
-        Optional<SchemaElement> element = Optional.empty();
-
-        switch (elementType) {
-            case ENTITY:
-                element = getElementsByNameOrAlias(name, getEntities());
-                break;
-            case MODEL:
-                element = getElementsByNameOrAlias(name, getModels());
-                break;
-            case METRIC:
-                element = getElementsByNameOrAlias(name, getMetrics());
-                break;
-            case DIMENSION:
-                element = getElementsByNameOrAlias(name, getDimensions());
-                break;
-            case VALUE:
-                element = getElementsByNameOrAlias(name, getDimensionValues());
-                break;
-            default:
-        }
-
-        if (element.isPresent()) {
-            return element.get();
-        } else {
-            return null;
-        }
-    }
-
-    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> getDimensions(Set<Long> modelIds) {
-        List<SchemaElement> dimensions = getDimensions();
-        return getElementsByModelId(modelIds, dimensions);
-    }
-
-    public SchemaElement getDimensions(Long id) {
-        List<SchemaElement> dimensions = getDimensions();
-        Optional<SchemaElement> dimension = getElementsById(id, dimensions);
-        return dimension.orElse(null);
-    }
-
-    public List<SchemaElement> getTags() {
-        List<SchemaElement> tags = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> tags.addAll(d.getTags()));
-        return tags;
-    }
-
-    public List<SchemaElement> getTags(Set<Long> modelIds) {
-        List<SchemaElement> tags = new ArrayList<>();
-        modelSchemaList.stream().filter(schemaElement ->
-                        modelIds.contains(schemaElement.getModel().getModel()))
-                .forEach(d -> tags.addAll(d.getTags()));
-        return tags;
-    }
-
-    public List<SchemaElement> getMetrics() {
-        List<SchemaElement> metrics = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> metrics.addAll(d.getMetrics()));
-        return metrics;
-    }
-
-    public List<SchemaElement> getMetrics(Set<Long> modelIds) {
-        List<SchemaElement> metrics = getMetrics();
-        return getElementsByModelId(modelIds, metrics);
-    }
-
-    public List<SchemaElement> getEntities() {
-        List<SchemaElement> entities = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> entities.add(d.getEntity()));
-        return entities;
-    }
-
-    public List<SchemaElement> getEntities(Set<Long> modelIds) {
-        List<SchemaElement> entities = getEntities();
-        return getElementsByModelId(modelIds, entities);
-    }
-
-    private List<SchemaElement> getElementsByModelId(Set<Long> modelIds, List<SchemaElement> elements) {
-        return elements.stream()
-                .filter(schemaElement -> modelIds.contains(schemaElement.getModel()))
-                .collect(Collectors.toList());
-    }
-
-    private Optional<SchemaElement> getElementsById(Long id, List<SchemaElement> elements) {
-        return elements.stream()
-                .filter(schemaElement -> id.equals(schemaElement.getId()))
-                .findFirst();
-    }
-
-    private Optional<SchemaElement> getElementsByNameOrAlias(String name, List<SchemaElement> elements) {
-        return elements.stream()
-                .filter(schemaElement ->
-                        name.equals(schemaElement.getName()) || (Objects.nonNull(schemaElement.getAlias())
-                                && schemaElement.getAlias().contains(name))
-                ).findFirst();
-    }
-
-    public List<SchemaElement> getModels() {
-        List<SchemaElement> models = new ArrayList<>();
-        modelSchemaList.stream().forEach(d -> models.add(d.getModel()));
-        return models;
-    }
-
-    public Map<String, String> getBizNameToName(Set<Long> modelIds) {
-        List<SchemaElement> allElements = new ArrayList<>();
-        allElements.addAll(getDimensions(modelIds));
-        allElements.addAll(getMetrics(modelIds));
-        return allElements.stream()
-                .collect(Collectors.toMap(SchemaElement::getBizName, SchemaElement::getName, (k1, k2) -> k1));
-    }
-
-    public Map<Long, ModelSchema> getModelSchemaMap() {
-        if (CollectionUtils.isEmpty(modelSchemaList)) {
-            return new HashMap<>();
-        }
-        return modelSchemaList.stream().collect(Collectors.toMap(modelSchema
-                -> modelSchema.getModel().getModel(), modelSchema -> modelSchema));
-    }
-}

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

@@ -16,16 +16,6 @@ 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

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;
+    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

@@ -1,15 +1,16 @@
 package com.tencent.supersonic.chat.api.pojo.request;
 
-
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
 import com.tencent.supersonic.common.pojo.DateConf;
-import java.util.HashSet;
-import java.util.Set;
+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 QueryDataReq {
+public class ChatQueryDataReq {
     private User user;
     private Set<SchemaElement> metrics = new HashSet<>();
     private Set<SchemaElement> dimensions = new HashSet<>();

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

@@ -1,23 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.request;
-
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.ToString;
-
-import javax.validation.constraints.NotNull;
-import java.util.List;
-
-import static java.time.LocalDate.now;
-
-@ToString
-@Data
-@NoArgsConstructor
-public class DictLatestTaskReq {
-
-    @NotNull
-    private Long modelId;
-
-    private List<Long> dimIds;
-
-    private String createdAt = now().plusDays(-4).toString();
-}

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

@@ -1,20 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.request;
-
-import com.tencent.supersonic.common.pojo.enums.TaskStatusEnum;
-import lombok.Data;
-import lombok.ToString;
-
-@ToString
-@Data
-public class DictTaskFilterReq {
-
-    private Long id;
-
-    private String name;
-
-    private String createdBy;
-
-    private String createdAt;
-
-    private TaskStatusEnum status;
-}

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/SimilarQueryReq.java

@@ -18,7 +18,7 @@ public class SimilarQueryReq {
 
     private String queryText;
 
-    private String modelId;
+    private Long dataSetId;
 
     private Integer agentId;
 

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.chat.api.pojo.request.ChatDefaultConfigReq.TimeMode;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
 import com.tencent.supersonic.common.pojo.Constants;
+import com.tencent.supersonic.common.pojo.enums.TimeMode;
 import lombok.Data;
 
 import java.util.List;
@@ -21,7 +21,7 @@ public class ChatDefaultRichConfigResp {
     private Integer unit = 1;
 
     /**
-     * default time type: day
+     * default time type:
      * DAY, WEEK, MONTH, YEAR
      */
     private String period = Constants.DAY;

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/ParseResp.java

@@ -1,23 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo.response;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import lombok.Data;
-import java.util.List;
-
-@Data
-public class ParseResp {
-    private Integer chatId;
-    private String queryText;
-    private Long queryId;
-    private ParseState state;
-    private List<SemanticParseInfo> selectedParses = Lists.newArrayList();
-    private ParseTimeCostDO parseTimeCost = new ParseTimeCostDO();
-
-    public enum ParseState {
-        COMPLETED,
-        PENDING,
-        FAILED
-    }
-
-}

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

@@ -1,10 +1,12 @@
 package com.tencent.supersonic.chat.api.pojo.response;
 
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
+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 {
 
@@ -18,5 +20,4 @@ public class QueryResp {
     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

@@ -10,8 +10,6 @@ public class SimilarQueryRecallResp {
 
     private Long queryId;
 
-    private Integer parseId;
-
     private String queryText;
 
 }

chat/core/pom.xml

@@ -1,174 +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>com.hankcs</groupId>
-            <artifactId>hanlp</artifactId>
-            <version>${hanlp.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.apache.hadoop</groupId>
-            <artifactId>hadoop-client</artifactId>
-            <version>${hadoop.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.apache.zookeeper</groupId>
-                    <artifactId>zookeeper</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>javax.servlet</groupId>
-                    <artifactId>servlet-api</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.hadoop</groupId>
-            <artifactId>hadoop-hdfs</artifactId>
-            <version>${hadoop.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.apache.zookeeper</groupId>
-                    <artifactId>zookeeper</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>javax.servlet</groupId>
-                    <artifactId>servlet-api</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.hadoop</groupId>
-            <artifactId>hadoop-common</artifactId>
-            <version>${hadoop.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.slf4j</groupId>
-                    <artifactId>slf4j-log4j12</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>log4j</groupId>
-                    <artifactId>log4j</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.apache.zookeeper</groupId>
-                    <artifactId>zookeeper</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.apache.curator</groupId>
-                    <artifactId>*</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>javax.servlet</groupId>
-                    <artifactId>servlet-api</artifactId>
-                </exclusion>
-            </exclusions>
-        </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.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>com.alibaba</groupId>
-            <artifactId>druid</artifactId>
-            <version>${alibaba.druid.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <version>${h2.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>headless-api</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>headless-core</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>chat-api</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>
-        <dependency>
-            <groupId>com.tencent.supersonic</groupId>
-            <artifactId>headless-server</artifactId>
-            <version>${project.version}</version>
-            <scope>compile</scope>
-        </dependency>
-
-    </dependencies>
-
-</project>

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

@@ -1,8 +0,0 @@
-package com.tencent.supersonic.chat.core.agent;
-
-public enum AgentToolType {
-    NL2SQL_RULE,
-    NL2SQL_LLM,
-    PLUGIN,
-    ANALYTICS
-}

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

@@ -1,11 +0,0 @@
-package com.tencent.supersonic.chat.core.agent;
-
-import lombok.Data;
-
-
-@Data
-public class DataAnalyticsTool extends AgentTool {
-
-    private Long modelId;
-
-}

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

@@ -1,14 +0,0 @@
-package com.tencent.supersonic.chat.core.config;
-
-
-import com.tencent.supersonic.headless.api.response.DimSchemaResp;
-import com.tencent.supersonic.headless.api.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/core/config/OptimizationConfig.java

@@ -1,178 +0,0 @@
-package com.tencent.supersonic.chat.core.config;
-
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.common.service.SysParameterService;
-import lombok.Data;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-@Slf4j
-public class OptimizationConfig {
-
-    @Value("${one.detection.size:8}")
-    private Integer oneDetectionSize;
-
-    @Value("${one.detection.max.size:20}")
-    private Integer oneDetectionMaxSize;
-
-    @Value("${metric.dimension.min.threshold:0.3}")
-    private Double metricDimensionMinThresholdConfig;
-
-    @Value("${metric.dimension.threshold:0.3}")
-    private Double metricDimensionThresholdConfig;
-
-    @Value("${dimension.value.threshold:0.5}")
-    private Double dimensionValueThresholdConfig;
-
-    @Value("${long.text.threshold:0.8}")
-    private Double longTextThreshold;
-
-    @Value("${short.text.threshold:0.5}")
-    private Double shortTextThreshold;
-
-    @Value("${query.text.length.threshold:10}")
-    private Integer queryTextLengthThreshold;
-    @Value("${embedding.mapper.word.min:4}")
-    private int embeddingMapperWordMin;
-
-    @Value("${embedding.mapper.word.max:5}")
-    private int embeddingMapperWordMax;
-
-    @Value("${embedding.mapper.batch:50}")
-    private int embeddingMapperBatch;
-
-    @Value("${embedding.mapper.number:5}")
-    private int embeddingMapperNumber;
-
-    @Value("${embedding.mapper.round.number:10}")
-    private int embeddingMapperRoundNumber;
-
-    @Value("${embedding.mapper.distance.threshold:0.58}")
-    private Double embeddingMapperDistanceThreshold;
-
-    @Value("${s2SQL.linking.value.switch:true}")
-    private boolean useLinkingValueSwitch;
-
-    @Value("${s2SQL.generation:TWO_PASS_AUTO_COT}")
-    private SqlGenerationMode sqlGenerationMode;
-
-    @Value("${s2SQL.use.switch:true}")
-    private boolean useS2SqlSwitch;
-
-    @Value("${text2sql.example.num:15}")
-    private int text2sqlExampleNum;
-
-    @Value("${text2sql.fewShots.num:10}")
-    private int text2sqlFewShotsNum;
-
-    @Value("${text2sql.self.consistency.num:5}")
-    private int text2sqlSelfConsistencyNum;
-
-    @Value("${text2sql.collection.name:text2dsl_agent_collection}")
-    private String text2sqlCollectionName;
-
-    @Value("${parse.show.count:3}")
-    private Integer parseShowCount;
-
-    @Autowired
-    private SysParameterService sysParameterService;
-
-    public Integer getOneDetectionSize() {
-        return convertValue("one.detection.size", Integer.class, oneDetectionSize);
-    }
-
-    public Integer getOneDetectionMaxSize() {
-        return convertValue("one.detection.max.size", Integer.class, oneDetectionMaxSize);
-    }
-
-    public Double getMetricDimensionMinThresholdConfig() {
-        return convertValue("metric.dimension.min.threshold", Double.class, metricDimensionMinThresholdConfig);
-    }
-
-    public Double getMetricDimensionThresholdConfig() {
-        return convertValue("metric.dimension.threshold", Double.class, metricDimensionThresholdConfig);
-    }
-
-    public Double getDimensionValueThresholdConfig() {
-        return convertValue("dimension.value.threshold", Double.class, dimensionValueThresholdConfig);
-    }
-
-    public Double getLongTextThreshold() {
-        return convertValue("long.text.threshold", Double.class, longTextThreshold);
-    }
-
-    public Double getShortTextThreshold() {
-        return convertValue("short.text.threshold", Double.class, shortTextThreshold);
-    }
-
-    public Integer getQueryTextLengthThreshold() {
-        return convertValue("query.text.length.threshold", Integer.class, queryTextLengthThreshold);
-    }
-
-    public boolean isUseS2SqlSwitch() {
-        return convertValue("use.s2SQL.switch", Boolean.class, useS2SqlSwitch);
-    }
-
-    public Integer getEmbeddingMapperWordMin() {
-        return convertValue("embedding.mapper.word.min", Integer.class, embeddingMapperWordMin);
-    }
-
-    public Integer getEmbeddingMapperWordMax() {
-        return convertValue("embedding.mapper.word.max", Integer.class, embeddingMapperWordMax);
-    }
-
-    public Integer getEmbeddingMapperBatch() {
-        return convertValue("embedding.mapper.batch", Integer.class, embeddingMapperBatch);
-    }
-
-    public Integer getEmbeddingMapperNumber() {
-        return convertValue("embedding.mapper.number", Integer.class, embeddingMapperNumber);
-    }
-
-    public Integer getEmbeddingMapperRoundNumber() {
-        return convertValue("embedding.mapper.round.number", Integer.class, embeddingMapperRoundNumber);
-    }
-
-    public Double getEmbeddingMapperDistanceThreshold() {
-        return convertValue("embedding.mapper.distance.threshold", Double.class, embeddingMapperDistanceThreshold);
-    }
-
-    public boolean isUseLinkingValueSwitch() {
-        return convertValue("s2SQL.linking.value.switch", Boolean.class, useLinkingValueSwitch);
-    }
-
-    public SqlGenerationMode getSqlGenerationMode() {
-        return convertValue("s2SQL.generation", SqlGenerationMode.class, sqlGenerationMode);
-    }
-
-    public Integer getParseShowCount() {
-        return convertValue("parse.show.count", Integer.class, parseShowCount);
-    }
-
-    public <T> T convertValue(String paramName, Class<T> targetType, T defaultValue) {
-        try {
-            String value = sysParameterService.getSysParameter().getParameterByName(paramName);
-            if (StringUtils.isBlank(value)) {
-                return defaultValue;
-            }
-            if (targetType == Double.class) {
-                return targetType.cast(Double.parseDouble(value));
-            } else if (targetType == Integer.class) {
-                return targetType.cast(Integer.parseInt(value));
-            } else if (targetType == Boolean.class) {
-                return targetType.cast(Boolean.parseBoolean(value));
-            } else if (targetType == SqlGenerationMode.class) {
-                return targetType.cast(SqlGenerationMode.valueOf(value));
-            }
-        } catch (Exception e) {
-            log.error("convertValue", e);
-        }
-        return defaultValue;
-    }
-
-}

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

@@ -1,21 +0,0 @@
-package com.tencent.supersonic.chat.core.corrector;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
-import lombok.extern.slf4j.Slf4j;
-/**
- * Perform SQL corrections on the "From" section in S2SQL.
- */
-@Slf4j
-public class FromCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        String modelName = semanticParseInfo.getModel().getName();
-        String correctSql = SqlParserReplaceHelper
-                .replaceTable(semanticParseInfo.getSqlInfo().getCorrectS2SQL(), modelName);
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctSql);
-    }
-
-}

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

@@ -1,88 +0,0 @@
-package com.tencent.supersonic.chat.core.corrector;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
-import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-/**
- * Perform SQL corrections on the "Group by" section in S2SQL.
- */
-@Slf4j
-public class GroupByCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-
-        addGroupByFields(queryContext, semanticParseInfo);
-
-    }
-
-    private void addGroupByFields(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        Set<Long> modelIds = semanticParseInfo.getModel().getModelIds();
-
-        //add dimension group by
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String correctS2SQL = sqlInfo.getCorrectS2SQL();
-        SemanticSchema semanticSchema = queryContext.getSemanticSchema();
-        //add alias field name
-        Set<String> dimensions = semanticSchema.getDimensions(modelIds).stream()
-                .flatMap(
-                        schemaElement -> {
-                            Set<String> elements = new HashSet<>();
-                            elements.add(schemaElement.getName());
-                            if (!CollectionUtils.isEmpty(schemaElement.getAlias())) {
-                                elements.addAll(schemaElement.getAlias());
-                            }
-                            return elements.stream();
-                        }
-                ).collect(Collectors.toSet());
-        dimensions.add(TimeDimensionEnum.DAY.getChName());
-
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(correctS2SQL);
-
-        if (CollectionUtils.isEmpty(selectFields) || CollectionUtils.isEmpty(dimensions)) {
-            return;
-        }
-        // if only date in select not add group by.
-        if (selectFields.size() == 1 && selectFields.contains(TimeDimensionEnum.DAY.getChName())) {
-            return;
-        }
-        if (SqlParserSelectHelper.hasGroupBy(correctS2SQL)) {
-            log.info("not add group by ,exist group by in correctS2SQL:{}", correctS2SQL);
-            return;
-        }
-
-        List<String> aggregateFields = SqlParserSelectHelper.getAggregateFields(correctS2SQL);
-        Set<String> groupByFields = selectFields.stream()
-                .filter(field -> dimensions.contains(field))
-                .filter(field -> {
-                    if (!CollectionUtils.isEmpty(aggregateFields) && aggregateFields.contains(field)) {
-                        return false;
-                    }
-                    return true;
-                })
-                .collect(Collectors.toSet());
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(SqlParserAddHelper.addGroupBy(correctS2SQL, groupByFields));
-
-        addAggregate(queryContext, semanticParseInfo);
-    }
-
-    private void addAggregate(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        List<String> sqlGroupByFields = SqlParserSelectHelper.getGroupByFields(
-                semanticParseInfo.getSqlInfo().getCorrectS2SQL());
-        if (CollectionUtils.isEmpty(sqlGroupByFields)) {
-            return;
-        }
-        addAggregateToMetric(queryContext, semanticParseInfo);
-    }
-}

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

@@ -1,61 +0,0 @@
-package com.tencent.supersonic.chat.core.corrector;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectFunctionHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.expression.Expression;
-import org.springframework.util.CollectionUtils;
-
-/**
- * Perform SQL corrections on the "Having" section in S2SQL.
- */
-@Slf4j
-public class HavingCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-
-        //add aggregate to all metric
-        addHaving(queryContext, semanticParseInfo);
-
-        //add having expression filed to select
-        addHavingToSelect(semanticParseInfo);
-
-    }
-
-    private void addHaving(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        Set<Long> modelIds = semanticParseInfo.getModel().getModelIds();
-
-        SemanticSchema semanticSchema = queryContext.getSemanticSchema();
-
-        Set<String> metrics = semanticSchema.getMetrics(modelIds).stream()
-                .map(schemaElement -> schemaElement.getName()).collect(Collectors.toSet());
-
-        if (CollectionUtils.isEmpty(metrics)) {
-            return;
-        }
-        String havingSql = SqlParserAddHelper.addHaving(semanticParseInfo.getSqlInfo().getCorrectS2SQL(), metrics);
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(havingSql);
-    }
-
-    private void addHavingToSelect(SemanticParseInfo semanticParseInfo) {
-        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        if (!SqlParserSelectFunctionHelper.hasAggregateFunction(correctS2SQL)) {
-            return;
-        }
-        List<Expression> havingExpressionList = SqlParserSelectHelper.getHavingExpression(correctS2SQL);
-        if (!CollectionUtils.isEmpty(havingExpressionList)) {
-            String replaceSql = SqlParserAddHelper.addFunctionToSelect(correctS2SQL, havingExpressionList);
-            semanticParseInfo.getSqlInfo().setCorrectS2SQL(replaceSql);
-        }
-        return;
-    }
-
-}

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

@@ -1,107 +0,0 @@
-package com.tencent.supersonic.chat.core.corrector;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
-import com.tencent.supersonic.chat.core.parser.sql.llm.ParseResult;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.ElementValue;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.common.util.jsqlparser.AggregateEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
-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;
-
-/**
- * Perform schema corrections on the Schema information in S2QL.
- */
-@Slf4j
-public class SchemaCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-
-        correctAggFunction(semanticParseInfo);
-
-        replaceAlias(semanticParseInfo);
-
-        updateFieldNameByLinkingValue(semanticParseInfo);
-
-        updateFieldValueByLinkingValue(semanticParseInfo);
-
-        correctFieldName(queryContext, semanticParseInfo);
-    }
-
-    private void correctAggFunction(SemanticParseInfo semanticParseInfo) {
-        Map<String, String> aggregateEnum = AggregateEnum.getAggregateEnum();
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceFunction(sqlInfo.getCorrectS2SQL(), aggregateEnum);
-        sqlInfo.setCorrectS2SQL(sql);
-    }
-
-    private void replaceAlias(SemanticParseInfo semanticParseInfo) {
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String replaceAlias = SqlParserReplaceHelper.replaceAlias(sqlInfo.getCorrectS2SQL());
-        sqlInfo.setCorrectS2SQL(replaceAlias);
-    }
-
-    private void correctFieldName(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        Map<String, String> fieldNameMap = getFieldNameMap(queryContext, semanticParseInfo.getModel().getModelIds());
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceFields(sqlInfo.getCorrectS2SQL(), fieldNameMap);
-        sqlInfo.setCorrectS2SQL(sql);
-    }
-
-    private void updateFieldNameByLinkingValue(SemanticParseInfo semanticParseInfo) {
-        List<ElementValue> linking = getLinkingValues(semanticParseInfo);
-        if (CollectionUtils.isEmpty(linking)) {
-            return;
-        }
-
-        Map<String, Set<String>> fieldValueToFieldNames = linking.stream().collect(
-                Collectors.groupingBy(ElementValue::getFieldValue,
-                        Collectors.mapping(ElementValue::getFieldName, Collectors.toSet())));
-
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-
-        String sql = SqlParserReplaceHelper.replaceFieldNameByValue(sqlInfo.getCorrectS2SQL(), fieldValueToFieldNames);
-        sqlInfo.setCorrectS2SQL(sql);
-    }
-
-    private List<ElementValue> getLinkingValues(SemanticParseInfo semanticParseInfo) {
-        Object context = semanticParseInfo.getProperties().get(Constants.CONTEXT);
-        if (Objects.isNull(context)) {
-            return null;
-        }
-
-        ParseResult parseResult = JsonUtil.toObject(JsonUtil.toString(context), ParseResult.class);
-        if (Objects.isNull(parseResult) || Objects.isNull(parseResult.getLlmReq())) {
-            return null;
-        }
-        return parseResult.getLinkingValues();
-    }
-
-    private void updateFieldValueByLinkingValue(SemanticParseInfo semanticParseInfo) {
-        List<ElementValue> linking = getLinkingValues(semanticParseInfo);
-        if (CollectionUtils.isEmpty(linking)) {
-            return;
-        }
-
-        Map<String, Map<String, String>> filedNameToValueMap = linking.stream().collect(
-                Collectors.groupingBy(ElementValue::getFieldName,
-                        Collectors.mapping(ElementValue::getFieldValue, Collectors.toMap(
-                                oldValue -> oldValue,
-                                newValue -> newValue,
-                                (existingValue, newValue) -> newValue)
-                        )));
-
-        SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceValue(sqlInfo.getCorrectS2SQL(), filedNameToValueMap, false);
-        sqlInfo.setCorrectS2SQL(sql);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/DictConfig.java

@@ -1,13 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge;
-
-import java.util.List;
-import lombok.Data;
-
-
-@Data
-public class DictConfig {
-
-    private Long modelId;
-
-    private List<DimValueInfo> dimValueInfoList;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/DimValue2DictCommand.java

@@ -1,18 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge;
-
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import lombok.Data;
-
-@Data
-public class DimValue2DictCommand {
-
-    private DictUpdateMode updateMode;
-
-    private List<Long> modelIds;
-
-    private Map<Long, List<Long>> modelAndDimPair = new HashMap<>();
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/DimValueDictInfo.java

@@ -1,31 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge;
-
-
-import com.tencent.supersonic.common.pojo.enums.TaskStatusEnum;
-
-import java.util.Date;
-import java.util.Set;
-
-import lombok.Data;
-
-@Data
-public class DimValueDictInfo {
-
-    private Long id;
-
-    private String name;
-
-    private String description;
-
-    private String command;
-
-    private TaskStatusEnum status;
-
-    private String createdBy;
-
-    private Date createdAt;
-
-    private Long elapsedMs;
-
-    private Set<Long> dimIds;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/DimValueInfo.java

@@ -1,26 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge;
-
-
-import com.tencent.supersonic.common.pojo.enums.TypeEnums;
-import java.util.List;
-import javax.validation.constraints.NotNull;
-
-public class DimValueInfo {
-
-    /**
-     * metricId、DimensionId、domainId
-     */
-    private Long itemId;
-
-    /**
-     * type: IntentionTypeEnum
-     * temporarily only supports dimension-related information
-     */
-    @NotNull
-    private TypeEnums type = TypeEnums.DIMENSION;
-
-    private List<String> blackList;
-    private List<String> whiteList;
-    private List<String> ruleList;
-    private Boolean isDictInfo;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/ModelInfoStat.java

@@ -1,21 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge;
-
-import java.io.Serializable;
-import lombok.Builder;
-import lombok.Data;
-import lombok.ToString;
-
-@Data
-@ToString
-@Builder
-public class ModelInfoStat implements Serializable {
-
-    private long modelCount;
-
-    private long metricModelCount;
-
-    private long dimensionModelCount;
-
-    private long dimensionValueModelCount;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/builder/DimensionWordBuilder.java

@@ -1,63 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.builder;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.core.knowledge.DictWord;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import java.util.ArrayList;
-import java.util.List;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-/**
- * dimension word nature
- */
-@Service
-public class DimensionWordBuilder extends BaseWordBuilder {
-
-    @Value("${nlp.dimension.use.suffix:true}")
-    private boolean nlpDimensionUseSuffix = true;
-
-    @Override
-    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
-        List<DictWord> result = Lists.newArrayList();
-        result.add(getOnwWordNature(word, schemaElement, false));
-        result.addAll(getOnwWordNatureAlias(schemaElement, false));
-        if (nlpDimensionUseSuffix) {
-            String reverseWord = StringUtils.reverse(word);
-            if (StringUtils.isNotEmpty(word) && !word.equalsIgnoreCase(reverseWord)) {
-                result.add(getOnwWordNature(reverseWord, schemaElement, true));
-            }
-        }
-        return result;
-    }
-
-    private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
-        DictWord dictWord = new DictWord();
-        dictWord.setWord(word);
-        Long domainId = schemaElement.getModel();
-        String nature = DictWordType.NATURE_SPILT + domainId + DictWordType.NATURE_SPILT + schemaElement.getId()
-                + DictWordType.DIMENSION.getType();
-        if (isSuffix) {
-            nature = DictWordType.NATURE_SPILT + domainId + DictWordType.NATURE_SPILT + schemaElement.getId()
-                    + DictWordType.SUFFIX.getType() + DictWordType.DIMENSION.getType();
-        }
-        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
-        return dictWord;
-    }
-
-    private List<DictWord> getOnwWordNatureAlias(SchemaElement schemaElement, boolean isSuffix) {
-        List<DictWord> dictWords = new ArrayList<>();
-        if (CollectionUtils.isEmpty(schemaElement.getAlias())) {
-            return dictWords;
-        }
-
-        for (String alias : schemaElement.getAlias()) {
-            dictWords.add(getOnwWordNature(alias, schemaElement, false));
-        }
-        return dictWords;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/builder/EntityWordBuilder.java

@@ -1,44 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.builder;
-
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.core.knowledge.DictWord;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import java.util.List;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-/**
- * dimension value wordNature
- */
-@Service
-@Slf4j
-public class EntityWordBuilder extends BaseWordBuilder {
-
-    @Override
-    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
-        List<DictWord> result = Lists.newArrayList();
-
-        if (Objects.isNull(schemaElement)) {
-            return result;
-        }
-
-        Long domain = schemaElement.getModel();
-        String nature = DictWordType.NATURE_SPILT + domain + DictWordType.NATURE_SPILT + schemaElement.getId()
-                + DictWordType.ENTITY.getType();
-
-        if (!CollectionUtils.isEmpty(schemaElement.getAlias())) {
-            schemaElement.getAlias().stream().forEach(alias -> {
-                DictWord dictWordAlias = new DictWord();
-                dictWordAlias.setWord(alias);
-                dictWordAlias.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY * 2, nature));
-                result.add(dictWordAlias);
-            });
-        }
-        return result;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/builder/MetricWordBuilder.java

@@ -1,63 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.builder;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.core.knowledge.DictWord;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import java.util.ArrayList;
-import java.util.List;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-/**
- * Metric DictWord
- */
-@Service
-public class MetricWordBuilder extends BaseWordBuilder {
-
-    @Value("${nlp.metric.use.suffix:true}")
-    private boolean nlpMetricUseSuffix = true;
-
-    @Override
-    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
-        List<DictWord> result = Lists.newArrayList();
-        result.add(getOnwWordNature(word, schemaElement, false));
-        result.addAll(getOnwWordNatureAlias(schemaElement, false));
-        if (nlpMetricUseSuffix) {
-            String reverseWord = StringUtils.reverse(word);
-            if (!word.equalsIgnoreCase(reverseWord)) {
-                result.add(getOnwWordNature(reverseWord, schemaElement, true));
-            }
-        }
-        return result;
-    }
-
-    private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
-        DictWord dictWord = new DictWord();
-        dictWord.setWord(word);
-        Long modelId = schemaElement.getModel();
-        String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
-                + DictWordType.METRIC.getType();
-        if (isSuffix) {
-            nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
-                    + DictWordType.SUFFIX.getType() + DictWordType.METRIC.getType();
-        }
-        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
-        return dictWord;
-    }
-
-    private List<DictWord> getOnwWordNatureAlias(SchemaElement schemaElement, boolean isSuffix) {
-        List<DictWord> dictWords = new ArrayList<>();
-        if (CollectionUtils.isEmpty(schemaElement.getAlias())) {
-            return dictWords;
-        }
-
-        for (String alias : schemaElement.getAlias()) {
-            dictWords.add(getOnwWordNature(alias, schemaElement, false));
-        }
-        return dictWords;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/builder/ModelWordBuilder.java

@@ -1,43 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.builder;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.core.knowledge.DictWord;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import java.util.List;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-import org.springframework.stereotype.Service;
-
-/**
- * model word nature
- */
-@Service
-@Slf4j
-public class ModelWordBuilder extends BaseWordBuilder {
-
-    @Override
-    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
-        List<DictWord> result = Lists.newArrayList();
-        //modelName
-        DictWord dictWord = buildDictWord(word, schemaElement.getModel());
-        result.add(dictWord);
-        //alias
-        List<String> aliasList = schemaElement.getAlias();
-        if (CollectionUtils.isNotEmpty(aliasList)) {
-            for (String alias : aliasList) {
-                result.add(buildDictWord(alias, schemaElement.getModel()));
-            }
-        }
-        return result;
-    }
-
-    private DictWord buildDictWord(String word, Long modelId) {
-        DictWord dictWord = new DictWord();
-        dictWord.setWord(word);
-        String nature = DictWordType.NATURE_SPILT + modelId;
-        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
-        return dictWord;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/builder/ValueWordBuilder.java

@@ -1,40 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.builder;
-
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.core.knowledge.DictWord;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
-import java.util.List;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-/**
- * dimension value wordNature
- */
-@Service
-@Slf4j
-public class ValueWordBuilder extends BaseWordBuilder {
-
-    @Override
-    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
-
-        List<DictWord> result = Lists.newArrayList();
-        if (Objects.nonNull(schemaElement) && !CollectionUtils.isEmpty(schemaElement.getAlias())) {
-
-            schemaElement.getAlias().stream().forEach(value -> {
-                DictWord dictWord = new DictWord();
-                Long modelId = schemaElement.getModel();
-                String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId();
-                dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
-                dictWord.setWord(value);
-                result.add(dictWord);
-            });
-        }
-        log.debug("ValueWordBuilder, result:{}", result);
-        return result;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/semantic/BaseSemanticInterpreter.java

@@ -1,67 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.semantic;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.tencent.supersonic.chat.api.pojo.ModelSchema;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public abstract class BaseSemanticInterpreter implements SemanticInterpreter {
-
-    protected final Cache<String, List<ModelSchemaResp>> modelSchemaCache =
-            CacheBuilder.newBuilder().expireAfterWrite(10, TimeUnit.SECONDS).build();
-
-    @SneakyThrows
-    public List<ModelSchemaResp> fetchModelSchema(List<Long> ids, Boolean cacheEnable) {
-        if (cacheEnable) {
-            return modelSchemaCache.get(String.valueOf(ids), () -> {
-                List<ModelSchemaResp> data = doFetchModelSchema(ids);
-                modelSchemaCache.put(String.valueOf(ids), data);
-                return data;
-            });
-        }
-        List<ModelSchemaResp> data = doFetchModelSchema(ids);
-        return data;
-    }
-
-    @Override
-    public ModelSchema getModelSchema(Long model, Boolean cacheEnable) {
-        List<Long> ids = new ArrayList<>();
-        ids.add(model);
-        List<ModelSchemaResp> modelSchemaResps = fetchModelSchema(ids, cacheEnable);
-        if (!CollectionUtils.isEmpty(modelSchemaResps)) {
-            Optional<ModelSchemaResp> modelSchemaResp = modelSchemaResps.stream()
-                    .filter(d -> d.getId().equals(model)).findFirst();
-            if (modelSchemaResp.isPresent()) {
-                ModelSchemaResp modelSchema = modelSchemaResp.get();
-                return ModelSchemaBuilder.build(modelSchema);
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public List<ModelSchema> getModelSchema() {
-        return getModelSchema(new ArrayList<>());
-    }
-
-    @Override
-    public List<ModelSchema> getModelSchema(List<Long> ids) {
-        List<ModelSchema> domainSchemaList = new ArrayList<>();
-
-        for (ModelSchemaResp resp : fetchModelSchema(ids, true)) {
-            domainSchemaList.add(ModelSchemaBuilder.build(resp));
-        }
-
-        return domainSchemaList;
-    }
-
-    protected abstract List<ModelSchemaResp> doFetchModelSchema(List<Long> ids);
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/semantic/LocalSemanticInterpreter.java

@@ -1,120 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.semantic;
-
-import com.github.pagehelper.PageInfo;
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.common.pojo.enums.AuthType;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.headless.api.request.ExplainSqlReq;
-import com.tencent.supersonic.headless.api.request.ModelSchemaFilterReq;
-import com.tencent.supersonic.headless.api.request.PageDimensionReq;
-import com.tencent.supersonic.headless.api.request.PageMetricReq;
-import com.tencent.supersonic.headless.api.request.QueryDimValueReq;
-import com.tencent.supersonic.headless.api.request.QueryMultiStructReq;
-import com.tencent.supersonic.headless.api.request.QuerySqlReq;
-import com.tencent.supersonic.headless.api.request.QueryStructReq;
-import com.tencent.supersonic.headless.api.response.DimensionResp;
-import com.tencent.supersonic.headless.api.response.DomainResp;
-import com.tencent.supersonic.headless.api.response.ExplainResp;
-import com.tencent.supersonic.headless.api.response.MetricResp;
-import com.tencent.supersonic.headless.api.response.ModelResp;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import com.tencent.supersonic.headless.api.response.SemanticQueryResp;
-import com.tencent.supersonic.headless.server.service.DimensionService;
-import com.tencent.supersonic.headless.server.service.MetricService;
-import com.tencent.supersonic.headless.server.service.QueryService;
-import com.tencent.supersonic.headless.server.service.SchemaService;
-import java.util.ArrayList;
-import java.util.List;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-
-@Slf4j
-public class LocalSemanticInterpreter extends BaseSemanticInterpreter {
-
-    private SchemaService schemaService;
-    private DimensionService dimensionService;
-    private MetricService metricService;
-    private QueryService queryService;
-
-    @SneakyThrows
-    @Override
-    public SemanticQueryResp queryByStruct(QueryStructReq queryStructReq, User user) {
-        if (StringUtils.isNotBlank(queryStructReq.getCorrectS2SQL())) {
-            QuerySqlReq querySQLReq = new QuerySqlReq();
-            querySQLReq.setSql(queryStructReq.getCorrectS2SQL());
-            querySQLReq.setModelIds(queryStructReq.getModelIdSet());
-            querySQLReq.setParams(new ArrayList<>());
-            return queryByS2SQL(querySQLReq, user);
-        }
-        queryService = ContextUtils.getBean(QueryService.class);
-        return queryService.queryByStructWithAuth(queryStructReq, user);
-    }
-
-    @Override
-    public SemanticQueryResp queryByMultiStruct(QueryMultiStructReq queryMultiStructReq, User user) {
-        try {
-            queryService = ContextUtils.getBean(QueryService.class);
-            return queryService.queryByMultiStruct(queryMultiStructReq, user);
-        } catch (Exception e) {
-            log.info("queryByMultiStruct has an exception:{}", e);
-        }
-        return null;
-    }
-
-    @Override
-    @SneakyThrows
-    public SemanticQueryResp queryByS2SQL(QuerySqlReq querySQLReq, User user) {
-        queryService = ContextUtils.getBean(QueryService.class);
-        SemanticQueryResp object = queryService.queryBySql(querySQLReq, user);
-        return JsonUtil.toObject(JsonUtil.toString(object), SemanticQueryResp.class);
-    }
-
-    @Override
-    @SneakyThrows
-    public SemanticQueryResp queryDimValue(QueryDimValueReq queryDimValueReq, User user) {
-        queryService = ContextUtils.getBean(QueryService.class);
-        return queryService.queryDimValue(queryDimValueReq, user);
-    }
-
-    @Override
-    public List<ModelSchemaResp> doFetchModelSchema(List<Long> ids) {
-        ModelSchemaFilterReq filter = new ModelSchemaFilterReq();
-        filter.setModelIds(ids);
-        schemaService = ContextUtils.getBean(SchemaService.class);
-        User user = User.getFakeUser();
-        return schemaService.fetchModelSchema(filter, user);
-    }
-
-    @Override
-    public List<DomainResp> getDomainList(User user) {
-        schemaService = ContextUtils.getBean(SchemaService.class);
-        return schemaService.getDomainList(user);
-    }
-
-    @Override
-    public List<ModelResp> getModelList(AuthType authType, Long domainId, User user) {
-        schemaService = ContextUtils.getBean(SchemaService.class);
-        return schemaService.getModelList(user, authType, domainId);
-    }
-
-    @Override
-    public <T> ExplainResp explain(ExplainSqlReq<T> explainSqlReq, User user) throws Exception {
-        queryService = ContextUtils.getBean(QueryService.class);
-        return queryService.explain(explainSqlReq, user);
-    }
-
-    @Override
-    public PageInfo<DimensionResp> getDimensionPage(PageDimensionReq pageDimensionCmd) {
-        dimensionService = ContextUtils.getBean(DimensionService.class);
-        return dimensionService.queryDimension(pageDimensionCmd);
-    }
-
-    @Override
-    public PageInfo<MetricResp> getMetricPage(PageMetricReq pageMetricReq, User user) {
-        metricService = ContextUtils.getBean(MetricService.class);
-        return metricService.queryMetric(pageMetricReq, user);
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/semantic/ModelSchemaBuilder.java

@@ -1,153 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.semantic;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.api.pojo.ModelSchema;
-import com.tencent.supersonic.chat.api.pojo.RelatedSchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaValueMap;
-import com.tencent.supersonic.headless.api.pojo.DimValueMap;
-import com.tencent.supersonic.headless.api.pojo.RelateDimension;
-import com.tencent.supersonic.headless.api.pojo.SchemaItem;
-import com.tencent.supersonic.headless.api.response.DimSchemaResp;
-import com.tencent.supersonic.headless.api.response.MetricSchemaResp;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import org.apache.logging.log4j.util.Strings;
-import org.springframework.beans.BeanUtils;
-import org.springframework.util.CollectionUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-public class ModelSchemaBuilder {
-
-    public static ModelSchema build(ModelSchemaResp resp) {
-        ModelSchema modelSchema = new ModelSchema();
-        SchemaElement model = SchemaElement.builder()
-                .model(resp.getId())
-                .id(resp.getId())
-                .name(resp.getName())
-                .bizName(resp.getBizName())
-                .type(SchemaElementType.MODEL)
-                .alias(SchemaItem.getAliasList(resp.getAlias()))
-                .build();
-        modelSchema.setModel(model);
-        modelSchema.setModelRelas(resp.getModelRelas());
-
-        Set<SchemaElement> metrics = new HashSet<>();
-        for (MetricSchemaResp metric : resp.getMetrics()) {
-
-            List<String> alias = SchemaItem.getAliasList(metric.getAlias());
-
-            SchemaElement metricToAdd = SchemaElement.builder()
-                    .model(resp.getId())
-                    .id(metric.getId())
-                    .name(metric.getName())
-                    .bizName(metric.getBizName())
-                    .type(SchemaElementType.METRIC)
-                    .useCnt(metric.getUseCnt())
-                    .alias(alias)
-                    .relatedSchemaElements(getRelateSchemaElement(metric))
-                    .defaultAgg(metric.getDefaultAgg())
-                    .build();
-            metrics.add(metricToAdd);
-
-        }
-        modelSchema.getMetrics().addAll(metrics);
-
-        Set<SchemaElement> dimensions = new HashSet<>();
-        Set<SchemaElement> dimensionValues = new HashSet<>();
-        Set<SchemaElement> tags = new HashSet<>();
-        for (DimSchemaResp dim : resp.getDimensions()) {
-
-            List<String> alias = SchemaItem.getAliasList(dim.getAlias());
-            Set<String> dimValueAlias = new HashSet<>();
-            List<DimValueMap> dimValueMaps = dim.getDimValueMaps();
-            List<SchemaValueMap> schemaValueMaps = new ArrayList<>();
-            if (!CollectionUtils.isEmpty(dimValueMaps)) {
-
-                for (DimValueMap dimValueMap : dimValueMaps) {
-                    if (Strings.isNotEmpty(dimValueMap.getBizName())) {
-                        dimValueAlias.add(dimValueMap.getBizName());
-                    }
-                    if (!CollectionUtils.isEmpty(dimValueMap.getAlias())) {
-                        dimValueAlias.addAll(dimValueMap.getAlias());
-                    }
-                    SchemaValueMap schemaValueMap = new SchemaValueMap();
-                    BeanUtils.copyProperties(dimValueMap, schemaValueMap);
-                    schemaValueMaps.add(schemaValueMap);
-                }
-
-            }
-            SchemaElement dimToAdd = SchemaElement.builder()
-                    .model(resp.getId())
-                    .id(dim.getId())
-                    .name(dim.getName())
-                    .bizName(dim.getBizName())
-                    .type(SchemaElementType.DIMENSION)
-                    .useCnt(dim.getUseCnt())
-                    .alias(alias)
-                    .schemaValueMaps(schemaValueMaps)
-                    .build();
-            dimensions.add(dimToAdd);
-
-            SchemaElement dimValueToAdd = SchemaElement.builder()
-                    .model(resp.getId())
-                    .id(dim.getId())
-                    .name(dim.getName())
-                    .bizName(dim.getBizName())
-                    .type(SchemaElementType.VALUE)
-                    .useCnt(dim.getUseCnt())
-                    .alias(new ArrayList<>(Arrays.asList(dimValueAlias.toArray(new String[0]))))
-                    .build();
-            dimensionValues.add(dimValueToAdd);
-            if (dim.getIsTag() == 1) {
-                SchemaElement tagToAdd = SchemaElement.builder()
-                        .model(resp.getId())
-                        .id(dim.getId())
-                        .name(dim.getName())
-                        .bizName(dim.getBizName())
-                        .type(SchemaElementType.TAG)
-                        .useCnt(dim.getUseCnt())
-                        .alias(alias)
-                        .schemaValueMaps(schemaValueMaps)
-                        .build();
-                tags.add(tagToAdd);
-            }
-        }
-        modelSchema.getDimensions().addAll(dimensions);
-        modelSchema.getDimensionValues().addAll(dimensionValues);
-        modelSchema.getTags().addAll(tags);
-
-        DimSchemaResp dim = resp.getPrimaryKey();
-        if (dim != null) {
-            SchemaElement entity = SchemaElement.builder()
-                    .model(resp.getId())
-                    .id(dim.getId())
-                    .name(dim.getName())
-                    .bizName(dim.getBizName())
-                    .type(SchemaElementType.ENTITY)
-                    .useCnt(dim.getUseCnt())
-                    .alias(dim.getEntityAlias())
-                    .build();
-            modelSchema.setEntity(entity);
-        }
-        return modelSchema;
-    }
-
-    private static List<RelatedSchemaElement> getRelateSchemaElement(MetricSchemaResp metricSchemaResp) {
-        RelateDimension relateDimension = metricSchemaResp.getRelateDimension();
-        if (relateDimension == null || CollectionUtils.isEmpty(relateDimension.getDrillDownDimensions())) {
-            return Lists.newArrayList();
-        }
-        return relateDimension.getDrillDownDimensions().stream().map(dimension -> {
-            RelatedSchemaElement relateSchemaElement = new RelatedSchemaElement();
-            BeanUtils.copyProperties(dimension, relateSchemaElement);
-            return relateSchemaElement;
-        }).collect(Collectors.toList());
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/semantic/RemoteSemanticInterpreter.java

@@ -1,313 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.semantic;
-
-import static com.tencent.supersonic.common.pojo.Constants.LIST_LOWER;
-import static com.tencent.supersonic.common.pojo.Constants.PAGESIZE_LOWER;
-import static com.tencent.supersonic.common.pojo.Constants.TOTAL_LOWER;
-import static com.tencent.supersonic.common.pojo.Constants.TRUE_LOWER;
-
-import com.alibaba.fastjson.JSON;
-import com.github.pagehelper.PageInfo;
-import com.google.gson.Gson;
-import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
-import com.tencent.supersonic.auth.api.authentication.constant.UserConstants;
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.core.config.DefaultSemanticConfig;
-import com.tencent.supersonic.common.pojo.ResultData;
-import com.tencent.supersonic.common.pojo.enums.AuthType;
-import com.tencent.supersonic.common.pojo.enums.ReturnCode;
-import com.tencent.supersonic.common.pojo.exception.CommonException;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.common.util.S2ThreadContext;
-import com.tencent.supersonic.common.util.ThreadContext;
-import com.tencent.supersonic.headless.api.request.ExplainSqlReq;
-import com.tencent.supersonic.headless.api.request.ModelSchemaFilterReq;
-import com.tencent.supersonic.headless.api.request.PageDimensionReq;
-import com.tencent.supersonic.headless.api.request.PageMetricReq;
-import com.tencent.supersonic.headless.api.request.QueryDimValueReq;
-import com.tencent.supersonic.headless.api.request.QueryMultiStructReq;
-import com.tencent.supersonic.headless.api.request.QuerySqlReq;
-import com.tencent.supersonic.headless.api.request.QueryStructReq;
-import com.tencent.supersonic.headless.api.response.DimensionResp;
-import com.tencent.supersonic.headless.api.response.DomainResp;
-import com.tencent.supersonic.headless.api.response.ExplainResp;
-import com.tencent.supersonic.headless.api.response.MetricResp;
-import com.tencent.supersonic.headless.api.response.ModelResp;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import com.tencent.supersonic.headless.api.response.SemanticQueryResp;
-import java.net.URI;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.util.Strings;
-import org.springframework.beans.BeanUtils;
-import org.springframework.core.ParameterizedTypeReference;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestTemplate;
-import org.springframework.web.util.UriComponentsBuilder;
-
-@Slf4j
-public class RemoteSemanticInterpreter extends BaseSemanticInterpreter {
-
-    private S2ThreadContext s2ThreadContext;
-
-    private AuthenticationConfig authenticationConfig;
-
-    private ParameterizedTypeReference<ResultData<SemanticQueryResp>> structTypeRef =
-            new ParameterizedTypeReference<ResultData<SemanticQueryResp>>() {
-            };
-
-    private ParameterizedTypeReference<ResultData<ExplainResp>> explainTypeRef =
-            new ParameterizedTypeReference<ResultData<ExplainResp>>() {
-            };
-
-    @Override
-    public SemanticQueryResp queryByStruct(QueryStructReq queryStructReq, User user) {
-        if (StringUtils.isNotBlank(queryStructReq.getCorrectS2SQL())) {
-            QuerySqlReq querySQLReq = new QuerySqlReq();
-            querySQLReq.setSql(queryStructReq.getCorrectS2SQL());
-            querySQLReq.setModelIds(queryStructReq.getModelIdSet());
-            querySQLReq.setParams(new ArrayList<>());
-            return queryByS2SQL(querySQLReq, user);
-        }
-
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        return searchByRestTemplate(
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getSearchByStructPath(),
-                new Gson().toJson(queryStructReq));
-    }
-
-    @Override
-    public SemanticQueryResp queryByMultiStruct(QueryMultiStructReq queryMultiStructReq, User user) {
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        return searchByRestTemplate(
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getSearchByMultiStructPath(),
-                new Gson().toJson(queryMultiStructReq));
-    }
-
-    @Override
-    public SemanticQueryResp queryByS2SQL(QuerySqlReq querySQLReq, User user) {
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        return searchByRestTemplate(defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getSearchBySqlPath(),
-                new Gson().toJson(querySQLReq));
-    }
-
-    public SemanticQueryResp searchByRestTemplate(String url, String jsonReq) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        fillToken(headers);
-        URI requestUrl = UriComponentsBuilder.fromHttpUrl(url).build().encode().toUri();
-        HttpEntity<String> entity = new HttpEntity<>(jsonReq, headers);
-        log.info("url:{},searchByRestTemplate:{}", url, entity.getBody());
-        ResultData<SemanticQueryResp> responseBody;
-        try {
-            RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-
-            ResponseEntity<ResultData<SemanticQueryResp>> responseEntity = restTemplate.exchange(
-                    requestUrl, HttpMethod.POST, entity, structTypeRef);
-            responseBody = responseEntity.getBody();
-            log.info("ApiResponse<QueryResultWithColumns> responseBody:{}", responseBody);
-            SemanticQueryResp schemaResp = new SemanticQueryResp();
-            if (ReturnCode.SUCCESS.getCode() == responseBody.getCode()) {
-                SemanticQueryResp data = responseBody.getData();
-                schemaResp.setColumns(data.getColumns());
-                schemaResp.setResultList(data.getResultList());
-                schemaResp.setSql(data.getSql());
-                schemaResp.setQueryAuthorization(data.getQueryAuthorization());
-                return schemaResp;
-            }
-        } catch (Exception e) {
-            throw new RuntimeException("search headless interface error,url:" + url, e);
-        }
-        throw new CommonException(responseBody.getCode(), responseBody.getMsg());
-    }
-
-    @Override
-    public SemanticQueryResp queryDimValue(QueryDimValueReq queryDimValueReq, User user) {
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        return searchByRestTemplate(defaultSemanticConfig.getSemanticUrl()
-                        + defaultSemanticConfig.getQueryDimValuePath(),
-                new Gson().toJson(queryDimValueReq));
-    }
-
-    @Override
-    public List<ModelSchemaResp> doFetchModelSchema(List<Long> ids) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.set(UserConstants.INTERNAL, TRUE_LOWER);
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        fillToken(headers);
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-
-        String semanticUrl = defaultSemanticConfig.getSemanticUrl();
-        String fetchModelSchemaPath = defaultSemanticConfig.getFetchModelSchemaPath();
-        URI requestUrl = UriComponentsBuilder.fromHttpUrl(semanticUrl + fetchModelSchemaPath)
-                .build().encode().toUri();
-        ModelSchemaFilterReq filter = new ModelSchemaFilterReq();
-        filter.setModelIds(ids);
-        ParameterizedTypeReference<ResultData<List<ModelSchemaResp>>> responseTypeRef =
-                new ParameterizedTypeReference<ResultData<List<ModelSchemaResp>>>() {
-                };
-
-        HttpEntity<String> entity = new HttpEntity<>(JSON.toJSONString(filter), headers);
-
-        try {
-            RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-            ResponseEntity<ResultData<List<ModelSchemaResp>>> responseEntity = restTemplate.exchange(
-                    requestUrl, HttpMethod.POST, entity, responseTypeRef);
-            ResultData<List<ModelSchemaResp>> responseBody = responseEntity.getBody();
-            log.debug("ApiResponse<fetchModelSchema> responseBody:{}", responseBody);
-            if (ReturnCode.SUCCESS.getCode() == responseBody.getCode()) {
-                List<ModelSchemaResp> data = responseBody.getData();
-                return data;
-            }
-        } catch (Exception e) {
-            throw new RuntimeException("fetchModelSchema interface error", e);
-        }
-        throw new RuntimeException("fetchModelSchema interface error");
-    }
-
-    @Override
-    public List<DomainResp> getDomainList(User user) {
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        Object domainDescListObject = fetchHttpResult(
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getFetchDomainListPath(),
-                null, HttpMethod.GET);
-        return JsonUtil.toList(JsonUtil.toString(domainDescListObject), DomainResp.class);
-    }
-
-    @Override
-    public List<ModelResp> getModelList(AuthType authType, Long domainId, User user) {
-        if (domainId == null) {
-            domainId = 0L;
-        }
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        String url = String.format("%s?domainId=%s&authType=%s",
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getFetchModelListPath(),
-                domainId, authType.toString());
-        Object domainDescListObject = fetchHttpResult(url, null, HttpMethod.GET);
-        return JsonUtil.toList(JsonUtil.toString(domainDescListObject), ModelResp.class);
-    }
-
-    @Override
-    public <T> ExplainResp explain(ExplainSqlReq<T> explainResp, User user) throws Exception {
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        String semanticUrl = defaultSemanticConfig.getSemanticUrl();
-        String explainPath = defaultSemanticConfig.getExplainPath();
-        URL url = new URL(new URL(semanticUrl), explainPath);
-        return explain(url.toString(), JsonUtil.toString(explainResp));
-    }
-
-    public ExplainResp explain(String url, String jsonReq) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        fillToken(headers);
-        URI requestUrl = UriComponentsBuilder.fromHttpUrl(url).build().encode().toUri();
-        HttpEntity<String> entity = new HttpEntity<>(jsonReq, headers);
-        log.info("url:{},explain:{}", url, entity.getBody());
-        ResultData<ExplainResp> responseBody;
-        try {
-            RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-
-            ResponseEntity<ResultData<ExplainResp>> responseEntity = restTemplate.exchange(
-                    requestUrl, HttpMethod.POST, entity, explainTypeRef);
-            log.info("ApiResponse<ExplainResp> responseBody:{}", responseEntity);
-            responseBody = responseEntity.getBody();
-            if (Objects.nonNull(responseBody.getData())) {
-                return responseBody.getData();
-            }
-            return null;
-        } catch (Exception e) {
-            throw new RuntimeException("explain interface error,url:" + url, e);
-        }
-    }
-
-    public Object fetchHttpResult(String url, String bodyJson, HttpMethod httpMethod) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        fillToken(headers);
-        URI requestUrl = UriComponentsBuilder.fromHttpUrl(url).build().encode().toUri();
-        ParameterizedTypeReference<ResultData<Object>> responseTypeRef =
-                new ParameterizedTypeReference<ResultData<Object>>() {
-                };
-        HttpEntity<String> entity = new HttpEntity<>(JsonUtil.toString(bodyJson), headers);
-        try {
-            RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-            ResponseEntity<ResultData<Object>> responseEntity = restTemplate.exchange(requestUrl,
-                    httpMethod, entity, responseTypeRef);
-            ResultData<Object> responseBody = responseEntity.getBody();
-            log.debug("ApiResponse<fetchModelSchema> responseBody:{}", responseBody);
-            if (ReturnCode.SUCCESS.getCode() == responseBody.getCode()) {
-                Object data = responseBody.getData();
-                return data;
-            }
-        } catch (Exception e) {
-            throw new RuntimeException("fetchModelSchema interface error", e);
-        }
-        throw new RuntimeException("fetchModelSchema interface error");
-    }
-
-    public void fillToken(HttpHeaders headers) {
-        s2ThreadContext = ContextUtils.getBean(S2ThreadContext.class);
-        authenticationConfig = ContextUtils.getBean(AuthenticationConfig.class);
-        ThreadContext threadContext = s2ThreadContext.get();
-        if (Objects.nonNull(threadContext) && Strings.isNotEmpty(threadContext.getToken())) {
-            if (Objects.nonNull(authenticationConfig) && Strings.isNotEmpty(
-                    authenticationConfig.getTokenHttpHeaderKey())) {
-                headers.set(authenticationConfig.getTokenHttpHeaderKey(), threadContext.getToken());
-            }
-        } else {
-            log.debug("threadContext is null:{}", Objects.isNull(threadContext));
-        }
-    }
-
-    @Override
-    public PageInfo<MetricResp> getMetricPage(PageMetricReq pageMetricCmd, User user) {
-        String body = JsonUtil.toString(pageMetricCmd);
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        log.info("url:{}", defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getFetchMetricPagePath());
-        Object dimensionListObject = fetchHttpResult(
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getFetchMetricPagePath(),
-                body, HttpMethod.POST);
-        LinkedHashMap map = (LinkedHashMap) dimensionListObject;
-        PageInfo<Object> metricDescObjectPageInfo = generatePageInfo(map);
-        PageInfo<MetricResp> metricDescPageInfo = new PageInfo<>();
-        BeanUtils.copyProperties(metricDescObjectPageInfo, metricDescPageInfo);
-        metricDescPageInfo.setList(metricDescPageInfo.getList());
-        return metricDescPageInfo;
-    }
-
-    @Override
-    public PageInfo<DimensionResp> getDimensionPage(PageDimensionReq pageDimensionCmd) {
-        String body = JsonUtil.toString(pageDimensionCmd);
-        DefaultSemanticConfig defaultSemanticConfig = ContextUtils.getBean(DefaultSemanticConfig.class);
-        Object dimensionListObject = fetchHttpResult(
-                defaultSemanticConfig.getSemanticUrl() + defaultSemanticConfig.getFetchDimensionPagePath(),
-                body, HttpMethod.POST);
-        LinkedHashMap map = (LinkedHashMap) dimensionListObject;
-        PageInfo<Object> dimensionDescObjectPageInfo = generatePageInfo(map);
-        PageInfo<DimensionResp> dimensionDescPageInfo = new PageInfo<>();
-        BeanUtils.copyProperties(dimensionDescObjectPageInfo, dimensionDescPageInfo);
-        dimensionDescPageInfo.setList(dimensionDescPageInfo.getList());
-        return dimensionDescPageInfo;
-    }
-
-    private PageInfo<Object> generatePageInfo(LinkedHashMap map) {
-        PageInfo<Object> pageInfo = new PageInfo<>();
-        pageInfo.setList((List<Object>) map.get(LIST_LOWER));
-        Integer total = (Integer) map.get(TOTAL_LOWER);
-        pageInfo.setTotal(total);
-        Integer pageSize = (Integer) map.get(PAGESIZE_LOWER);
-        pageInfo.setPageSize(pageSize);
-        pageInfo.setPages((int) Math.ceil((double) total / pageSize));
-        return pageInfo;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/knowledge/semantic/SemanticInterpreter.java

@@ -1,63 +0,0 @@
-package com.tencent.supersonic.chat.core.knowledge.semantic;
-
-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.headless.api.request.PageDimensionReq;
-import com.tencent.supersonic.headless.api.request.PageMetricReq;
-import com.tencent.supersonic.headless.api.response.DomainResp;
-import com.tencent.supersonic.headless.api.response.DimensionResp;
-import com.tencent.supersonic.headless.api.response.ExplainResp;
-import com.tencent.supersonic.headless.api.response.MetricResp;
-import com.tencent.supersonic.headless.api.response.ModelResp;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import com.tencent.supersonic.headless.api.response.SemanticQueryResp;
-import com.tencent.supersonic.headless.api.request.ExplainSqlReq;
-import com.tencent.supersonic.headless.api.request.QueryDimValueReq;
-import com.tencent.supersonic.headless.api.request.QuerySqlReq;
-import com.tencent.supersonic.headless.api.request.QueryMultiStructReq;
-import com.tencent.supersonic.headless.api.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 SemanticInterpreter {
-
-    SemanticQueryResp queryByStruct(QueryStructReq queryStructReq, User user);
-
-    SemanticQueryResp queryByMultiStruct(QueryMultiStructReq queryMultiStructReq, User user);
-
-    SemanticQueryResp queryByS2SQL(QuerySqlReq querySQLReq, User user);
-
-    SemanticQueryResp queryDimValue(QueryDimValueReq queryDimValueReq, User user);
-
-    List<ModelSchema> getModelSchema();
-
-    List<ModelSchema> getModelSchema(List<Long> ids);
-
-    ModelSchema getModelSchema(Long model, Boolean cacheEnable);
-
-    PageInfo<DimensionResp> getDimensionPage(PageDimensionReq pageDimensionReq);
-
-    PageInfo<MetricResp> getMetricPage(PageMetricReq pageDimensionReq, User user);
-
-    List<DomainResp> getDomainList(User user);
-
-    List<ModelResp> getModelList(AuthType authType, Long domainId, User user);
-
-    <T> ExplainResp explain(ExplainSqlReq<T> explainSqlReq, User user) throws Exception;
-
-    List<ModelSchemaResp> fetchModelSchema(List<Long> ids, Boolean cacheEnable);
-
-}

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

@@ -1,98 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.tencent.supersonic.chat.api.pojo.ModelSchema;
-import com.tencent.supersonic.chat.core.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.api.pojo.SemanticSchema;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.BeanUtils;
-
-@Slf4j
-public abstract class BaseMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContext queryContext) {
-
-        String simpleName = this.getClass().getSimpleName();
-        long startTime = System.currentTimeMillis();
-        log.info("before {},mapInfo:{}", simpleName, queryContext.getMapInfo().getModelElementMatches());
-
-        try {
-            doMap(queryContext);
-        } catch (Exception e) {
-            log.error("work error", e);
-        }
-
-        long cost = System.currentTimeMillis() - startTime;
-        log.info("after {},cost:{},mapInfo:{}", simpleName, cost, queryContext.getMapInfo().getModelElementMatches());
-    }
-
-    public abstract void doMap(QueryContext queryContext);
-
-    public void addToSchemaMap(SchemaMapInfo schemaMap, Long modelId, SchemaElementMatch newElementMatch) {
-        Map<Long, List<SchemaElementMatch>> modelElementMatches = schemaMap.getModelElementMatches();
-        List<SchemaElementMatch> schemaElementMatches = modelElementMatches.putIfAbsent(modelId, new ArrayList<>());
-        if (schemaElementMatches == null) {
-            schemaElementMatches = modelElementMatches.get(modelId);
-        }
-        //remove duplication
-        AtomicBoolean needAddNew = new AtomicBoolean(true);
-        schemaElementMatches.removeIf(
-                existElementMatch -> {
-                    SchemaElement existElement = existElementMatch.getElement();
-                    SchemaElement newElement = newElementMatch.getElement();
-                    if (existElement.equals(newElement)) {
-                        if (newElementMatch.getSimilarity() > existElementMatch.getSimilarity()) {
-                            return true;
-                        } else {
-                            needAddNew.set(false);
-                        }
-                    }
-                    return false;
-                }
-        );
-        if (needAddNew.get()) {
-            schemaElementMatches.add(newElementMatch);
-        }
-    }
-
-    public SchemaElement getSchemaElement(Long modelId, SchemaElementType elementType, Long elementID,
-            SemanticSchema semanticSchema) {
-        SchemaElement element = new SchemaElement();
-        ModelSchema modelSchema = semanticSchema.getModelSchemaMap().get(modelId);
-        if (Objects.isNull(modelSchema)) {
-            return null;
-        }
-        SchemaElement elementDb = modelSchema.getElement(elementType, elementID);
-        if (Objects.isNull(elementDb)) {
-            log.info("element is null, elementType:{},elementID:{}", elementType, elementID);
-            return null;
-        }
-        BeanUtils.copyProperties(elementDb, element);
-        element.setAlias(getAlias(elementDb));
-        return element;
-    }
-
-    public List<String> getAlias(SchemaElement element) {
-        if (!SchemaElementType.VALUE.equals(element.getType())) {
-            return element.getAlias();
-        }
-        if (org.apache.commons.collections.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/core/mapper/EmbeddingMatchStrategy.java

@@ -1,140 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.knowledge.EmbeddingResult;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.config.EmbeddingConfig;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.util.ComponentFactory;
-import com.tencent.supersonic.common.util.embedding.Retrieval;
-import com.tencent.supersonic.common.util.embedding.RetrieveQuery;
-import com.tencent.supersonic.common.util.embedding.RetrieveQueryResult;
-import com.tencent.supersonic.common.util.embedding.S2EmbeddingStore;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-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;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-/**
- * EmbeddingMatchStrategy uses vector database to perform
- * similarity search against the embeddings of schema elements.
- */
-@Service
-@Slf4j
-public class EmbeddingMatchStrategy extends BaseMatchStrategy<EmbeddingResult> {
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private EmbeddingConfig embeddingConfig;
-
-    private S2EmbeddingStore s2EmbeddingStore = ComponentFactory.getS2EmbeddingStore();
-
-    @Override
-    public boolean needDelete(EmbeddingResult oneRoundResult, EmbeddingResult existResult) {
-        return getMapKey(oneRoundResult).equals(getMapKey(existResult))
-                && existResult.getDistance() > oneRoundResult.getDistance();
-    }
-
-    @Override
-    public String getMapKey(EmbeddingResult a) {
-        return a.getName() + Constants.UNDERLINE + a.getId();
-    }
-
-    @Override
-    protected void detectByBatch(QueryContext queryContext, Set<EmbeddingResult> results, Set<Long> detectModelIds,
-            Set<String> detectSegments) {
-
-        List<String> queryTextsList = detectSegments.stream()
-                .map(detectSegment -> detectSegment.trim())
-                .filter(detectSegment -> StringUtils.isNotBlank(detectSegment)
-                        && detectSegment.length() >= optimizationConfig.getEmbeddingMapperWordMin()
-                        && detectSegment.length() <= optimizationConfig.getEmbeddingMapperWordMax())
-                .collect(Collectors.toList());
-
-        List<List<String>> queryTextsSubList = Lists.partition(queryTextsList,
-                optimizationConfig.getEmbeddingMapperBatch());
-
-        for (List<String> queryTextsSub : queryTextsSubList) {
-            detectByQueryTextsSub(results, detectModelIds, queryTextsSub);
-        }
-    }
-
-    private void detectByQueryTextsSub(Set<EmbeddingResult> results, Set<Long> detectModelIds,
-            List<String> queryTextsSub) {
-        int embeddingNumber = optimizationConfig.getEmbeddingMapperNumber();
-        Double distance = optimizationConfig.getEmbeddingMapperDistanceThreshold();
-        Map<String, String> filterCondition = null;
-        // step1. build query params
-        // if only one modelId, add to filterCondition
-        if (CollectionUtils.isNotEmpty(detectModelIds) && detectModelIds.size() == 1) {
-            filterCondition = new HashMap<>();
-            filterCondition.put("modelId", detectModelIds.stream().findFirst().get().toString());
-        }
-
-        RetrieveQuery retrieveQuery = RetrieveQuery.builder()
-                .queryTextsList(queryTextsSub)
-                .filterCondition(filterCondition)
-                .queryEmbeddings(null)
-                .build();
-        // step2. retrieveQuery by detectSegment
-        List<RetrieveQueryResult> retrieveQueryResults = s2EmbeddingStore.retrieveQuery(
-                embeddingConfig.getMetaCollectionName(), retrieveQuery, embeddingNumber);
-
-        if (CollectionUtils.isEmpty(retrieveQueryResults)) {
-            return;
-        }
-        // step3. build EmbeddingResults. filter by modelId
-        List<EmbeddingResult> collect = retrieveQueryResults.stream()
-                .map(retrieveQueryResult -> {
-                    List<Retrieval> retrievals = retrieveQueryResult.getRetrieval();
-                    if (CollectionUtils.isNotEmpty(retrievals)) {
-                        retrievals.removeIf(retrieval -> retrieval.getDistance() > distance.doubleValue());
-                        if (CollectionUtils.isNotEmpty(detectModelIds)) {
-                            retrievals.removeIf(retrieval -> {
-                                String modelIdStr = retrieval.getMetadata().get("modelId").toString();
-                                if (StringUtils.isBlank(modelIdStr)) {
-                                    return true;
-                                }
-                                return detectModelIds.contains(Long.parseLong(modelIdStr));
-                            });
-                        }
-                    }
-                    return retrieveQueryResult;
-                })
-                .filter(retrieveQueryResult -> CollectionUtils.isNotEmpty(retrieveQueryResult.getRetrieval()))
-                .flatMap(retrieveQueryResult -> retrieveQueryResult.getRetrieval().stream()
-                        .map(retrieval -> {
-                            EmbeddingResult embeddingResult = new EmbeddingResult();
-                            BeanUtils.copyProperties(retrieval, embeddingResult);
-                            embeddingResult.setDetectWord(retrieveQueryResult.getQuery());
-                            embeddingResult.setName(retrieval.getQuery());
-                            return embeddingResult;
-                        }))
-                .collect(Collectors.toList());
-
-        // step4. select mapResul in one round
-        int roundNumber = optimizationConfig.getEmbeddingMapperRoundNumber() * queryTextsSub.size();
-        List<EmbeddingResult> oneRoundResults = collect.stream()
-                .sorted(Comparator.comparingDouble(EmbeddingResult::getDistance))
-                .limit(roundNumber)
-                .collect(Collectors.toList());
-        selectResultInOneRound(results, oneRoundResults);
-    }
-
-    @Override
-    public void detectByStep(QueryContext queryContext, Set<EmbeddingResult> existResults, Set<Long> detectModelIds,
-            Integer startIndex, Integer index, int offset) {
-        return;
-    }
-}

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

@@ -1,121 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.knowledge.HanlpMapResult;
-import com.tencent.supersonic.chat.core.knowledge.SearchService;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.pojo.Constants;
-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.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-/**
- * HanlpDictMatchStrategy uses <a href="https://www.hanlp.com/">HanLP</a> to
- * match schema elements. It currently supports prefix and suffix matching
- * against names, values and aliases.
- */
-@Service
-@Slf4j
-public class HanlpDictMatchStrategy extends BaseMatchStrategy<HanlpMapResult> {
-
-    @Autowired
-    private MapperHelper mapperHelper;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Override
-    public Map<MatchText, List<HanlpMapResult>> match(QueryContext queryContext, List<Term> terms,
-            Set<Long> detectModelIds) {
-        String text = queryContext.getQueryText();
-        if (Objects.isNull(terms) || StringUtils.isEmpty(text)) {
-            return null;
-        }
-
-        log.debug("retryCount:{},terms:{},,detectModelIds:{}", terms, detectModelIds);
-
-        List<HanlpMapResult> detects = detect(queryContext, terms, detectModelIds);
-        Map<MatchText, List<HanlpMapResult>> result = new HashMap<>();
-
-        result.put(MatchText.builder().regText(text).detectSegment(text).build(), detects);
-        return result;
-    }
-
-    @Override
-    public boolean needDelete(HanlpMapResult oneRoundResult, HanlpMapResult existResult) {
-        return getMapKey(oneRoundResult).equals(getMapKey(existResult))
-                && existResult.getDetectWord().length() < oneRoundResult.getDetectWord().length();
-    }
-
-    public void detectByStep(QueryContext queryContext, Set<HanlpMapResult> existResults, Set<Long> detectModelIds,
-            Integer startIndex, Integer index, int offset) {
-        String text = queryContext.getQueryText();
-        Integer agentId = queryContext.getAgentId();
-        String detectSegment = text.substring(startIndex, index);
-
-        // step1. pre search
-        Integer oneDetectionMaxSize = optimizationConfig.getOneDetectionMaxSize();
-        LinkedHashSet<HanlpMapResult> hanlpMapResults = SearchService.prefixSearch(detectSegment, oneDetectionMaxSize,
-                agentId, detectModelIds).stream().collect(Collectors.toCollection(LinkedHashSet::new));
-        // step2. suffix search
-        LinkedHashSet<HanlpMapResult> suffixHanlpMapResults = SearchService.suffixSearch(detectSegment,
-                        oneDetectionMaxSize, agentId, detectModelIds).stream()
-                .collect(Collectors.toCollection(LinkedHashSet::new));
-
-        hanlpMapResults.addAll(suffixHanlpMapResults);
-
-        if (CollectionUtils.isEmpty(hanlpMapResults)) {
-            return;
-        }
-        // step3. merge pre/suffix result
-        hanlpMapResults = hanlpMapResults.stream().sorted((a, b) -> -(b.getName().length() - a.getName().length()))
-                .collect(Collectors.toCollection(LinkedHashSet::new));
-
-        // step4. filter by similarity
-        hanlpMapResults = hanlpMapResults.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:{}", hanlpMapResults);
-
-        hanlpMapResults = hanlpMapResults.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<HanlpMapResult> dimensionMetrics = hanlpMapResults.stream()
-                .filter(entry -> mapperHelper.existDimensionValues(entry.getNatures()))
-                .collect(Collectors.toList())
-                .stream()
-                .limit(1)
-                .collect(Collectors.toList());
-
-        Integer oneDetectionSize = optimizationConfig.getOneDetectionSize();
-        List<HanlpMapResult> oneRoundResults = hanlpMapResults.stream().limit(oneDetectionSize)
-                .collect(Collectors.toList());
-
-        if (CollectionUtils.isNotEmpty(dimensionMetrics)) {
-            oneRoundResults = dimensionMetrics;
-        }
-        // step6. select mapResul in one round
-        selectResultInOneRound(existResults, oneRoundResults);
-    }
-
-    public String getMapKey(HanlpMapResult a) {
-        return a.getName() + Constants.UNDERLINE + String.join(Constants.UNDERLINE, a.getNatures());
-    }
-}

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

@@ -1,113 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.hankcs.hanlp.algorithm.EditDistance;
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.core.agent.Agent;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.utils.NatureHelper;
-import java.util.Comparator;
-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;
-
-@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<Term> termList, Integer index) {
-        List<Integer> offsetList = termList.stream().sorted(Comparator.comparing(Term::getOffset))
-                .map(term -> term.getOffset()).collect(Collectors.toList());
-
-        for (int j = 0; j < termList.size() - 1; j++) {
-            if (offsetList.get(j) <= index && offsetList.get(j + 1) > index) {
-                return offsetList.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(Long modelId, Agent agent) {
-
-        Set<Long> detectModelIds = new HashSet<>();
-        if (Objects.nonNull(agent)) {
-            detectModelIds = agent.getModelIds(null);
-        }
-        //contains all
-        if (Agent.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/core/mapper/ModelClusterMapper.java

@@ -1,52 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SchemaModelClusterMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.utils.ModelClusterBuilder;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/***
- * ModelClusterMapper build a cluster from
- * connectable data models based on model-rela configuration
- * and generate SchemaModelClusterMapInfo
- */
-public class ModelClusterMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContext queryContext) {
-        SemanticSchema semanticSchema = queryContext.getSemanticSchema();
-        SchemaMapInfo schemaMapInfo = queryContext.getMapInfo();
-        List<ModelCluster> modelClusters = buildModelClusterMatched(schemaMapInfo, semanticSchema);
-        Map<String, List<SchemaElementMatch>> modelClusterElementMatches = new HashMap<>();
-        for (ModelCluster modelCluster : modelClusters) {
-            for (Long modelId : schemaMapInfo.getMatchedModels()) {
-                if (modelCluster.getModelIds().contains(modelId)) {
-                    modelClusterElementMatches.computeIfAbsent(modelCluster.getKey(), k -> new ArrayList<>())
-                            .addAll(schemaMapInfo.getMatchedElements(modelId));
-                }
-            }
-        }
-        SchemaModelClusterMapInfo modelClusterMapInfo = new SchemaModelClusterMapInfo();
-        modelClusterMapInfo.setModelElementMatches(modelClusterElementMatches);
-        queryContext.setModelClusterMapInfo(modelClusterMapInfo);
-    }
-
-    private List<ModelCluster> buildModelClusterMatched(SchemaMapInfo schemaMapInfo,
-            SemanticSchema semanticSchema) {
-        Set<Long> matchedModels = schemaMapInfo.getMatchedModels();
-        List<ModelCluster> modelClusters = ModelClusterBuilder.buildModelClusters(semanticSchema);
-        return modelClusters.stream().map(ModelCluster::getModelIds).peek(modelCluster -> {
-            modelCluster.removeIf(model -> !matchedModels.contains(model));
-        }).filter(modelCluster -> modelCluster.size() > 0).map(ModelCluster::build).collect(Collectors.toList());
-    }
-
-}

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

@@ -1,65 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionPromptGenerator;
-import com.tencent.supersonic.chat.core.parser.sql.llm.OutputFormat;
-import com.tencent.supersonic.chat.core.parser.sql.llm.SqlGeneration;
-import com.tencent.supersonic.chat.core.parser.sql.llm.SqlGenerationFactory;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionReq;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.ContextUtils;
-import dev.langchain4j.model.chat.ChatLanguageModel;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Component;
-
-/**
- * LLMProxy based on langchain4j Java version.
- */
-@Slf4j
-@Component
-public class JavaLLMProxy implements LLMProxy {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-
-    @Override
-    public boolean isSkip(QueryContext queryContext) {
-        ChatLanguageModel chatLanguageModel = ContextUtils.getBean(ChatLanguageModel.class);
-        if (Objects.isNull(chatLanguageModel)) {
-            log.warn("chatLanguageModel is null, skip :{}", JavaLLMProxy.class.getName());
-            return true;
-        }
-        return false;
-    }
-
-    public LLMResp query2sql(LLMReq llmReq, String modelClusterKey) {
-
-        SqlGeneration sqlGeneration = SqlGenerationFactory.get(
-                SqlGenerationMode.getMode(llmReq.getSqlGenerationMode()));
-        String modelName = llmReq.getSchema().getModelName();
-        LLMResp result = sqlGeneration.generation(llmReq, modelClusterKey);
-        result.setQuery(llmReq.getQueryText());
-        result.setModelName(modelName);
-        return result;
-    }
-
-    @Override
-    public FunctionResp requestFunction(FunctionReq functionReq) {
-
-        FunctionPromptGenerator promptGenerator = ContextUtils.getBean(FunctionPromptGenerator.class);
-
-        ChatLanguageModel chatLanguageModel = ContextUtils.getBean(ChatLanguageModel.class);
-        String functionCallPrompt = promptGenerator.generateFunctionCallPrompt(functionReq.getQueryText(),
-                functionReq.getPluginConfigs());
-        keyPipelineLog.info("functionCallPrompt:{}", functionCallPrompt);
-        String response = chatLanguageModel.generate(functionCallPrompt);
-        keyPipelineLog.info("functionCall response:{}", response);
-        return OutputFormat.functionCallParse(response);
-    }
-
-}

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

@@ -1,22 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionReq;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-
-/**
- * LLMProxy encapsulates functions performed by LLMs so that multiple
- * orchestration frameworks (e.g. LangChain in python, LangChain4j in java)
- * could be used.
- */
-public interface LLMProxy {
-
-    boolean isSkip(QueryContext queryContext);
-
-    LLMResp query2sql(LLMReq llmReq, String modelClusterKey);
-
-    FunctionResp requestFunction(FunctionReq functionReq);
-
-}

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

@@ -1,103 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.alibaba.fastjson.JSON;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.config.LLMParserConfig;
-import com.tencent.supersonic.chat.core.parser.sql.llm.OutputFormat;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionCallConfig;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionReq;
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.JsonUtil;
-import java.net.URI;
-import java.net.URL;
-import java.util.ArrayList;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.MapUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Component;
-import org.springframework.web.client.RestTemplate;
-import org.springframework.web.util.UriComponentsBuilder;
-
-/**
- * PythonLLMProxy sends requests to LangChain-based python service.
- */
-@Slf4j
-@Component
-public class PythonLLMProxy implements LLMProxy {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-
-    @Override
-    public boolean isSkip(QueryContext queryContext) {
-        LLMParserConfig llmParserConfig = ContextUtils.getBean(LLMParserConfig.class);
-        if (StringUtils.isEmpty(llmParserConfig.getUrl())) {
-            log.warn("llmParserUrl is empty, skip :{}", PythonLLMProxy.class.getName());
-            return true;
-        }
-        return false;
-    }
-
-    public LLMResp query2sql(LLMReq llmReq, String modelClusterKey) {
-        long startTime = System.currentTimeMillis();
-        log.info("requestLLM request, modelId:{},llmReq:{}", modelClusterKey, llmReq);
-        keyPipelineLog.info("modelClusterKey:{},llmReq:{}", modelClusterKey, llmReq);
-        try {
-            LLMParserConfig llmParserConfig = ContextUtils.getBean(LLMParserConfig.class);
-
-            URL url = new URL(new URL(llmParserConfig.getUrl()), llmParserConfig.getQueryToSqlPath());
-            HttpHeaders headers = new HttpHeaders();
-            headers.setContentType(MediaType.APPLICATION_JSON);
-            HttpEntity<String> entity = new HttpEntity<>(JsonUtil.toString(llmReq), headers);
-            RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-            ResponseEntity<LLMResp> responseEntity = restTemplate.exchange(url.toString(), HttpMethod.POST, entity,
-                    LLMResp.class);
-
-            LLMResp llmResp = responseEntity.getBody();
-            log.info("requestLLM response,cost:{}, questUrl:{} \n entity:{} \n body:{}",
-                    System.currentTimeMillis() - startTime, url, entity, llmResp);
-            keyPipelineLog.info("LLMResp:{}", llmResp);
-
-            if (MapUtils.isEmpty(llmResp.getSqlRespMap())) {
-                llmResp.setSqlRespMap(OutputFormat.buildSqlRespMap(new ArrayList<>(), llmResp.getSqlWeight()));
-            }
-            return llmResp;
-        } catch (Exception e) {
-            log.error("requestLLM error", e);
-        }
-        return null;
-    }
-
-    public FunctionResp requestFunction(FunctionReq functionReq) {
-        FunctionCallConfig functionCallInfoConfig = ContextUtils.getBean(FunctionCallConfig.class);
-        String url = functionCallInfoConfig.getUrl() + functionCallInfoConfig.getPluginSelectPath();
-        HttpHeaders headers = new HttpHeaders();
-        long startTime = System.currentTimeMillis();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        HttpEntity<String> entity = new HttpEntity<>(JSON.toJSONString(functionReq), headers);
-        URI requestUrl = UriComponentsBuilder.fromHttpUrl(url).build().encode().toUri();
-        RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
-        try {
-            log.info("requestFunction functionReq:{}", JsonUtil.toString(functionReq));
-            keyPipelineLog.info("requestFunction functionReq:{}", JsonUtil.toString(functionReq));
-            ResponseEntity<FunctionResp> responseEntity = restTemplate.exchange(requestUrl, HttpMethod.POST, entity,
-                    FunctionResp.class);
-            log.info("requestFunction responseEntity:{},cost:{}", responseEntity,
-                    System.currentTimeMillis() - startTime);
-            keyPipelineLog.info("response:{}", responseEntity.getBody());
-            return responseEntity.getBody();
-        } catch (Exception e) {
-            log.error("requestFunction error", e);
-        }
-        return null;
-    }
-}

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

@@ -1,86 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
-import com.tencent.supersonic.chat.core.query.rule.RuleSemanticQuery;
-import com.tencent.supersonic.common.pojo.enums.QueryType;
-import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-
-/**
- * QueryTypeParser resolves query type as either METRIC or TAG, or ID.
- */
-@Slf4j
-public class QueryTypeParser implements SemanticParser {
-
-    @Override
-    public void parse(QueryContext queryContext, ChatContext chatContext) {
-
-        List<SemanticQuery> candidateQueries = queryContext.getCandidateQueries();
-        User user = queryContext.getUser();
-
-        for (SemanticQuery semanticQuery : candidateQueries) {
-            // 1.init S2SQL
-            semanticQuery.initS2Sql(queryContext.getSemanticSchema(), user);
-            // 2.set queryType
-            QueryType queryType = getQueryType(queryContext, semanticQuery);
-            semanticQuery.getParseInfo().setQueryType(queryType);
-        }
-    }
-
-    private QueryType getQueryType(QueryContext queryContext, SemanticQuery semanticQuery) {
-        SemanticParseInfo parseInfo = semanticQuery.getParseInfo();
-        SqlInfo sqlInfo = parseInfo.getSqlInfo();
-        if (Objects.isNull(sqlInfo) || StringUtils.isBlank(sqlInfo.getS2SQL())) {
-            return QueryType.ID;
-        }
-        //1. entity queryType
-        Set<Long> modelIds = parseInfo.getModel().getModelIds();
-        SemanticSchema semanticSchema = queryContext.getSemanticSchema();
-        if (semanticQuery instanceof RuleSemanticQuery || semanticQuery instanceof LLMSqlQuery) {
-            //If all the fields in the SELECT statement are of tag type.
-            List<String> whereFields = SqlParserSelectHelper.getWhereFields(sqlInfo.getS2SQL())
-                    .stream().filter(field -> !TimeDimensionEnum.containsTimeDimension(field))
-                    .collect(Collectors.toList());
-
-            if (CollectionUtils.isNotEmpty(whereFields)) {
-                Set<String> ids = semanticSchema.getEntities(modelIds).stream().map(SchemaElement::getName)
-                        .collect(Collectors.toSet());
-                if (CollectionUtils.isNotEmpty(ids) && ids.stream().anyMatch(whereFields::contains)) {
-                    return QueryType.ID;
-                }
-                Set<String> tags = semanticSchema.getTags(modelIds).stream().map(SchemaElement::getName)
-                        .collect(Collectors.toSet());
-                if (CollectionUtils.isNotEmpty(tags) && tags.containsAll(whereFields)) {
-                    return QueryType.TAG;
-                }
-            }
-        }
-        //2. metric queryType
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(sqlInfo.getS2SQL());
-        List<SchemaElement> metrics = semanticSchema.getMetrics(modelIds);
-        if (CollectionUtils.isNotEmpty(metrics)) {
-            Set<String> metricNameSet = metrics.stream().map(SchemaElement::getName).collect(Collectors.toSet());
-            boolean containMetric = selectFields.stream().anyMatch(metricNameSet::contains);
-            if (containMetric) {
-                return QueryType.METRIC;
-            }
-        }
-        return QueryType.ID;
-    }
-
-}

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

@@ -1,49 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
-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 isSkip(QueryContext queryContext) {
-        for (SemanticQuery query : queryContext.getCandidateQueries()) {
-            if (query.getQueryMode().equals(LLMSqlQuery.QUERY_MODE)) {
-                continue;
-            }
-            if (checkThreshold(queryContext.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/core/parser/SemanticParser.java

@@ -1,15 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-
-/**
- * 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/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/PluginParser.java

@@ -1,125 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilter;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilters;
-import com.tencent.supersonic.chat.core.parser.SemanticParser;
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import com.tencent.supersonic.chat.core.plugin.PluginManager;
-import com.tencent.supersonic.chat.core.plugin.PluginParseResult;
-import com.tencent.supersonic.chat.core.plugin.PluginRecallResult;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.QueryManager;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.chat.core.query.plugin.PluginSemanticQuery;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import com.tencent.supersonic.common.pojo.enums.FilterOperatorEnum;
-import org.springframework.util.CollectionUtils;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-
-/**
- * PluginParser defines the basic process and common methods for recalling plugins.
- */
-public abstract class PluginParser implements SemanticParser {
-
-    @Override
-    public void parse(QueryContext queryContext, ChatContext chatContext) {
-        for (SemanticQuery semanticQuery : queryContext.getCandidateQueries()) {
-            if (queryContext.getQueryText().length() <= semanticQuery.getParseInfo().getScore()
-                    && (QueryManager.getPluginQueryModes().contains(semanticQuery.getQueryMode()))) {
-                return;
-            }
-        }
-        if (!checkPreCondition(queryContext)) {
-            return;
-        }
-        PluginRecallResult pluginRecallResult = recallPlugin(queryContext);
-        if (pluginRecallResult == null) {
-            return;
-        }
-        buildQuery(queryContext, pluginRecallResult);
-    }
-
-    public abstract boolean checkPreCondition(QueryContext queryContext);
-
-    public abstract PluginRecallResult recallPlugin(QueryContext queryContext);
-
-    public void buildQuery(QueryContext queryContext, PluginRecallResult pluginRecallResult) {
-        Plugin plugin = pluginRecallResult.getPlugin();
-        Set<Long> modelIds = pluginRecallResult.getModelIds();
-        if (plugin.isContainsAllModel()) {
-            modelIds = Sets.newHashSet(-1L);
-        }
-        for (Long modelId : modelIds) {
-            PluginSemanticQuery pluginQuery = QueryManager.createPluginQuery(plugin.getType());
-            SemanticParseInfo semanticParseInfo = buildSemanticParseInfo(modelId, plugin,
-                    queryContext, pluginRecallResult.getDistance());
-            semanticParseInfo.setQueryMode(pluginQuery.getQueryMode());
-            semanticParseInfo.setScore(pluginRecallResult.getScore());
-            pluginQuery.setParseInfo(semanticParseInfo);
-            queryContext.getCandidateQueries().add(pluginQuery);
-        }
-    }
-
-    protected List<Plugin> getPluginList(QueryContext queryContext) {
-        return PluginManager.getPluginAgentCanSupport(queryContext);
-    }
-
-    protected SemanticParseInfo buildSemanticParseInfo(Long modelId, Plugin plugin,
-                                                       QueryContext queryContext, double distance) {
-        List<SchemaElementMatch> schemaElementMatches =
-                queryContext.getModelClusterMapInfo().getMatchedElements(modelId);
-        QueryFilters queryFilters = queryContext.getQueryFilters();
-        if (modelId == null && !CollectionUtils.isEmpty(plugin.getModelList())) {
-            modelId = plugin.getModelList().get(0);
-        }
-        if (schemaElementMatches == null) {
-            schemaElementMatches = Lists.newArrayList();
-        }
-        SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
-        semanticParseInfo.setElementMatches(schemaElementMatches);
-        semanticParseInfo.setModel(ModelCluster.build(Sets.newHashSet(modelId)));
-        Map<String, Object> properties = new HashMap<>();
-        PluginParseResult pluginParseResult = new PluginParseResult();
-        pluginParseResult.setPlugin(plugin);
-        pluginParseResult.setQueryFilters(queryFilters);
-        pluginParseResult.setDistance(distance);
-        pluginParseResult.setQueryText(queryContext.getQueryText());
-        properties.put(Constants.CONTEXT, pluginParseResult);
-        properties.put("type", "plugin");
-        properties.put("name", plugin.getName());
-        semanticParseInfo.setProperties(properties);
-        semanticParseInfo.setScore(distance);
-        fillSemanticParseInfo(semanticParseInfo);
-        return semanticParseInfo;
-    }
-
-    private void fillSemanticParseInfo(SemanticParseInfo semanticParseInfo) {
-        List<SchemaElementMatch> schemaElementMatches = semanticParseInfo.getElementMatches();
-        if (CollectionUtils.isEmpty(schemaElementMatches)) {
-            return;
-        }
-        schemaElementMatches.stream().filter(schemaElementMatch ->
-                        SchemaElementType.VALUE.equals(schemaElementMatch.getElement().getType())
-                                || SchemaElementType.ID.equals(schemaElementMatch.getElement().getType()))
-                .forEach(schemaElementMatch -> {
-                    QueryFilter queryFilter = new QueryFilter();
-                    queryFilter.setValue(schemaElementMatch.getWord());
-                    queryFilter.setElementID(schemaElementMatch.getElement().getId());
-                    queryFilter.setName(schemaElementMatch.getElement().getName());
-                    queryFilter.setOperator(FilterOperatorEnum.EQUALS);
-                    queryFilter.setBizName(schemaElementMatch.getElement().getBizName());
-                    semanticParseInfo.getDimensionFilters().add(queryFilter);
-                });
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/FunctionCallConfig.java

@@ -1,15 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-public class FunctionCallConfig {
-    @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/core/parser/plugin/function/FunctionCallParser.java

@@ -1,126 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import com.tencent.supersonic.chat.core.parser.PythonLLMProxy;
-import com.tencent.supersonic.chat.core.parser.plugin.ParseMode;
-import com.tencent.supersonic.chat.core.parser.plugin.PluginParser;
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import com.tencent.supersonic.chat.core.plugin.PluginManager;
-import com.tencent.supersonic.chat.core.plugin.PluginParseConfig;
-import com.tencent.supersonic.chat.core.plugin.PluginRecallResult;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
-import com.tencent.supersonic.chat.core.utils.ComponentFactory;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.JsonUtil;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-import org.springframework.util.CollectionUtils;
-
-/**
- * FunctionCallParser is an implementation of a recall plugin based on FunctionCall
- */
-@Slf4j
-public class FunctionCallParser extends PluginParser {
-
-    @Override
-    public boolean checkPreCondition(QueryContext queryContext) {
-        FunctionCallConfig functionCallConfig = ContextUtils.getBean(FunctionCallConfig.class);
-        String functionUrl = functionCallConfig.getUrl();
-        if (StringUtils.isBlank(functionUrl) && ComponentFactory.getLLMProxy() instanceof PythonLLMProxy) {
-            log.info("functionUrl:{}, skip function parser, queryText:{}", functionUrl,
-                    queryContext.getQueryText());
-            return false;
-        }
-        List<Plugin> plugins = getPluginList(queryContext);
-        return !CollectionUtils.isEmpty(plugins);
-    }
-
-    @Override
-    public PluginRecallResult recallPlugin(QueryContext queryContext) {
-        FunctionResp functionResp = functionCall(queryContext);
-        if (skipFunction(functionResp)) {
-            return null;
-        }
-        log.info("requestFunction result:{}", functionResp.getToolSelection());
-        String toolSelection = functionResp.getToolSelection();
-        Plugin plugin = queryContext.getNameToPlugin().get(toolSelection);
-        if (Objects.isNull(plugin)) {
-            log.info("pluginOptional is not exist:{}, skip the parse", toolSelection);
-            return null;
-        }
-        plugin.setParseMode(ParseMode.FUNCTION_CALL);
-        Pair<Boolean, Set<Long>> pluginResolveResult = PluginManager.resolve(plugin, queryContext);
-        if (pluginResolveResult.getLeft()) {
-            Set<Long> modelList = pluginResolveResult.getRight();
-            if (CollectionUtils.isEmpty(modelList)) {
-                return null;
-            }
-            double score = queryContext.getQueryText().length();
-            return PluginRecallResult.builder().plugin(plugin).modelIds(modelList).score(score).build();
-        }
-        return null;
-    }
-
-    public FunctionResp functionCall(QueryContext queryContext) {
-        List<PluginParseConfig> pluginToFunctionCall =
-                getPluginToFunctionCall(queryContext.getModelId(), queryContext);
-        if (CollectionUtils.isEmpty(pluginToFunctionCall)) {
-            log.info("function call parser, plugin is empty, skip");
-            return null;
-        }
-        FunctionResp functionResp = new FunctionResp();
-        if (pluginToFunctionCall.size() == 1) {
-            functionResp.setToolSelection(pluginToFunctionCall.iterator().next().getName());
-        } else {
-            FunctionReq functionReq = FunctionReq.builder()
-                    .queryText(queryContext.getQueryText())
-                    .pluginConfigs(pluginToFunctionCall).build();
-            functionResp = ComponentFactory.getLLMProxy().requestFunction(functionReq);
-        }
-        return functionResp;
-    }
-
-    private boolean skipFunction(FunctionResp functionResp) {
-        return Objects.isNull(functionResp) || StringUtils.isBlank(functionResp.getToolSelection());
-    }
-
-    private List<PluginParseConfig> getPluginToFunctionCall(Long modelId, QueryContext queryContext) {
-        log.info("user decide Model:{}", modelId);
-        List<Plugin> plugins = getPluginList(queryContext);
-        List<PluginParseConfig> functionDOList = plugins.stream().filter(plugin -> {
-            if (LLMSqlQuery.QUERY_MODE.equalsIgnoreCase(plugin.getType())) {
-                return false;
-            }
-            if (plugin.getParseModeConfig() == null) {
-                return false;
-            }
-            PluginParseConfig pluginParseConfig = JsonUtil.toObject(plugin.getParseModeConfig(),
-                    PluginParseConfig.class);
-            if (StringUtils.isBlank(pluginParseConfig.getName())) {
-                return false;
-            }
-            Pair<Boolean, Set<Long>> pluginResolverResult = PluginManager.resolve(plugin, queryContext);
-            log.info("plugin [{}-{}] resolve: {}", plugin.getId(), plugin.getName(), pluginResolverResult);
-            if (!pluginResolverResult.getLeft()) {
-                return false;
-            } else {
-                Set<Long> resolveModel = pluginResolverResult.getRight();
-                if (modelId != null && modelId > 0) {
-                    if (plugin.isContainsAllModel()) {
-                        return true;
-                    }
-                    return resolveModel.contains(modelId);
-                }
-                return true;
-            }
-        }).map(o -> JsonUtil.toObject(o.getParseModeConfig(), PluginParseConfig.class)).collect(Collectors.toList());
-        log.info("PluginToFunctionCall: {}", JsonUtil.toString(functionDOList));
-        return functionDOList;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/FunctionFiled.java

@@ -1,13 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-
-import lombok.Data;
-
-@Data
-public class FunctionFiled {
-
-    private String type;
-
-    private String description;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/FunctionPromptGenerator.java

@@ -1,44 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import com.tencent.supersonic.chat.core.parser.sql.llm.InputFormat;
-import com.tencent.supersonic.chat.core.plugin.PluginParseConfig;
-import java.util.List;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-@Component
-@Slf4j
-public class FunctionPromptGenerator {
-
-    public String generateFunctionCallPrompt(String queryText, List<PluginParseConfig> toolConfigList) {
-        List<String> toolExplainList = toolConfigList.stream()
-                .map(this::constructPluginPrompt)
-                .collect(Collectors.toList());
-        String functionList = String.join(InputFormat.SEPERATOR, toolExplainList);
-        return constructTaskPrompt(queryText, functionList);
-    }
-
-    public String constructPluginPrompt(PluginParseConfig parseConfig) {
-        String toolName = parseConfig.getName();
-        String toolDescription = parseConfig.getDescription();
-        List<String> toolExamples = parseConfig.getExamples();
-
-        StringBuilder prompt = new StringBuilder();
-        prompt.append("【工具名称】\n").append(toolName).append("\n");
-        prompt.append("【工具描述】\n").append(toolDescription).append("\n");
-        prompt.append("【工具适用问题示例】\n");
-        for (String example : toolExamples) {
-            prompt.append(example).append("\n");
-        }
-        return prompt.toString();
-    }
-
-    public String constructTaskPrompt(String queryText, String functionList) {
-        String instruction = String.format("问题为:%s\n请根据问题和工具的描述，选择对应的工具，完成任务。"
-                + "请注意，只能选择1个工具。请一步一步地分析选择工具的原因(每个工具的【工具适用问题示例】是选择的重要参考依据)，"
-                + "并给出最终选择，输出格式为json,key为’分析过程‘, ’选择工具‘", queryText);
-
-        return String.format("工具选择如下:\n\n%s\n\n【任务说明】\n%s", functionList, instruction);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/FunctionReq.java

@@ -1,17 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import com.tencent.supersonic.chat.core.plugin.PluginParseConfig;
-import java.util.List;
-
-import lombok.Builder;
-import lombok.Data;
-
-@Data
-@Builder
-public class FunctionReq {
-
-    private String queryText;
-
-    private List<PluginParseConfig> pluginConfigs;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/FunctionResp.java

@@ -1,10 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import lombok.Data;
-
-@Data
-public class FunctionResp {
-
-    private String toolSelection;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/plugin/function/Parameters.java

@@ -1,17 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.plugin.function;
-
-import lombok.Data;
-import java.util.List;
-import java.util.Map;
-
-@Data
-public class Parameters {
-
-    //default: object
-    private String type = "object";
-
-    private Map<String, FunctionFiled> properties;
-
-    private List<String> required;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/HeuristicModelResolver.java

@@ -1,146 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaModelClusterMapInfo;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-
-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;
-
-@Slf4j
-public class HeuristicModelResolver implements ModelResolver {
-
-    protected static String selectModelBySchemaElementMatchScore(Map<String, SemanticQuery> modelQueryModes,
-            SchemaModelClusterMapInfo schemaMap) {
-        //model count priority
-        String modelIdByModelCount = getModelIdByMatchModelScore(schemaMap);
-        if (Objects.nonNull(modelIdByModelCount)) {
-            log.info("selectModel by model count:{}", modelIdByModelCount);
-            return modelIdByModelCount;
-        }
-
-        Map<String, ModelMatchResult> modelTypeMap = getModelTypeMap(schemaMap);
-        if (modelTypeMap.size() == 1) {
-            String modelSelect = modelTypeMap.entrySet().stream().collect(Collectors.toList()).get(0).getKey();
-            if (modelQueryModes.containsKey(modelSelect)) {
-                log.info("selectModel with only one Model [{}]", modelSelect);
-                return modelSelect;
-            }
-        } else {
-            Map.Entry<String, ModelMatchResult> maxModel = modelTypeMap.entrySet().stream()
-                    .filter(entry -> modelQueryModes.containsKey(entry.getKey()))
-                    .sorted((o1, o2) -> {
-                        int difference = o2.getValue().getCount() - o1.getValue().getCount();
-                        if (difference == 0) {
-                            return (int) ((o2.getValue().getMaxSimilarity()
-                                    - o1.getValue().getMaxSimilarity()) * 100);
-                        }
-                        return difference;
-                    }).findFirst().orElse(null);
-            if (maxModel != null) {
-                log.info("selectModel with multiple Models [{}]", maxModel.getKey());
-                return maxModel.getKey();
-            }
-        }
-        return null;
-    }
-
-    private static String getModelIdByMatchModelScore(SchemaModelClusterMapInfo schemaMap) {
-        Map<String, List<SchemaElementMatch>> modelElementMatches = schemaMap.getModelElementMatches();
-        // calculate model match score, matched element gets 1.0 point, and inherit element gets 0.5 point
-        Map<String, Double> modelIdToModelScore = new HashMap<>();
-        if (Objects.nonNull(modelElementMatches)) {
-            for (Entry<String, List<SchemaElementMatch>> modelElementMatch : modelElementMatches.entrySet()) {
-                String modelId = modelElementMatch.getKey();
-                List<Double> modelMatchesScore = modelElementMatch.getValue().stream()
-                        .filter(elementMatch -> elementMatch.getSimilarity() >= 1)
-                        .filter(elementMatch -> SchemaElementType.MODEL.equals(elementMatch.getElement().getType()))
-                        .map(elementMatch -> elementMatch.isInherited() ? 0.5 : 1.0).collect(Collectors.toList());
-
-                if (!CollectionUtils.isEmpty(modelMatchesScore)) {
-                    // get sum of model match score
-                    double score = modelMatchesScore.stream().mapToDouble(Double::doubleValue).sum();
-                    modelIdToModelScore.put(modelId, score);
-                }
-            }
-            Entry<String, Double> maxModelScore = modelIdToModelScore.entrySet().stream()
-                    .max(Comparator.comparingDouble(o -> o.getValue())).orElse(null);
-            log.info("maxModelCount:{},modelIdToModelCount:{}", maxModelScore, modelIdToModelScore);
-            if (Objects.nonNull(maxModelScore)) {
-                return maxModelScore.getKey();
-            }
-        }
-        return null;
-    }
-
-    public static Map<String, ModelMatchResult> getModelTypeMap(SchemaModelClusterMapInfo schemaMap) {
-        Map<String, ModelMatchResult> modelCount = new HashMap<>();
-        for (Map.Entry<String, List<SchemaElementMatch>> entry : schemaMap.getModelElementMatches().entrySet()) {
-            List<SchemaElementMatch> schemaElementMatches = schemaMap.getMatchedElements(entry.getKey());
-            if (schemaElementMatches != null && schemaElementMatches.size() > 0) {
-                if (!modelCount.containsKey(entry.getKey())) {
-                    modelCount.put(entry.getKey(), new ModelMatchResult());
-                }
-                ModelMatchResult modelMatchResult = modelCount.get(entry.getKey());
-                Set<SchemaElementType> schemaElementTypes = new HashSet<>();
-                schemaElementMatches.stream()
-                        .forEach(schemaElementMatch -> schemaElementTypes.add(
-                                schemaElementMatch.getElement().getType()));
-                SchemaElementMatch schemaElementMatchMax = schemaElementMatches.stream()
-                        .sorted((o1, o2) ->
-                                ((int) ((o2.getSimilarity() - o1.getSimilarity()) * 100))
-                        ).findFirst().orElse(null);
-                if (schemaElementMatchMax != null) {
-                    modelMatchResult.setMaxSimilarity(schemaElementMatchMax.getSimilarity());
-                }
-                modelMatchResult.setCount(schemaElementTypes.size());
-
-            }
-        }
-        return modelCount;
-    }
-
-    public String resolve(QueryContext queryContext, ChatContext chatCtx, Set<Long> restrictiveModels) {
-        SchemaModelClusterMapInfo mapInfo = queryContext.getModelClusterMapInfo();
-        Set<String> matchedModelClusters = mapInfo.getElementMatchesByModelIds(restrictiveModels).keySet();
-        Long modelId = queryContext.getModelId();
-        if (Objects.nonNull(modelId) && modelId > 0) {
-            if (CollectionUtils.isEmpty(restrictiveModels) || restrictiveModels.contains(modelId)) {
-                return getModelClusterByModelId(modelId, matchedModelClusters);
-            }
-            return null;
-        }
-
-        Map<String, SemanticQuery> modelQueryModes = new HashMap<>();
-        for (String matchedModel : matchedModelClusters) {
-            modelQueryModes.put(matchedModel, null);
-        }
-        if (modelQueryModes.size() == 1) {
-            return modelQueryModes.keySet().stream().findFirst().get();
-        }
-        return selectModelBySchemaElementMatchScore(modelQueryModes, mapInfo);
-    }
-
-    private String getModelClusterByModelId(Long modelId, Set<String> modelClusterKeySet) {
-        for (String modelClusterKey : modelClusterKeySet) {
-            if (ModelCluster.build(modelClusterKey).getModelIds().contains(modelId)) {
-                return modelClusterKey;
-            }
-        }
-        return null;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/LLMRequestService.java

@@ -1,284 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-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.SemanticSchema;
-import com.tencent.supersonic.chat.core.agent.Agent;
-import com.tencent.supersonic.chat.core.agent.AgentToolType;
-import com.tencent.supersonic.chat.core.agent.NL2SQLTool;
-import com.tencent.supersonic.chat.core.config.LLMParserConfig;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.knowledge.semantic.SemanticInterpreter;
-import com.tencent.supersonic.chat.core.parser.SatisfactionChecker;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.QueryManager;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.ElementValue;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
-import com.tencent.supersonic.chat.core.utils.ComponentFactory;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import com.tencent.supersonic.common.pojo.enums.DataFormatTypeEnum;
-import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.DateUtils;
-import com.tencent.supersonic.headless.api.pojo.SchemaItem;
-import com.tencent.supersonic.headless.api.response.ModelSchemaResp;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-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.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-@Service
-public class LLMRequestService {
-
-    protected SemanticInterpreter semanticInterpreter = ComponentFactory.getSemanticLayer();
-    @Autowired
-    private LLMParserConfig llmParserConfig;
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    public boolean isSkip(QueryContext queryCtx) {
-        if (ComponentFactory.getLLMProxy().isSkip(queryCtx)) {
-            return true;
-        }
-        if (SatisfactionChecker.isSkip(queryCtx)) {
-            log.info("skip {}, queryText:{}", LLMSqlParser.class, queryCtx.getQueryText());
-            return true;
-        }
-        return false;
-    }
-
-    public ModelCluster getModelCluster(QueryContext queryCtx, ChatContext chatCtx) {
-        Agent agent = queryCtx.getAgent();
-        Set<Long> distinctModelIds = new HashSet<>();
-        if (Objects.nonNull(agent)) {
-            distinctModelIds = agent.getModelIds(AgentToolType.NL2SQL_LLM);
-        }
-        if (llmParserConfig.getAllModel()) {
-            ModelCluster modelCluster = ModelCluster.build(distinctModelIds);
-            if (!CollectionUtils.isEmpty(queryCtx.getCandidateQueries())) {
-                queryCtx.getCandidateQueries().stream().forEach(o -> {
-                    if (LLMSqlQuery.QUERY_MODE.equals(o.getParseInfo().getQueryMode())) {
-                        o.getParseInfo().setModel(modelCluster);
-                    }
-                });
-            }
-            SemanticQuery semanticQuery = QueryManager.createQuery(LLMSqlQuery.QUERY_MODE);
-            semanticQuery.getParseInfo().setModel(modelCluster);
-            List<SchemaElementMatch> schemaElementMatches = new ArrayList<>();
-            distinctModelIds.stream().forEach(o -> {
-                if (!CollectionUtils.isEmpty(queryCtx.getMapInfo().getMatchedElements(o))) {
-                    schemaElementMatches.addAll(queryCtx.getMapInfo().getMatchedElements(o));
-                }
-            });
-            queryCtx.getModelClusterMapInfo().setMatchedElements(modelCluster.getKey(), schemaElementMatches);
-            return modelCluster;
-        }
-        if (Agent.containsAllModel(distinctModelIds)) {
-            distinctModelIds = new HashSet<>();
-        }
-        ModelResolver modelResolver = ComponentFactory.getModelResolver();
-        String modelCluster = modelResolver.resolve(queryCtx, chatCtx, distinctModelIds);
-        log.info("resolve modelId:{},llmParser Models:{}", modelCluster, distinctModelIds);
-        return ModelCluster.build(modelCluster);
-    }
-
-    public NL2SQLTool getParserTool(QueryContext queryCtx, Set<Long> modelIdSet) {
-        Agent agent = queryCtx.getAgent();
-        List<NL2SQLTool> commonAgentTools = agent.getParserTools(AgentToolType.NL2SQL_LLM);
-        Optional<NL2SQLTool> llmParserTool = commonAgentTools.stream()
-                .filter(tool -> {
-                    List<Long> modelIds = tool.getModelIds();
-                    if (Agent.containsAllModel(new HashSet<>(modelIds))) {
-                        return true;
-                    }
-                    for (Long modelId : modelIdSet) {
-                        if (modelIds.contains(modelId)) {
-                            return true;
-                        }
-                    }
-                    return false;
-                })
-                .findFirst();
-        return llmParserTool.orElse(null);
-    }
-
-    public LLMReq getLlmReq(QueryContext queryCtx, SemanticSchema semanticSchema,
-            ModelCluster modelCluster, List<ElementValue> linkingValues) {
-        Map<Long, String> modelIdToName = semanticSchema.getModelIdToName();
-        String queryText = queryCtx.getQueryText();
-
-        LLMReq llmReq = new LLMReq();
-        llmReq.setQueryText(queryText);
-        Long firstModelId = modelCluster.getFirstModel();
-        LLMReq.FilterCondition filterCondition = new LLMReq.FilterCondition();
-        llmReq.setFilterCondition(filterCondition);
-
-        LLMReq.LLMSchema llmSchema = new LLMReq.LLMSchema();
-        llmSchema.setModelName(modelIdToName.get(firstModelId));
-        llmSchema.setDomainName(modelIdToName.get(firstModelId));
-
-        List<String> fieldNameList = getFieldNameList(queryCtx, modelCluster, llmParserConfig);
-
-        String priorExts = getPriorExts(modelCluster.getModelIds(), fieldNameList);
-        llmReq.setPriorExts(priorExts);
-
-        fieldNameList.add(TimeDimensionEnum.DAY.getChName());
-        llmSchema.setFieldNameList(fieldNameList);
-        llmReq.setSchema(llmSchema);
-
-        List<ElementValue> linking = new ArrayList<>();
-        if (optimizationConfig.isUseLinkingValueSwitch()) {
-            linking.addAll(linkingValues);
-        }
-        llmReq.setLinking(linking);
-
-        String currentDate = S2SqlDateHelper.getReferenceDate(queryCtx, firstModelId);
-        if (StringUtils.isEmpty(currentDate)) {
-            currentDate = DateUtils.getBeforeDate(0);
-        }
-        llmReq.setCurrentDate(currentDate);
-        llmReq.setSqlGenerationMode(optimizationConfig.getSqlGenerationMode().getName());
-        return llmReq;
-    }
-
-    public LLMResp requestLLM(LLMReq llmReq, String modelClusterKey) {
-        return ComponentFactory.getLLMProxy().query2sql(llmReq, modelClusterKey);
-    }
-
-    protected List<String> getFieldNameList(QueryContext queryCtx, ModelCluster modelCluster,
-            LLMParserConfig llmParserConfig) {
-
-        Set<String> results = getTopNFieldNames(queryCtx, modelCluster, llmParserConfig);
-
-        Set<String> fieldNameList = getMatchedFieldNames(queryCtx, modelCluster);
-
-        results.addAll(fieldNameList);
-        return new ArrayList<>(results);
-    }
-
-    private String getPriorExts(Set<Long> modelIds, List<String> fieldNameList) {
-        StringBuilder extraInfoSb = new StringBuilder();
-        List<ModelSchemaResp> modelSchemaResps = semanticInterpreter.fetchModelSchema(
-                new ArrayList<>(modelIds), true);
-        if (!CollectionUtils.isEmpty(modelSchemaResps)) {
-
-            ModelSchemaResp modelSchemaResp = modelSchemaResps.get(0);
-            Map<String, String> fieldNameToDataFormatType = modelSchemaResp.getMetrics()
-                    .stream().filter(metricSchemaResp -> Objects.nonNull(metricSchemaResp.getDataFormatType()))
-                    .flatMap(metricSchemaResp -> {
-                        Set<Pair<String, String>> result = new HashSet<>();
-                        String dataFormatType = metricSchemaResp.getDataFormatType();
-                        result.add(Pair.of(metricSchemaResp.getName(), dataFormatType));
-                        List<String> aliasList = SchemaItem.getAliasList(metricSchemaResp.getAlias());
-                        if (!CollectionUtils.isEmpty(aliasList)) {
-                            for (String alias : aliasList) {
-                                result.add(Pair.of(alias, dataFormatType));
-                            }
-                        }
-                        return result.stream();
-                    })
-                    .collect(Collectors.toMap(a -> a.getLeft(), a -> a.getRight(), (k1, k2) -> k1));
-
-            for (String fieldName : fieldNameList) {
-                String dataFormatType = fieldNameToDataFormatType.get(fieldName);
-                if (DataFormatTypeEnum.DECIMAL.getName().equalsIgnoreCase(dataFormatType)
-                        || DataFormatTypeEnum.PERCENT.getName().equalsIgnoreCase(dataFormatType)) {
-                    String format = String.format("%s的计量单位是%s", fieldName, "小数; ");
-                    extraInfoSb.append(format);
-                }
-            }
-        }
-        return extraInfoSb.toString();
-    }
-
-    protected List<ElementValue> getValueList(QueryContext queryCtx, ModelCluster modelCluster) {
-        Map<Long, String> itemIdToName = getItemIdToName(queryCtx, modelCluster);
-
-        List<SchemaElementMatch> matchedElements = queryCtx.getModelClusterMapInfo()
-                .getMatchedElements(modelCluster.getKey());
-        if (CollectionUtils.isEmpty(matchedElements)) {
-            return new ArrayList<>();
-        }
-        Set<ElementValue> valueMatches = matchedElements
-                .stream()
-                .filter(elementMatch -> !elementMatch.isInherited())
-                .filter(schemaElementMatch -> {
-                    SchemaElementType type = schemaElementMatch.getElement().getType();
-                    return SchemaElementType.VALUE.equals(type) || SchemaElementType.ID.equals(type);
-                })
-                .map(elementMatch -> {
-                    ElementValue elementValue = new ElementValue();
-                    elementValue.setFieldName(itemIdToName.get(elementMatch.getElement().getId()));
-                    elementValue.setFieldValue(elementMatch.getWord());
-                    return elementValue;
-                }).collect(Collectors.toSet());
-        return new ArrayList<>(valueMatches);
-    }
-
-    protected Map<Long, String> getItemIdToName(QueryContext queryCtx, ModelCluster modelCluster) {
-        SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-        return semanticSchema.getDimensions(modelCluster.getModelIds()).stream()
-                .collect(Collectors.toMap(SchemaElement::getId, SchemaElement::getName, (value1, value2) -> value2));
-    }
-
-    private Set<String> getTopNFieldNames(QueryContext queryCtx, ModelCluster modelCluster,
-            LLMParserConfig llmParserConfig) {
-        SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-        Set<String> results = semanticSchema.getDimensions(modelCluster.getModelIds()).stream()
-                .sorted(Comparator.comparing(SchemaElement::getUseCnt).reversed())
-                .limit(llmParserConfig.getDimensionTopN())
-                .map(entry -> entry.getName())
-                .collect(Collectors.toSet());
-
-        Set<String> metrics = semanticSchema.getMetrics(modelCluster.getModelIds()).stream()
-                .sorted(Comparator.comparing(SchemaElement::getUseCnt).reversed())
-                .limit(llmParserConfig.getMetricTopN())
-                .map(entry -> entry.getName())
-                .collect(Collectors.toSet());
-
-        results.addAll(metrics);
-        return results;
-    }
-
-    protected Set<String> getMatchedFieldNames(QueryContext queryCtx, ModelCluster modelCluster) {
-        Map<Long, String> itemIdToName = getItemIdToName(queryCtx, modelCluster);
-        List<SchemaElementMatch> matchedElements = queryCtx.getModelClusterMapInfo()
-                .getMatchedElements(modelCluster.getKey());
-        if (CollectionUtils.isEmpty(matchedElements)) {
-            return new HashSet<>();
-        }
-        Set<String> fieldNameList = matchedElements.stream()
-                .filter(schemaElementMatch -> {
-                    SchemaElementType elementType = schemaElementMatch.getElement().getType();
-                    return SchemaElementType.METRIC.equals(elementType)
-                            || SchemaElementType.DIMENSION.equals(elementType)
-                            || SchemaElementType.VALUE.equals(elementType);
-                })
-                .map(schemaElementMatch -> {
-                    SchemaElement element = schemaElementMatch.getElement();
-                    SchemaElementType elementType = element.getType();
-                    if (SchemaElementType.VALUE.equals(elementType)) {
-                        return itemIdToName.get(element.getId());
-                    }
-                    return schemaElementMatch.getWord();
-                })
-                .collect(Collectors.toSet());
-        return fieldNameList;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/LLMSqlParser.java

@@ -1,77 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.core.agent.NL2SQLTool;
-import com.tencent.supersonic.chat.core.parser.SemanticParser;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.ElementValue;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlResp;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import com.tencent.supersonic.common.util.ContextUtils;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.MapUtils;
-import org.apache.commons.lang3.StringUtils;
-
-@Slf4j
-public class LLMSqlParser implements SemanticParser {
-
-    @Override
-    public void parse(QueryContext queryCtx, ChatContext chatCtx) {
-        LLMRequestService requestService = ContextUtils.getBean(LLMRequestService.class);
-        //1.determine whether to skip this parser.
-        if (requestService.isSkip(queryCtx)) {
-            return;
-        }
-        try {
-            //2.get modelId from queryCtx and chatCtx.
-            ModelCluster modelCluster = requestService.getModelCluster(queryCtx, chatCtx);
-            if (StringUtils.isBlank(modelCluster.getKey())) {
-                return;
-            }
-            //3.get agent tool and determine whether to skip this parser.
-            NL2SQLTool commonAgentTool = requestService.getParserTool(queryCtx, modelCluster.getModelIds());
-            if (Objects.isNull(commonAgentTool)) {
-                log.info("no tool in this agent, skip {}", LLMSqlParser.class);
-                return;
-            }
-            //4.construct a request, call the API for the large model, and retrieve the results.
-            List<ElementValue> linkingValues = requestService.getValueList(queryCtx, modelCluster);
-            SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-            LLMReq llmReq = requestService.getLlmReq(queryCtx, semanticSchema, modelCluster, linkingValues);
-            LLMResp llmResp = requestService.requestLLM(llmReq, modelCluster.getKey());
-
-            if (Objects.isNull(llmResp)) {
-                return;
-            }
-            //5. deduplicate the SQL result list and build parserInfo
-            modelCluster.buildName(semanticSchema.getModelIdToName());
-            LLMResponseService responseService = ContextUtils.getBean(LLMResponseService.class);
-            Map<String, LLMSqlResp> deduplicationSqlResp = responseService.getDeduplicationSqlResp(llmResp);
-            ParseResult parseResult = ParseResult.builder()
-                    .modelCluster(modelCluster)
-                    .commonAgentTool(commonAgentTool)
-                    .llmReq(llmReq)
-                    .llmResp(llmResp)
-                    .linkingValues(linkingValues)
-                    .build();
-
-            if (MapUtils.isEmpty(deduplicationSqlResp)) {
-                responseService.addParseInfo(queryCtx, parseResult, llmResp.getSqlOutput(), 1D);
-            } else {
-                deduplicationSqlResp.forEach((sql, sqlResp) -> {
-                    responseService.addParseInfo(queryCtx, parseResult, sql, sqlResp.getSqlWeight());
-                });
-            }
-
-        } catch (Exception e) {
-            log.error("parse", e);
-        }
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/ModelMatchResult.java

@@ -1,9 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import lombok.Data;
-
-@Data
-public class ModelMatchResult {
-    private Integer count = 0;
-    private double maxSimilarity;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/ModelResolver.java

@@ -1,12 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import java.util.Set;
-
-public interface ModelResolver {
-
-    String resolve(QueryContext queryContext, ChatContext chatCtx, Set<Long> restrictiveModels);
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/OnePassSCSqlGeneration.java

@@ -1,89 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.JsonUtil;
-import dev.langchain4j.data.message.AiMessage;
-import dev.langchain4j.model.chat.ChatLanguageModel;
-import dev.langchain4j.model.input.Prompt;
-import dev.langchain4j.model.input.PromptTemplate;
-import dev.langchain4j.model.output.Response;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.tuple.Pair;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-@Service
-@Slf4j
-public class OnePassSCSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExampleLoader sqlExampleLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, String modelClusterKey) {
-        //1.retriever sqlExamples and generate exampleListPool
-        keyPipelineLog.info("modelClusterKey:{},llmReq:{}", modelClusterKey, llmReq);
-
-        List<Map<String, String>> sqlExamples = sqlExampleLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                optimizationConfig.getText2sqlCollectionName(), optimizationConfig.getText2sqlExampleNum());
-
-        List<List<Map<String, String>>> exampleListPool = sqlPromptGenerator.getExampleCombos(sqlExamples,
-                optimizationConfig.getText2sqlFewShotsNum(), optimizationConfig.getText2sqlSelfConsistencyNum());
-
-        //2.generator linking and sql prompt by sqlExamples,and parallel generate response.
-        List<String> linkingSqlPromptPool = sqlPromptGenerator.generatePromptPool(llmReq, exampleListPool, true);
-        List<String> llmResults = new CopyOnWriteArrayList<>();
-        linkingSqlPromptPool.parallelStream().forEach(linkingSqlPrompt -> {
-                    Prompt prompt = PromptTemplate.from(JsonUtil.toString(linkingSqlPrompt))
-                            .apply(new HashMap<>());
-                    keyPipelineLog.info("request prompt:{}", prompt.toSystemMessage());
-                    Response<AiMessage> response = chatLanguageModel.generate(prompt.toSystemMessage());
-                    String result = response.content().text();
-                    llmResults.add(result);
-                    keyPipelineLog.info("model response:{}", result);
-                }
-        );
-        //3.format response.
-        List<String> schemaLinkingResults = llmResults.stream()
-                .map(llmResult -> OutputFormat.getSchemaLinks(llmResult)).collect(Collectors.toList());
-        List<String> candidateSortedList = OutputFormat.formatList(schemaLinkingResults);
-        Pair<String, Map<String, Double>> linkingMap = OutputFormat.selfConsistencyVote(candidateSortedList);
-        List<String> sqlList = llmResults.stream()
-                .map(llmResult -> OutputFormat.getSql(llmResult)).collect(Collectors.toList());
-
-        Pair<String, Map<String, Double>> sqlMapPair = OutputFormat.selfConsistencyVote(sqlList);
-        keyPipelineLog.info("linkingMap:{} sqlMap:{}", linkingMap, sqlMapPair.getRight());
-
-        LLMResp result = new LLMResp();
-        result.setQuery(llmReq.getQueryText());
-        result.setSqlRespMap(OutputFormat.buildSqlRespMap(sqlExamples, sqlMapPair.getRight()));
-        return result;
-    }
-
-    @Override
-    public void afterPropertiesSet() {
-        SqlGenerationFactory.addSqlGenerationForFactory(SqlGenerationMode.ONE_PASS_AUTO_COT_SELF_CONSISTENCY, this);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/OnePassSqlGeneration.java

@@ -1,74 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlResp;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.JsonUtil;
-import dev.langchain4j.data.message.AiMessage;
-import dev.langchain4j.model.chat.ChatLanguageModel;
-import dev.langchain4j.model.input.Prompt;
-import dev.langchain4j.model.input.PromptTemplate;
-import dev.langchain4j.model.output.Response;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-@Service
-@Slf4j
-public class OnePassSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExampleLoader sqlExampleLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, String modelClusterKey) {
-        //1.retriever sqlExamples
-        keyPipelineLog.info("modelClusterKey:{},llmReq:{}", modelClusterKey, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExampleLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                optimizationConfig.getText2sqlCollectionName(), optimizationConfig.getText2sqlExampleNum());
-
-        //2.generator linking and sql prompt by sqlExamples,and generate response.
-        String promptStr = sqlPromptGenerator.generatorLinkingAndSqlPrompt(llmReq, sqlExamples);
-
-        Prompt prompt = PromptTemplate.from(JsonUtil.toString(promptStr)).apply(new HashMap<>());
-        keyPipelineLog.info("request prompt:{}", prompt.toSystemMessage());
-        Response<AiMessage> response = chatLanguageModel.generate(prompt.toSystemMessage());
-        String result = response.content().text();
-        keyPipelineLog.info("model response:{}", result);
-        //3.format response.
-        String schemaLinkStr = OutputFormat.getSchemaLinks(response.content().text());
-        String sql = OutputFormat.getSql(response.content().text());
-        Map<String, LLMSqlResp> sqlRespMap = new HashMap<>();
-        sqlRespMap.put(sql, LLMSqlResp.builder().sqlWeight(1D).fewShots(sqlExamples).build());
-        keyPipelineLog.info("schemaLinkStr:{},sqlRespMap:{}", schemaLinkStr, sqlRespMap);
-
-        LLMResp llmResp = new LLMResp();
-        llmResp.setQuery(llmReq.getQueryText());
-        llmResp.setSqlRespMap(sqlRespMap);
-        return llmResp;
-    }
-
-    @Override
-    public void afterPropertiesSet() {
-        SqlGenerationFactory.addSqlGenerationForFactory(SqlGenerationMode.ONE_PASS_AUTO_COT, this);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/ParseResult.java

@@ -1,33 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.tencent.supersonic.chat.core.agent.NL2SQLTool;
-import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.ElementValue;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.pojo.ModelCluster;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class ParseResult {
-
-    private ModelCluster modelCluster;
-
-    private LLMReq llmReq;
-
-    private LLMResp llmResp;
-
-    private QueryReq request;
-
-    private NL2SQLTool commonAgentTool;
-
-    private List<ElementValue> linkingValues;
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/S2SqlDateHelper.java

@@ -1,49 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.tencent.supersonic.chat.api.pojo.request.ChatConfigFilter;
-import com.tencent.supersonic.chat.api.pojo.response.ChatConfigRichResp;
-import com.tencent.supersonic.chat.api.pojo.response.ChatDefaultRichConfigResp;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.util.DatePeriodEnum;
-import com.tencent.supersonic.common.util.DateUtils;
-import java.util.Objects;
-
-public class S2SqlDateHelper {
-
-    public static String getReferenceDate(QueryContext queryContext, Long modelId) {
-        String defaultDate = DateUtils.getBeforeDate(0);
-        if (Objects.isNull(modelId)) {
-            return defaultDate;
-        }
-        ChatConfigFilter filter = new ChatConfigFilter();
-        filter.setModelId(modelId);
-        ChatConfigRichResp chatConfigRichResp = queryContext.getModelIdToChatRichConfig().get(modelId);
-
-        if (Objects.isNull(chatConfigRichResp)) {
-            return defaultDate;
-        }
-        if (Objects.isNull(chatConfigRichResp.getChatDetailRichConfig()) || Objects.isNull(
-                chatConfigRichResp.getChatDetailRichConfig().getChatDefaultConfig())) {
-            return defaultDate;
-        }
-
-        ChatDefaultRichConfigResp chatDefaultConfig = chatConfigRichResp.getChatDetailRichConfig()
-                .getChatDefaultConfig();
-        Integer unit = chatDefaultConfig.getUnit();
-        String period = chatDefaultConfig.getPeriod();
-        if (Objects.nonNull(unit)) {
-            // If the unit is set to less than 0, then do not add relative date.
-            if (unit < 0) {
-                return null;
-            }
-            DatePeriodEnum datePeriodEnum = DatePeriodEnum.get(period);
-            if (Objects.isNull(datePeriodEnum)) {
-                return DateUtils.getBeforeDate(unit);
-            } else {
-                return DateUtils.getBeforeDate(unit, datePeriodEnum);
-            }
-        }
-        return defaultDate;
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/SqlGeneration.java

@@ -1,20 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-
-/**
- * Sql Generation interface, generating SQL using a large model.
- */
-public interface SqlGeneration {
-
-    /***
-     * generate llmResp (sql, schemaLink, prompt, etc.) through LLMReq.
-     * @param llmReq
-     * @param modelClusterKey
-     * @return
-     */
-    LLMResp generation(LLMReq llmReq, String modelClusterKey);
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/SqlGenerationFactory.java

@@ -1,19 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class SqlGenerationFactory {
-
-    private static Map<SqlGenerationMode, SqlGeneration> sqlGenerationMap = new ConcurrentHashMap<>();
-
-    public static SqlGeneration get(SqlGenerationMode strategyType) {
-        return sqlGenerationMap.get(strategyType);
-    }
-
-    public static void addSqlGenerationForFactory(SqlGenerationMode strategy, SqlGeneration sqlGeneration) {
-        sqlGenerationMap.put(strategy, sqlGeneration);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/TwoPassSCSqlGeneration.java

@@ -1,91 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.JsonUtil;
-import dev.langchain4j.data.message.AiMessage;
-import dev.langchain4j.model.chat.ChatLanguageModel;
-import dev.langchain4j.model.input.Prompt;
-import dev.langchain4j.model.input.PromptTemplate;
-import dev.langchain4j.model.output.Response;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
-import org.apache.commons.lang3.tuple.Pair;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-@Service
-public class TwoPassSCSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExampleLoader sqlExampleLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, String modelClusterKey) {
-        //1.retriever sqlExamples and generate exampleListPool
-        keyPipelineLog.info("modelClusterKey:{},llmReq:{}", modelClusterKey, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExampleLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                optimizationConfig.getText2sqlCollectionName(), optimizationConfig.getText2sqlExampleNum());
-
-        List<List<Map<String, String>>> exampleListPool = sqlPromptGenerator.getExampleCombos(sqlExamples,
-                optimizationConfig.getText2sqlFewShotsNum(), optimizationConfig.getText2sqlSelfConsistencyNum());
-
-        //2.generator linking prompt,and parallel generate response.
-        List<String> linkingPromptPool = sqlPromptGenerator.generatePromptPool(llmReq, exampleListPool, false);
-        List<String> linkingResults = new CopyOnWriteArrayList<>();
-        linkingPromptPool.parallelStream().forEach(
-                linkingPrompt -> {
-                    Prompt prompt = PromptTemplate.from(JsonUtil.toString(linkingPrompt)).apply(new HashMap<>());
-                    keyPipelineLog.info("step one request prompt:{}", prompt.toSystemMessage());
-                    Response<AiMessage> linkingResult = chatLanguageModel.generate(prompt.toSystemMessage());
-                    String result = linkingResult.content().text();
-                    keyPipelineLog.info("step one model response:{}", result);
-                    linkingResults.add(OutputFormat.getSchemaLink(result));
-                }
-        );
-        List<String> sortedList = OutputFormat.formatList(linkingResults);
-        Pair<String, Map<String, Double>> linkingMap = OutputFormat.selfConsistencyVote(sortedList);
-        //3.generator sql prompt,and parallel generate response.
-        List<String> sqlPromptPool = sqlPromptGenerator.generateSqlPromptPool(llmReq, sortedList, exampleListPool);
-        List<String> sqlTaskPool = new CopyOnWriteArrayList<>();
-        sqlPromptPool.parallelStream().forEach(sqlPrompt -> {
-            Prompt linkingPrompt = PromptTemplate.from(JsonUtil.toString(sqlPrompt)).apply(new HashMap<>());
-            keyPipelineLog.info("step two request prompt:{}", linkingPrompt.toSystemMessage());
-            Response<AiMessage> sqlResult = chatLanguageModel.generate(linkingPrompt.toSystemMessage());
-            String result = sqlResult.content().text();
-            keyPipelineLog.info("step two model response:{}", result);
-            sqlTaskPool.add(result);
-        });
-        //4.format response.
-        Pair<String, Map<String, Double>> sqlMapPair = OutputFormat.selfConsistencyVote(sqlTaskPool);
-        keyPipelineLog.info("linkingMap:{} sqlMap:{}", linkingMap, sqlMapPair.getRight());
-
-        LLMResp llmResp = new LLMResp();
-        llmResp.setQuery(llmReq.getQueryText());
-        llmResp.setSqlRespMap(OutputFormat.buildSqlRespMap(sqlExamples, sqlMapPair.getRight()));
-        return llmResp;
-    }
-
-    @Override
-    public void afterPropertiesSet() {
-        SqlGenerationFactory.addSqlGenerationForFactory(SqlGenerationMode.TWO_PASS_AUTO_COT_SELF_CONSISTENCY, this);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/TwoPassSqlGeneration.java

@@ -1,75 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.SqlGenerationMode;
-import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
-import com.tencent.supersonic.common.util.JsonUtil;
-import dev.langchain4j.data.message.AiMessage;
-import dev.langchain4j.model.chat.ChatLanguageModel;
-import dev.langchain4j.model.input.Prompt;
-import dev.langchain4j.model.input.PromptTemplate;
-import dev.langchain4j.model.output.Response;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-@Service
-@Slf4j
-public class TwoPassSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExampleLoader sqlExampleLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, String modelClusterKey) {
-        keyPipelineLog.info("modelClusterKey:{},llmReq:{}", modelClusterKey, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExampleLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                optimizationConfig.getText2sqlCollectionName(), optimizationConfig.getText2sqlExampleNum());
-
-        String linkingPromptStr = sqlPromptGenerator.generateLinkingPrompt(llmReq, sqlExamples);
-
-        Prompt prompt = PromptTemplate.from(JsonUtil.toString(linkingPromptStr)).apply(new HashMap<>());
-        keyPipelineLog.info("step one request prompt:{}", prompt.toSystemMessage());
-        Response<AiMessage> response = chatLanguageModel.generate(prompt.toSystemMessage());
-        keyPipelineLog.info("step one model response:{}", response.content().text());
-        String schemaLinkStr = OutputFormat.getSchemaLink(response.content().text());
-        String generateSqlPrompt = sqlPromptGenerator.generateSqlPrompt(llmReq, schemaLinkStr, sqlExamples);
-
-        Prompt sqlPrompt = PromptTemplate.from(JsonUtil.toString(generateSqlPrompt)).apply(new HashMap<>());
-        keyPipelineLog.info("step two request prompt:{}", sqlPrompt.toSystemMessage());
-        Response<AiMessage> sqlResult = chatLanguageModel.generate(sqlPrompt.toSystemMessage());
-        String result = sqlResult.content().text();
-        keyPipelineLog.info("step two model response:{}", result);
-        Map<String, Double> sqlMap = new HashMap<>();
-        sqlMap.put(result, 1D);
-        keyPipelineLog.info("schemaLinkStr:{},sqlMap:{}", schemaLinkStr, sqlMap);
-
-        LLMResp llmResp = new LLMResp();
-        llmResp.setQuery(llmReq.getQueryText());
-        llmResp.setSqlRespMap(OutputFormat.buildSqlRespMap(sqlExamples, sqlMap));
-        return llmResp;
-    }
-
-    @Override
-    public void afterPropertiesSet() {
-        SqlGenerationFactory.addSqlGenerationForFactory(SqlGenerationMode.TWO_PASS_AUTO_COT, this);
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/rule/AgentCheckParser.java

@@ -1,84 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.rule;
-
-import com.alibaba.fastjson.JSONObject;
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.core.agent.Agent;
-import com.tencent.supersonic.chat.core.agent.AgentToolType;
-import com.tencent.supersonic.chat.core.agent.RuleParserTool;
-import com.tencent.supersonic.chat.core.parser.SemanticParser;
-import com.tencent.supersonic.chat.core.pojo.ChatContext;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.QueryManager;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.common.pojo.enums.QueryType;
-import java.util.HashSet;
-import java.util.List;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-
-@Slf4j
-public class AgentCheckParser implements SemanticParser {
-
-    @Override
-    public void parse(QueryContext queryContext, ChatContext chatContext) {
-        List<SemanticQuery> queries = queryContext.getCandidateQueries();
-        agentCanSupport(queryContext, queries);
-    }
-
-    private void agentCanSupport(QueryContext queryContext, List<SemanticQuery> queries) {
-        Agent agent = queryContext.getAgent();
-        if (agent == null) {
-            return;
-        }
-        List<RuleParserTool> queryTools = getRuleTools(agent);
-        if (CollectionUtils.isEmpty(queryTools)) {
-            queries.clear();
-            return;
-        }
-        log.info("queries resolved:{} {}", agent.getName(),
-                queries.stream().map(SemanticQuery::getQueryMode).collect(Collectors.toList()));
-        queries.removeIf(query -> {
-            for (RuleParserTool tool : queryTools) {
-                if (CollectionUtils.isNotEmpty(tool.getQueryModes())
-                        && !tool.getQueryModes().contains(query.getQueryMode())) {
-                    return true;
-                }
-                if (CollectionUtils.isNotEmpty(tool.getQueryTypes())) {
-                    if (QueryManager.isTagQuery(query.getQueryMode())) {
-                        return !tool.getQueryTypes().contains(QueryType.TAG.name());
-                    }
-                    if (QueryManager.isMetricQuery(query.getQueryMode())) {
-                        return !tool.getQueryTypes().contains(QueryType.METRIC.name());
-                    }
-                }
-                if (CollectionUtils.isEmpty(tool.getModelIds())) {
-                    return true;
-                }
-                if (tool.isContainsAllModel()) {
-                    return false;
-                }
-                if (new HashSet<>(tool.getModelIds())
-                        .containsAll(query.getParseInfo().getModel().getModelIds())) {
-                    return false;
-                }
-            }
-            return true;
-        });
-        log.info("rule queries witch can be supported by agent :{} {}", agent.getName(),
-                queries.stream().map(SemanticQuery::getQueryMode).collect(Collectors.toList()));
-    }
-
-    private static List<RuleParserTool> getRuleTools(Agent agent) {
-        if (agent == null) {
-            return Lists.newArrayList();
-        }
-        List<String> tools = agent.getTools(AgentToolType.NL2SQL_RULE);
-        if (CollectionUtils.isEmpty(tools)) {
-            return Lists.newArrayList();
-        }
-        return tools.stream().map(tool -> JSONObject.parseObject(tool, RuleParserTool.class))
-                .collect(Collectors.toList());
-    }
-
-}

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

@@ -1,56 +0,0 @@
-package com.tencent.supersonic.chat.core.pojo;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SchemaModelClusterMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.request.QueryFilters;
-import com.tencent.supersonic.chat.api.pojo.response.ChatConfigRichResp;
-import com.tencent.supersonic.chat.core.agent.Agent;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import com.tencent.supersonic.common.util.ContextUtils;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class QueryContext {
-
-    private String queryText;
-    private Integer chatId;
-    private Long modelId;
-    private User user;
-    private boolean saveAnswer = true;
-    private Integer agentId;
-    private QueryFilters queryFilters;
-    private List<SemanticQuery> candidateQueries = new ArrayList<>();
-    private SchemaMapInfo mapInfo = new SchemaMapInfo();
-    private SchemaModelClusterMapInfo modelClusterMapInfo = new SchemaModelClusterMapInfo();
-    private SemanticSchema semanticSchema;
-    private Agent agent;
-    private Map<Long, ChatConfigRichResp> modelIdToChatRichConfig;
-    private Map<String, Plugin> nameToPlugin;
-    private List<Plugin> pluginList;
-
-    public List<SemanticQuery> getCandidateQueries() {
-        OptimizationConfig optimizationConfig = ContextUtils.getBean(OptimizationConfig.class);
-        Integer parseShowCount = optimizationConfig.getParseShowCount();
-        candidateQueries = candidateQueries.stream()
-                .sorted(Comparator.comparing(semanticQuery -> semanticQuery.getParseInfo().getScore(),
-                        Comparator.reverseOrder()))
-                .limit(parseShowCount)
-                .collect(Collectors.toList());
-        return candidateQueries;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/BaseSemanticQuery.java

@@ -1,129 +0,0 @@
-
-package com.tencent.supersonic.chat.core.query;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.knowledge.semantic.SemanticInterpreter;
-import com.tencent.supersonic.chat.core.utils.ComponentFactory;
-import com.tencent.supersonic.chat.core.utils.QueryReqBuilder;
-import com.tencent.supersonic.common.pojo.Aggregator;
-import com.tencent.supersonic.common.pojo.Filter;
-import com.tencent.supersonic.common.pojo.Order;
-import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.headless.api.enums.QueryType;
-import com.tencent.supersonic.headless.api.request.ExplainSqlReq;
-import com.tencent.supersonic.headless.api.request.QuerySqlReq;
-import com.tencent.supersonic.headless.api.request.QueryStructReq;
-import com.tencent.supersonic.headless.api.response.ExplainResp;
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import lombok.ToString;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-
-@Slf4j
-@ToString
-public abstract class BaseSemanticQuery implements SemanticQuery, Serializable {
-
-    protected SemanticParseInfo parseInfo = new SemanticParseInfo();
-
-    protected SemanticInterpreter semanticInterpreter = ComponentFactory.getSemanticLayer();
-
-    @Override
-    public String explain(User user) {
-        ExplainSqlReq explainSqlReq = null;
-        try {
-            SqlInfo sqlInfo = parseInfo.getSqlInfo();
-
-            if (StringUtils.isNotBlank(sqlInfo.getCorrectS2SQL())) {
-                //sql
-                explainSqlReq = ExplainSqlReq.builder()
-                        .queryTypeEnum(QueryType.SQL)
-                        .queryReq(QueryReqBuilder.buildS2SQLReq(
-                                sqlInfo.getCorrectS2SQL(), parseInfo.getModel().getModelIds()
-                        ))
-                        .build();
-            } else {
-                //struct
-                explainSqlReq = ExplainSqlReq.builder()
-                        .queryTypeEnum(QueryType.STRUCT)
-                        .queryReq(QueryReqBuilder.buildStructReq(parseInfo))
-                        .build();
-            }
-            ExplainResp explain = semanticInterpreter.explain(explainSqlReq, user);
-            if (Objects.nonNull(explain)) {
-                return explain.getSql();
-            }
-        } catch (Exception e) {
-            log.error("explain error explainSqlReq:{}", explainSqlReq, e);
-        }
-        return null;
-    }
-
-    @Override
-    public SemanticParseInfo getParseInfo() {
-        return parseInfo;
-    }
-
-    @Override
-    public void setParseInfo(SemanticParseInfo parseInfo) {
-        this.parseInfo = parseInfo;
-    }
-
-    protected QueryStructReq convertQueryStruct() {
-        return QueryReqBuilder.buildStructReq(parseInfo);
-    }
-
-    protected void convertBizNameToName(SemanticSchema semanticSchema, QueryStructReq queryStructReq) {
-        Map<String, String> bizNameToName = semanticSchema.getBizNameToName(queryStructReq.getModelIdSet());
-        bizNameToName.putAll(TimeDimensionEnum.getNameToNameMap());
-
-        List<Order> orders = queryStructReq.getOrders();
-        if (CollectionUtils.isNotEmpty(orders)) {
-            for (Order order : orders) {
-                order.setColumn(bizNameToName.get(order.getColumn()));
-            }
-        }
-        List<Aggregator> aggregators = queryStructReq.getAggregators();
-        if (CollectionUtils.isNotEmpty(aggregators)) {
-            for (Aggregator aggregator : aggregators) {
-                aggregator.setColumn(bizNameToName.get(aggregator.getColumn()));
-            }
-        }
-        List<String> groups = queryStructReq.getGroups();
-        if (CollectionUtils.isNotEmpty(groups)) {
-            groups = groups.stream().map(group -> bizNameToName.get(group)).collect(Collectors.toList());
-            queryStructReq.setGroups(groups);
-        }
-        List<Filter> dimensionFilters = queryStructReq.getDimensionFilters();
-        if (CollectionUtils.isNotEmpty(dimensionFilters)) {
-            dimensionFilters.stream().forEach(filter -> filter.setName(bizNameToName.get(filter.getBizName())));
-        }
-        List<Filter> metricFilters = queryStructReq.getMetricFilters();
-        if (CollectionUtils.isNotEmpty(dimensionFilters)) {
-            metricFilters.stream().forEach(filter -> filter.setName(bizNameToName.get(filter.getBizName())));
-        }
-        queryStructReq.setModelName(parseInfo.getModelName());
-    }
-
-    protected void initS2SqlByStruct(SemanticSchema semanticSchema) {
-        OptimizationConfig optimizationConfig = ContextUtils.getBean(OptimizationConfig.class);
-        if (!optimizationConfig.isUseS2SqlSwitch()) {
-            return;
-        }
-        QueryStructReq queryStructReq = convertQueryStruct();
-        convertBizNameToName(semanticSchema, queryStructReq);
-        QuerySqlReq querySQLReq = queryStructReq.convert(queryStructReq);
-        parseInfo.getSqlInfo().setS2SQL(querySQLReq.getSql());
-        parseInfo.getSqlInfo().setCorrectS2SQL(querySQLReq.getSql());
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/llm/LLMSemanticQuery.java

@@ -1,8 +0,0 @@
-package com.tencent.supersonic.chat.core.query.llm;
-
-import com.tencent.supersonic.chat.core.query.BaseSemanticQuery;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-public abstract class LLMSemanticQuery extends BaseSemanticQuery {
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/llm/analytics/LLMAnswerReq.java

@@ -1,13 +0,0 @@
-package com.tencent.supersonic.chat.core.query.llm.analytics;
-
-
-import lombok.Data;
-
-@Data
-public class LLMAnswerReq {
-
-    private String queryText;
-
-    private String pluginOutput;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/llm/analytics/LLMAnswerResp.java

@@ -1,10 +0,0 @@
-package com.tencent.supersonic.chat.core.query.llm.analytics;
-
-
-import lombok.Data;
-
-@Data
-public class LLMAnswerResp {
-    private String assistantMessage;
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/llm/analytics/MetricAnalyzeQuery.java

@@ -1,152 +0,0 @@
-package com.tencent.supersonic.chat.core.query.llm.analytics;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-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.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.response.QueryResult;
-import com.tencent.supersonic.chat.api.pojo.response.QueryState;
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.knowledge.semantic.SemanticInterpreter;
-import com.tencent.supersonic.chat.core.query.QueryManager;
-import com.tencent.supersonic.chat.core.query.llm.LLMSemanticQuery;
-import com.tencent.supersonic.chat.core.utils.ComponentFactory;
-import com.tencent.supersonic.chat.core.utils.QueryReqBuilder;
-import com.tencent.supersonic.common.pojo.Aggregator;
-import com.tencent.supersonic.common.pojo.QueryColumn;
-import com.tencent.supersonic.common.pojo.enums.AggOperatorEnum;
-import com.tencent.supersonic.common.pojo.enums.QueryType;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.headless.api.request.QueryStructReq;
-import com.tencent.supersonic.headless.api.response.SemanticQueryResp;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.calcite.sql.parser.SqlParseException;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.stereotype.Component;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-@Component
-public class MetricAnalyzeQuery extends LLMSemanticQuery {
-
-
-    public static final String QUERY_MODE = "METRIC_INTERPRET";
-
-    public MetricAnalyzeQuery() {
-        QueryManager.register(this);
-    }
-
-    @Override
-    public String getQueryMode() {
-        return QUERY_MODE;
-    }
-
-    @Override
-    public QueryResult execute(User user) throws SqlParseException {
-        QueryStructReq queryStructReq = convertQueryStruct();
-        SemanticInterpreter semanticInterpreter = ComponentFactory.getSemanticLayer();
-
-        OptimizationConfig optimizationConfig = ContextUtils.getBean(OptimizationConfig.class);
-        if (optimizationConfig.isUseS2SqlSwitch()) {
-            queryStructReq.setS2SQL(parseInfo.getSqlInfo().getS2SQL());
-            queryStructReq.setS2SQL(parseInfo.getSqlInfo().getQuerySQL());
-        }
-
-        SemanticQueryResp semanticQueryResp = semanticInterpreter.queryByStruct(queryStructReq, user);
-        String text = generateTableText(semanticQueryResp);
-        Map<String, Object> properties = parseInfo.getProperties();
-        Map<String, String> replacedMap = new HashMap<>();
-        String textReplaced = replaceText((String) properties.get("queryText"),
-                parseInfo.getElementMatches(), replacedMap);
-        String answer = replaceAnswer(fetchInterpret(textReplaced, text), replacedMap);
-        QueryResult queryResult = new QueryResult();
-        List<QueryColumn> queryColumns = Lists.newArrayList(new QueryColumn("结果", "string", "answer"));
-        Map<String, Object> result = new HashMap<>();
-        result.put("answer", answer);
-        List<Map<String, Object>> resultList = Lists.newArrayList();
-        resultList.add(result);
-        queryResult.setQueryResults(resultList);
-        queryResult.setQueryColumns(queryColumns);
-        queryResult.setQueryMode(getQueryMode());
-        queryResult.setQueryState(QueryState.SUCCESS);
-        return queryResult;
-    }
-
-    @Override
-    public void initS2Sql(SemanticSchema semanticSchema, User user) {
-        initS2SqlByStruct(semanticSchema);
-    }
-
-    protected QueryStructReq convertQueryStruct() {
-        QueryStructReq queryStructReq = QueryReqBuilder.buildStructReq(parseInfo);
-        fillAggregator(queryStructReq, parseInfo.getMetrics());
-        queryStructReq.setQueryType(QueryType.TAG);
-        return queryStructReq;
-    }
-
-    private String replaceText(String text, List<SchemaElementMatch> schemaElementMatches,
-            Map<String, String> replacedMap) {
-        if (CollectionUtils.isEmpty(schemaElementMatches)) {
-            return text;
-        }
-        List<SchemaElementMatch> valueSchemaElementMatches = schemaElementMatches.stream()
-                .filter(schemaElementMatch ->
-                        SchemaElementType.VALUE.equals(schemaElementMatch.getElement().getType())
-                                || SchemaElementType.ID.equals(schemaElementMatch.getElement().getType()))
-                .collect(Collectors.toList());
-        for (SchemaElementMatch schemaElementMatch : valueSchemaElementMatches) {
-            String detectWord = schemaElementMatch.getDetectWord();
-            if (StringUtils.isBlank(detectWord)) {
-                continue;
-            }
-            text = text.replace(detectWord, "xxx");
-            replacedMap.put("xxx", detectWord);
-        }
-        return text;
-    }
-
-    private void fillAggregator(QueryStructReq queryStructReq, Set<SchemaElement> schemaElements) {
-        queryStructReq.getAggregators().clear();
-        for (SchemaElement schemaElement : schemaElements) {
-            Aggregator aggregator = new Aggregator();
-            aggregator.setColumn(schemaElement.getBizName());
-            aggregator.setFunc(AggOperatorEnum.SUM);
-            aggregator.setNameCh(schemaElement.getName());
-            queryStructReq.getAggregators().add(aggregator);
-        }
-    }
-
-    private String replaceAnswer(String text, Map<String, String> replacedMap) {
-        for (String key : replacedMap.keySet()) {
-            text = text.replaceAll(key, replacedMap.get(key));
-        }
-        return text;
-    }
-
-    public static String generateTableText(SemanticQueryResp result) {
-        StringBuilder tableBuilder = new StringBuilder();
-        for (QueryColumn column : result.getColumns()) {
-            tableBuilder.append(column.getName()).append("\t");
-        }
-        tableBuilder.append("\n");
-        for (Map<String, Object> row : result.getResultList()) {
-            for (QueryColumn column : result.getColumns()) {
-                tableBuilder.append(row.get(column.getNameEn())).append("\t");
-            }
-            tableBuilder.append("\n");
-        }
-        return tableBuilder.toString();
-    }
-
-    public String fetchInterpret(String queryText, String dataText) {
-        return "";
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/query/llm/s2sql/LLMSqlQuery.java

@@ -1,72 +0,0 @@
-package com.tencent.supersonic.chat.core.query.llm.s2sql;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.core.knowledge.semantic.SemanticInterpreter;
-import com.tencent.supersonic.chat.api.pojo.response.QueryResult;
-import com.tencent.supersonic.chat.api.pojo.response.QueryState;
-import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
-import com.tencent.supersonic.chat.core.utils.ComponentFactory;
-import com.tencent.supersonic.chat.core.utils.QueryReqBuilder;
-import com.tencent.supersonic.chat.core.query.QueryManager;
-import com.tencent.supersonic.chat.core.query.llm.LLMSemanticQuery;
-import com.tencent.supersonic.common.pojo.QueryColumn;
-import com.tencent.supersonic.headless.api.response.SemanticQueryResp;
-import com.tencent.supersonic.headless.api.request.QuerySqlReq;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-@Slf4j
-@Component
-public class LLMSqlQuery extends LLMSemanticQuery {
-
-    public static final String QUERY_MODE = "LLM_S2SQL";
-    protected SemanticInterpreter semanticInterpreter = ComponentFactory.getSemanticLayer();
-
-    public LLMSqlQuery() {
-        QueryManager.register(this);
-    }
-
-    @Override
-    public String getQueryMode() {
-        return QUERY_MODE;
-    }
-
-    @Override
-    public QueryResult execute(User user) {
-
-        long startTime = System.currentTimeMillis();
-        String querySql = parseInfo.getSqlInfo().getCorrectS2SQL();
-        QuerySqlReq querySQLReq = QueryReqBuilder.buildS2SQLReq(querySql, parseInfo.getModel().getModelIds());
-        SemanticQueryResp queryResp = semanticInterpreter.queryByS2SQL(querySQLReq, user);
-
-        log.info("queryByS2SQL cost:{},querySql:{}", System.currentTimeMillis() - startTime, querySql);
-
-        QueryResult queryResult = new QueryResult();
-        if (Objects.nonNull(queryResp)) {
-            queryResult.setQueryAuthorization(queryResp.getQueryAuthorization());
-        }
-        String resultQql = queryResp == null ? null : queryResp.getSql();
-        List<Map<String, Object>> resultList = queryResp == null ? new ArrayList<>() : queryResp.getResultList();
-        List<QueryColumn> columns = queryResp == null ? new ArrayList<>() : queryResp.getColumns();
-        queryResult.setQuerySql(resultQql);
-        queryResult.setQueryResults(resultList);
-        queryResult.setQueryColumns(columns);
-        queryResult.setQueryMode(QUERY_MODE);
-        queryResult.setQueryState(QueryState.SUCCESS);
-
-        parseInfo.setProperties(null);
-        return queryResult;
-    }
-
-    @Override
-    public void initS2Sql(SemanticSchema semanticSchema, User user) {
-        SqlInfo sqlInfo = parseInfo.getSqlInfo();
-        sqlInfo.setCorrectS2SQL(sqlInfo.getS2SQL());
-    }
-}