(improvement)(chat) add chat plugin webservice demo (#1317)

Co-authored-by: lxwcodemonkey

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,89 @@
+name: SuperSonic Bug report
+title: "[Bug] "
+description: Problems and issues with code of SuperSonic
+labels: bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you very much for submitting feedback to SuperSonic to help SuperSonic develop better.
+
+        If it is an idea or help wanted, please go to:
+        [Github Discussion](https://github.com/tencentmusic/supersonic/discussions)
+
+  - type: checkboxes
+    attributes:
+      label: Search before asking
+      description: >
+        Please make sure to search in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) first to see
+        whether the same issue was reported already.
+      options:
+        - label: >
+            I had searched in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) and found no similar
+            issues.
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Version
+      description: What is the current version
+      placeholder: >
+        Please provide the version you are using.
+        If it is the trunk version, please input commit id.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: What's Wrong?
+      description: Describe the bug.
+      placeholder: >
+        Describe the specific problem, the more detailed the better.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: What You Expected?
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: How to Reproduce?
+      placeholder: >
+        Please try to give reproducing steps to facilitate quick location of the problem.
+
+        - What actions were performed
+        - Table building statement
+        - Import statement
+        - Cluster information: number of nodes, configuration, etc.
+
+        If it is hard to reproduce, please also explain the general scene.
+
+  - type: textarea
+    attributes:
+      label: Anything Else?
+
+  - type: checkboxes
+    attributes:
+      label: Are you willing to submit PR?
+      description: >
+        We very much look forward to developers or users to help solve the SuperSonic problem together.
+        If you are willing to submit a PR to fix this problem, please tick it.
+      options:
+        - label: Yes I am willing to submit a PR!
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      description: The Code of Conduct helps create a safe space for everyone. We require that everyone agrees to it.
+      options:
+        - label: >
+            I agree to follow this project's
+            [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "Thanks for completing our form!"

.github/ISSUE_TEMPLATE/enhancement_request.yml

@@ -0,0 +1,57 @@
+name: SuperSonic enhancement request
+description: Add an enhancement for SuperSonic
+title: "[Enhancement] "
+labels: enhancement
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you very much for your good enhancement for SuperSonic.
+  - type: checkboxes
+    attributes:
+      label: Search before asking
+      description: >
+        Please make sure to search in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) first to see
+        whether the same issue was reported already.
+      options:
+        - label: >
+            I had searched in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) and found no similar
+            issues.
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Description
+      description: Describe the enhancement what you want, including motivation if it exists.
+
+  - type: textarea
+    attributes:
+      label: Solution
+      placeholder: >
+        Add overview of proposed solution. 
+
+        Add related materials like links if they exist.
+
+  - type: checkboxes
+    attributes:
+      label: Are you willing to submit PR?
+      description: >
+        We very much look forward to developers or users to help develop the SuperSonic together.
+        If you are willing to submit a PR to implement this feature, please tick it.
+      options:
+        - label: Yes I am willing to submit a PR!
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      description: The Code of Conduct helps create a safe space for everyone. We require that everyone agrees to it.
+      options:
+        - label: >
+            I agree to follow this project's
+            [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "Thanks for completing our form!"

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,60 @@
+name: SuperSonic feature request
+description: Suggest an idea for SuperSonic
+title: "[Feature] "
+labels: feature
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you very much for your good ideas and suggestions for SuperSonic
+
+  - type: checkboxes
+    attributes:
+      label: Search before asking
+      description: >
+        Please make sure to search in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) first to see
+        whether the same issue was reported already.
+      options:
+        - label: >
+            I had searched in the [issues](https://github.com/tencentmusic/supersonic/issues?q=is%3Aissue) and found no similar
+            issues.
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Description
+      description: Describe your ideas and needs.
+
+  - type: textarea
+    attributes:
+      label: Use case
+      placeholder: >
+        What problem does this feature mainly solve, or what scenarios it is suitable for.
+
+  - type: textarea
+    attributes:
+      label: Related issues
+      description: Is there currently another issue associated with this?
+
+  - type: checkboxes
+    attributes:
+      label: Are you willing to submit PR?
+      description: >
+        We very much look forward to developers or users to help develop the SuperSonic together.
+        If you are willing to submit a PR to implement this feature, please tick it.
+      options:
+        - label: Yes I am willing to submit a PR!
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      description: The Code of Conduct helps create a safe space for everyone. We require that everyone agrees to it.
+      options:
+        - label: >
+            I agree to follow this project's
+            [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "Thanks for completing our form!"

.github/ISSUE_TEMPLATE/question_request.yml

@@ -0,0 +1,58 @@
+name: SuperSonic question request
+description: Ask a question about SuperSonic
+title: "[question] "
+labels: question
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Ask a Question about SuperSonic
+        Please provide a detailed description of your question or the clarification you seek regarding the SuperSonic project.
+  - type: textarea
+    id: describe-question
+    attributes:
+      label: Describe your question
+      description: Please provide a clear and concise description of your question.
+      placeholder: "Type your question here..."
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Provide any additional context or information
+      description: If your question is related to a specific part of the SuperSonic project or if you have already looked through certain documentation, please provide that information here.
+      placeholder: "Add context here..."
+    validations:
+      required: false
+  - type: textarea
+    id: tried-to-resolve
+    attributes:
+      label: What have you tried to resolve your question
+      description: Let us know what you have done to try and understand or resolve your question. This can help us provide you with the most useful guidance.
+      placeholder: "I've already tried..."
+    validations:
+      required: false
+  - type: textarea
+    id: environment
+    attributes:
+      label: Your environment
+      description: Share details about your environment to help us reproduce the issue. Include your operating system, version of SuperSonic, and any other relevant details.
+      placeholder: "OS, SuperSonic version, etc..."
+    validations:
+      required: false
+  - type: textarea
+    id: screenshots-logs
+    attributes:
+      label: Screenshots or Logs
+      description: If applicable, add screenshots or logs to help explain your problem.
+      placeholder: "Paste your logs or attach screenshots here..."
+    validations:
+      required: false
+  - type: textarea
+    id: additional-information
+    attributes:
+      label: Additional information
+      description: Add any other context or details you think might be helpful for understanding your question.
+      placeholder: "Any other information..."
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,36 @@
+# Pull Request Template
+
+## Description
+
+Please include a summary of the change and which issue is fixed. Also include relevant motivation and context. List any dependencies that are required for this change.
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] This change requires a documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration.
+
+- [ ] Test A
+- [ ] Test B
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules
+
+## Additional information
+
+Any additional information, configuration or data that might be necessary to reproduce the issue.

.github/workflows/centos-ci.yml

@@ -0,0 +1,44 @@
+name: supersonic RHEL/CentOS CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: quay.io/centos/centos:stream8  # 使用 CentOS Stream 8 容器
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Reset DNF repositories
+        run: |
+          cd /etc/yum.repos.d/
+          sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
+          sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+      - name: Update DNF package index
+        run: dnf makecache
+      - name: Install Java and Maven with retry
+        run: |
+          for i in {1..5}; do
+            dnf install -y java-1.8.0-openjdk-devel maven && break || sleep 15
+          done
+      - name: Verify Java and Maven installation
+        run: |
+          java -version
+          mvn -version
+      - name: Cache Maven packages
+        uses: actions/cache@v2
+        with:
+          path: ~/.m2
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-m2
+      - name: Build with Maven
+        run: mvn -B package --file pom.xml
+      - name: Test with Maven
+        run: mvn test

.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,29 @@
 - "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

README.md

@@ -1,54 +1,66 @@
-[中文介绍](README_CN.md) | [文档中心](https://github.com/tencentmusic/supersonic/wiki)
+[中文版](README_CN.md) | [日本語版](README_JP.md) | [Docs](https://supersonicbi.github.io/)
 
 ![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) with semantic layer, 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: 
 
-<img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
+- 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="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_ideas.png" height="75%" width="75%" />
+
+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="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_demo.gif" height="100%" width="100%" />
 
 ## 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**. 
-   <img src="./docs/images/supersonic_ideas.png" height="65%" width="65%" align="center"/>
-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
 
 The high-level architecture and main process flow is as follows:
 
-<img src="./docs/images/supersonic_components.png" height="65%" width="65%" align="center"/> 
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_components.png" height="65%" width="65%" /> 
 
 - **Knowledge Base:** extracts schema information periodically from the semantic models and build dictionary and index to facilitate schema mapping.
 
 - **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.
+- **Chat Plugin:** extends functionality with third-party tools. Given a list of configured plugins with descriptions and sample questions, an LLM will be leveraged to select the most suitable one.
+
+- **Chat Memory:** encapsulates a collection of historical query trajectories that can be recalled to facilitate few-shot prompting.
 
 ## Quick Demo
+### Online playground
+Visit http://117.72.46.148:9080 to register and experience as a new user. Please do not modify system configurations. We will restart to reset configurations regularly every weekend.
 
+### Local build
 SuperSonic comes with sample semantic models as well as chat conversations that can be used as a starting point. Please follow the steps: 
 
 - Download the latest prebuilt binary from the [release page](https://github.com/tencentmusic/supersonic/releases)
@@ -57,10 +69,14 @@ SuperSonic comes with sample semantic models as well as chat conversations that
 
 ## Build and Development
 
-Please refer to project [wiki](https://github.com/tencentmusic/supersonic/wiki). 
+Please refer to project [Docs](https://supersonicbi.github.io/docs/%E7%B3%BB%E7%BB%9F%E9%83%A8%E7%BD%B2/%E7%BC%96%E8%AF%91%E6%9E%84%E5%BB%BA/). 
 
 ## WeChat Contact
 
 Please follow SuperSonic wechat official account:
 
-<img src="./docs/images/supersonic_wechat_oa.png" height="50%" width="50%" align="center"/> 
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat_oa.png" height="50%" width="50%" /> 
+
+Welcome to join the WeChat community:
+
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat.png" height="50%" width="50%" /> 

README_CN.md

@@ -1,51 +1,66 @@
-# SuperSonic (超音数)
+[English](README.md) | [日本語版](README_JP.md) | [文档中心](https://supersonicbi.github.io/)
 
-**SuperSonic融合ChatBI和HeadlessBI打造新一代的数据分析平台**。通过SuperSonic的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。SuperSonic不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（指标/维度/实体的定义，以及他们的业务含义、相互间关系等），即可开启数据问答体验。与此同时，SuperSonic被设计为可插拔的框架，采用Java SPI机制来扩展定制功能。
+# SuperSonic
 
-<img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
+**SuperSonic融合Chat BI（powered by LLM）和Headless BI（powered by 语义层）打造新一代的BI平台**。这种融合确保了Chat BI能够与传统BI一样访问统一化治理的语义数据模型。此外，两种BI新范式都从中获得收益：
+
+- Chat BI的Text2SQL生成通过检索语义数据模型得到增强。
+- Headless BI的查询接口通过支持自然语言API得到拓展。
+
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_ideas.png" height="75%" width="75%" />
+
+通过SuperSonic的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。SuperSonic不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（定义指标/维度/实体/标签，以及它们的业务含义、相互关系等），即可开启数据问答体验。与此同时，SuperSonic被设计为可插拔的框架，采用Java SPI机制来扩展定制功能。
+
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_demo.gif" height="100%" width="100%" />
 
 ## 项目动机
 
-大型语言模型（LLMs）如ChatGPT的出现正在重塑信息检索的方式。在数据分析领域，学术界和工业界主要关注利用深度学习模型将自然语言查询转换为SQL查询。虽然一些工作显示出有前景的结果，但它们的可靠性还达不到生产可用的要求。
+大型语言模型（LLM）如ChatGPT的出现正在重塑信息检索的方式，引领数据分析领域的一种新范式，被称为Chat BI。为了实现Chat BI，学术界和工业界主要关注利用LLM的能力将自然语言转换为SQL，通常称为Text2SQL或NL2SQL。尽管一些方法显示出有希望的结果，但它们在大规模实际应用中的可靠性还不足。
 
-在我们看来，为了在实际场景发挥价值，有三个关键点：
-1. 融合HeadlessBI，通过统一语义层封装底层数据细节（关联、键值、公式等），降低SQL生成的**复杂度**。
+与此同时，另一种新兴范式被称为Headless BI，它专注于构建统一的语义数据模型，并引起了广泛的关注。Headless BI通过一个通用的语义层来实现，通过开放的API公开一致的数据语义。
 
-   <img src="./docs/images/supersonic_ideas.png" height="65%" width="65%" align="center"/>
-2. 通过一前一后的模式映射器和语义修正器，来缓解LLM常见的**幻觉**现象。
-3. 设计启发式的规则，在一些特定场景提升语义解析的**效率**。
+从我们的角度来看，Chat BI和Headless BI的融合有潜力在两个方面增强Text2SQL的能力：
+
+1. 将数据语义（如业务术语、列值等）纳入提示词中，使LLM能够更好地理解语义，以**减少幻觉**。
+2. 将高级SQL语法（如连接、公式等）的生成从LLM卸载到语义层，以**减少复杂度**。
 
 为了验证上述想法，我们开发了SuperSonic项目，并将其应用在实际的内部产品中。与此同时，我们将SuperSonic作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
 
 ## 开箱即用的特性
 
-- 内置ChatBI界面以便*业务用户*输入数据查询。
-- 内置HeadlessBI界面以便*分析工程师*构建语义模型。
-- 内置图形用户界面以便*系统管理员*管理第三方插件和对话助理。
-- 支持文本输入的联想和查询问题的推荐。
-- 支持多轮对话，根据语境自动切换上下文。
-- 支持四级权限控制：主题域级、模型级、列级、行级。
+- 内置Chat BI界面以便*业务用户*输入数据查询。
+- 内置Headless BI界面以便*分析工程师*构建语义模型。
+- 内置基于规则的语义解析器，在特定场景（比如DEMO演示、集成测试）可以提升推理效率。
+- 支持文本输入联想、多轮对话、查询后问题推荐等高级特征。
+- 支持三级权限控制：数据集级、列级、行级。
 
 ## 易于扩展的组件
 
 SuperSonic的整体架构和主流程如下图所示：
 
-<img src="./docs/images/supersonic_components.png" height="65%" width="65%" align="center"/> 
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_components.png" height="65%" width="65%" /> 
 
 - **模型知识库(Knowledge Base)：** 定期从语义模型中提取相关的模式信息，构建词典和索引，以便后续的模式映射。
 
 - **模式映射器(Schema Mapper)：** 将自然语言文本在知识库中进行匹配，为后续的语义解析提供相关信息。
 
-- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，其由一组基于规则和基于模型的解析器组成，每个解析器可应对不同的特定场景。
+- **语义解析器(Semantic Parser)：** 理解用户查询并抽取语义信息，生成语义查询语句S2SQL。
 
-- **语义修正器(Semantic Corrector)：** 检查语义信息的合法性，对不合法的信息做修正和优化处理。
+- **语义修正器(Semantic Corrector)：** 检查语义查询语句的合法性，对不合法的信息做修正和优化处理。
 
-- **语义解释器(Semantic Interpreter)：** 根据语义信息生成物理SQL执行查询。
+- **语义翻译器(Semantic Translator)：** 将语义查询语句翻译成可在物理数据模型上执行的SQL语句。
 
 - **问答插件(Chat Plugin)：** 通过第三方工具扩展功能。给定所有配置的插件及其功能描述和示例问题，大语言模型将选择最合适的插件。
 
+- **问答记忆(Chat Memory)：** 将历史的查询轨迹进行封装，可被召回作为few-shot样例嵌入提示词。
+
 ## 快速体验
 
+### 线上环境体验
+访问http://117.72.46.148:9080 注册新用户体验. 请勿修改系统配置。我们每周末定期重启重置配置。
+
+### 本地构建
+
 SuperSonic自带样例的语义模型和问答对话，只需以下三步即可快速体验：
 
 - 从[release page](https://github.com/tencentmusic/supersonic/releases)下载预先构建好的发行包
@@ -54,10 +69,14 @@ SuperSonic自带样例的语义模型和问答对话，只需以下三步即可
 
 ## 如何构建和部署
 
-请参考项目[wiki](https://github.com/tencentmusic/supersonic/wiki)。
+请参考项目[文档](https://supersonicbi.github.io/docs/%E7%B3%BB%E7%BB%9F%E9%83%A8%E7%BD%B2/%E7%BC%96%E8%AF%91%E6%9E%84%E5%BB%BA/)。
 
 ## 微信联系方式
 
 欢迎关注微信公众号：
 
-<img src="./docs/images/supersonic_wechat_oa.png" height="50%" width="50%" align="center"/> 
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat_oa.png" height="50%" width="50%" /> 
+
+欢迎加入微信社群：
+
+<img src="https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat.png" height="50%" width="50%" /> 

README_JP.md

@@ -0,0 +1,78 @@
+[英文版](README.md) | [中国語版](README_CN.md)
+
+# SuperSonic
+
+**SuperSonicは、LLM（大規模言語モデル）によるChat BIと、セマンティックレイヤーによるHeadless BIを統合した次世代のBIプラットフォームです。** この統合により、Chat BIは従来のBIと同様に、統一されたガバナンスされたセマンティックデータモデルにアクセスできます。さらに、両方のBIパラダイムは統合から恩恵を受けます：
+
+- Chat BIのText2SQLは、セマンティックモデルからのコンテキスト検索によって強化されます。
+- Headless BIのクエリインターフェースは、自然言語APIによって拡張されます。
+
+![SuperSonicのアイデア](https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_ideas.png)
+
+SuperSonicは、ユーザーが自然言語でデータをクエリし、適切なチャートで結果を視覚化できる**Chat BIインターフェース**を提供します。このような体験を実現するために必要なのは、**Headless BIインターフェース**を通じて論理的なセマンティックモデル（メトリック/ディメンション/タグの定義、それらの意味と関係など）を構築することだけです。同時に、SuperSonicは拡張可能で構成可能な設計を採用しており、Java SPIを使用してカスタム実装を追加および設定できます。
+
+![SuperSonicのデモ](https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_demo.gif)
+
+## プロジェクトの動機
+
+ChatGPTのような大規模言語モデル（LLM）の出現は、情報検索の方法を再定義し、データ分析分野における新しいパラダイムであるChat BIをリードしています。Chat BIを実装するために、学術界と産業界は主に、自然言語をSQLに変換するLLMの能力を活用することに焦点を当てています。これは一般にText2SQLまたはNL2SQLと呼ばれます。一部のアプローチは有望な結果を示していますが、大規模な実世界のアプリケーションでの**信頼性**はまだ不十分です。
+
+一方で、統一されたセマンティックデータモデルを構築することに焦点を当てた別の新興パラダイムであるHeadless BIも、大きな注目を集めています。Headless BIは、オープンAPIを介して一貫したデータセマンティクスを公開するユニバーサルセマンティックレイヤーを通じて実装されます。
+
+私たちの観点から見ると、Chat BIとHeadless BIの統合は、Text2SQL生成を2つの側面で強化する可能性があります：
+
+1. データセマンティクス（ビジネス用語、列の値など）をプロンプトに組み込むことで、LLMがセマンティクスをよりよく理解し、**幻覚を減らす**ことができます。
+2. 高度なSQL構文（結合、式など）の生成をLLMからセマンティックレイヤーにオフロードすることで、**複雑さを減らす**ことができます。
+
+これらのアイデアを念頭に置いて、私たちはSuperSonicプロジェクトを開発し、実際の製品でそれを使用しています。同時に、SuperSonicを拡張可能なフレームワークとしてオープンソース化し、データクエリ対話分野のさらなる発展を促進したいと考えています。
+
+## 初期設定で利用可能な機能
+
+- *ビジネスユーザー*が自然言語クエリを入力できる組み込みのChat BIインターフェース。
+- *分析エンジニア*がセマンティックモデルを構築できる組み込みのHeadless BIインターフェース。
+- 特定のシナリオ（例：デモンストレーション、統合テスト）で推論効率を向上させるための組み込みのルールベースのセマンティックパーサー。
+- 入力自動補完、マルチターン会話、クエリ後の質問推奨などの高度な機能をサポート。
+- データセットレベル、列レベル、行レベルの3レベルのデータアクセス制御をサポート。
+
+## 拡張可能なコンポーネント
+
+高レベルのアーキテクチャとメインのプロセスフローは以下の通りです：
+
+![SuperSonicのコンポーネント](https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_components.png)
+
+- **モデル知識ベース(Knowledge Base)：** セマンティックモデルから定期的にスキーマ情報を抽出し、辞書とインデックスを構築して、スキーママッピングを容易にします。
+
+- **スキーママッパー(Schema Mapper)：** ユーザークエリ内のスキーマ要素（メトリック/ディメンション/エンティティ/値）を識別します。クエリテキストを知識ベースと照合します。
+
+- **セマンティックパーサー(Semantic Parser)：** ユーザークエリを理解し、セマンティッククエリステートメントS2SQLを生成します。
+
+- **セマンティック修正器(Semantic Corrector)：** セマンティッククエリステートメントの妥当性をチェックし、必要に応じて修正と最適化を行います。
+
+- **セマンティックトランスレーター(Semantic Translator)：** セマンティッククエリステートメントを、物理データモデル上で実行可能なSQLステートメントに変換します。
+
+- **チャットプラグイン(Chat Plugin)：** サードパーティツールで機能を拡張します。すべての設定されたプラグインとその機能説明、サンプル質問が与えられた場合、LLMは最も適切なプラグインを選択します。
+
+## クイックデモ
+### オンラインプレイグラウンド
+http://117.72.46.148:9080 にアクセスして、新規ユーザーとして登録して体験してください。システム設定を変更しないでください。毎週末に定期的に再起動して設定をリセットします。
+
+### ローカルビルド
+SuperSonicには、サンプルのセマンティックモデルとチャット会話が付属しており、以下の手順で簡単に体験できます：
+
+- [リリースページ](https://github.com/tencentmusic/supersonic/releases)から最新のプリビルドバイナリをダウンロード
+- スクリプト "assembly/bin/supersonic-daemon.sh start" を実行して、スタンドアロンJavaサービスを起動
+- ブラウザで http://localhost:9080 にアクセスして探索を開始
+
+## ビルドと開発
+
+プロジェクト[ドキュメント](https://supersonicbi.github.io/docs/%E7%B3%BB%E7%BB%9F%E9%83%A8%E7%BD%B2/%E7%BC%96%E8%AF%91%E6%9E%84%E5%BB%BA/)を参照してください。
+
+## WeChat連絡先
+
+SuperSonicの公式WeChatアカウントをフォローしてください：
+
+![SuperSonicのWeChat公式アカウント](https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat_oa.png)
+
+WeChatコミュニティに参加することを歓迎します：
+
+![SuperSonicのWeChatコミュニティ](https://github.com/supersonicbi/supersonic-website/blob/main/static/img/supersonic_wechat.png)

assembly/bin/supersonic-build.bat

@@ -1,72 +1,94 @@
 @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 %sbinDir%/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%"=="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% 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,78 @@
 #!/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
+  [ -d "$release_dir" ] && rm -rf "$release_dir"
+  [ -f "$release_dir.zip" ] && rm -f "$release_dir.zip"
+  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
-  ${pip_path} install -r ${requirementPath}
-  echo "install python modules success"
-fi
-
-#6. reset runtime
-rm -fr $runtimeDir/supersonic*
-moveAllToRuntime
-setEnvToWeb chat
-setEnvToWeb headless
+#1. build backend services
+if [ "$service" == "webapp" ]; then
+  buildWebapp
+  target_path=$projectDir/launchers/$STANDALONE_SERVICE/target/classes
+  tar xvf $projectDir/webapp/supersonic-webapp.tar.gz -C $target_path
+  rm -rf $target_path/webapp
+  mv $target_path/supersonic-webapp $target_path/webapp
+else
+  buildJavaService $service
+  buildWebapp
+  packageRelease $service
+fi

assembly/bin/supersonic-common.bat

@@ -0,0 +1,6 @@
+set "sbinDir=%~dp0"
+set "baseDir=%~dp0.."
+set "buildDir=%baseDir%\build"
+set "main_class=com.tencent.supersonic.StandaloneLauncher"
+set "standalone_service=standalone"
+set "projectDir=%baseDir%\.."

assembly/bin/supersonic-common.sh

@@ -1,110 +1,16 @@
 #!/usr/bin/env bash
 
 # environment parameters
-python_path=${PYTHON_PATH:-"python3"}
-pip_path=${PIP_PATH:-"pip3"}
-
 sbinDir=$(cd "$(dirname "$0")"; pwd)
 baseDir=$(cd "$sbinDir/.." && pwd -P)
-runtimeDir=$baseDir/../runtime
+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
-}
+readonly STANDALONE_SERVICE="standalone"

assembly/bin/supersonic-daemon.bat

@@ -1,118 +1,71 @@
 @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"
+set "sbinDir=%~dp0"
+call %sbinDir%/supersonic-common.bat %*
 
 set "command=%~1"
 set "service=%~2"
+set "profile=%~3"
 
 if "%service%"=="" (
    set "service=%standalone_service%"
 )
 
-IF "%service%"=="pyllm" (
-  SET "llmProxy=PythonLLMProxy"
+if "%profile%"=="" (
+   set "profile=local"
 )
 
-call :BUILD_RUNTIME
+set "model_name=%service%"
+
+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
-         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'
+:start
+   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%\*"
-   set "java-command=-Dfile.encoding=UTF-8 -Duser.language=Zh -Duser.region=CN -Duser.timezone=GMT+08 -Xms1024m -Xmx2048m -cp %CLASSPATH% %MAIN_CLASS%"
+:stop
+   call :stopJavaService
+   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 -Dspring.profiles.active=%profile% -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
-   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,143 +1,111 @@
 #!/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
-
 command=$1
 service=$2
+profile=$3
+
 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
+if [ -z "$profile" ]; then
+  profile="local"
 fi
 
+model_name=$service
 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
-  ${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
+  java -Dspring.profiles.active="$profile" $command >/dev/null 2>$javaRunDir/logs/error.log &
 }
 
-
-function start()
-{
+function start() {
   local_app_name=$1
-  pid=$(ps aux |grep ${local_app_name} | grep -v grep | awk '{print $2}')
+  echo "Starting ${local_app_name}"
+  pid=$(ps aux | grep ${local_app_name} | grep -v grep | awk '{print $2}')
   if [[ "$pid" == "" ]]; then
-    if [[ ${local_app_name} == $PYLLM_APP_NAME ]]; then
-      runPythonService ${local_app_name}
-    else
-      runJavaService ${local_app_name}
-    fi
+    runJavaService ${local_app_name}
   else
     echo "Process (PID = $pid) is running."
     return 1
   fi
+  echo "Start success"
 }
 
-function stop()
-{
+function stop() {
+  echo "Stopping $1"
   pid=$(ps aux | grep $1 | grep -v grep | awk '{print $2}')
   if [[ "$pid" == "" ]]; then
-    echo "Process $1 is not running !"
+    echo "Process $1 is not running!"
     return 1
   else
     kill -9 $pid
-    echo "Process (PID = $pid) is killed !"
+    echo "Process (PID = $pid) is killed!"
     return 0
   fi
+  echo "Stop success"
 }
 
-function reload()
-{
-  if [[ $1 == $PYLLM_APP_NAME ]]; then
-    reloadExamples
-  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
-        fi
-        echo  "Start success"
-        ;;
+    start ${app_name}
+    ;;
   stop)
-        echo  "Stopping $app_name"
-        stop $app_name
-        echo  "Stopping $PYLLM_APP_NAME"
-        stop $PYLLM_APP_NAME
-        echo  "Stop success"
-        ;;
-  reload)
-        echo  "Reloading ${app_name}"
-        reload ${app_name}
-        echo  "Reload success"
-        ;;
+    stop $app_name
+    ;;
   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}
-        fi
-        echo  "Restart success"
-        ;;
+    stop ${app_name}
+    start ${app_name}
+    ;;
   *)
-        echo "Use command {start|stop|restart} to run."
-        exit 1
-esac
+    echo "Use command {start|stop|restart} to run."
+    exit 1
+esac

assembly/build/build.xml

@@ -21,8 +21,12 @@
             </includes>
         </fileSet>
         <fileSet>
-            <directory>${project.basedir}/../../chat/python</directory>
-            <outputDirectory>pyllm</outputDirectory>
+            <directory>${project.basedir}/../../assembly/bin</directory>
+            <excludes>
+                <exclude>supersonic-build.sh</exclude>
+                <exclude>supersonic-build.bat</exclude>
+            </excludes>
+            <outputDirectory>bin</outputDirectory>
             <fileMode>0777</fileMode>
             <directoryMode>0755</directoryMode>
         </fileSet>

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

@@ -6,6 +6,7 @@ import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 
 import java.util.List;
 import java.util.Set;
+import javax.servlet.http.HttpServletRequest;
 
 /**
  * UserAdaptor defines some interfaces for obtaining user and organization information
@@ -20,7 +21,9 @@ public interface UserAdaptor {
 
     void register(UserReq userReq);
 
-    String login(UserReq userReq);
+    String login(UserReq userReq, HttpServletRequest request);
+
+    String login(UserReq userReq, String appKey);
 
     List<User> getUserByOrg(String key);
 

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/annotation/AuthenticationIgnore.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.interceptor;
+package com.tencent.supersonic.auth.api.authentication.annotation;
 
 
 import java.lang.annotation.ElementType;

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

@@ -5,32 +5,51 @@ import lombok.Data;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
 
+import java.util.Arrays;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 @Data
 @Configuration
 public class AuthenticationConfig {
 
-    @Value("${authentication.exclude.path:XXX}")
+    @Value("${s2.authentication.exclude.path:XXX}")
     private String excludePath;
 
-    @Value("${authentication.include.path:/api}")
+    @Value("${s2.authentication.include.path:/api}")
     private String includePath;
 
-    @Value("${authentication.enable:false}")
+    @Value("${s2.authentication.enable:false}")
     private boolean enabled;
 
-    @Value("${authentication.token.secret:secret}")
-    private String tokenSecret;
+    @Value("${s2.authentication.token.default.appKey:supersonic}")
+    private String tokenDefaultAppKey;
 
-    @Value("${authentication.token.http.header.key:Authorization}")
+    @Value("${s2.authentication.token.appSecret:supersonic:WIaO9YRRVt+7QtpPvyWsARFngnEcbaKBk"
+            + "783uGFwMrbJBaochsqCH62L4Kijcb0sZCYoSsiKGV/zPml5MnZ3uQ==}")
+    private String tokenAppSecret;
+
+    @Value("${s2.authentication.token.http.header.key:Authorization}")
     private String tokenHttpHeaderKey;
 
-    @Value("${authentication.app.appId:appId}")
+    @Value("${s2.authentication.token.http.app.key:App-Key}")
+    private String tokenHttpHeaderAppKey;
+
+    @Value("${s2.authentication.app.appId:appId}")
     private String appId;
 
-    @Value("${authentication.app.timestamp:timestamp}")
+    @Value("${s2.authentication.app.timestamp:timestamp}")
     private String timestamp;
 
-    @Value("${authentication.app.signature:signature}")
+    @Value("${s2.authentication.app.signature:signature}")
     private String signature;
 
+    @Value("${s2.authentication.token.timeout:72000000}")
+    private Long tokenTimeout;
+
+    public Map<String, String> getAppKeyToSecretMap() {
+        return Arrays.stream(this.tokenAppSecret.split(","))
+                .map(s -> s.split(":"))
+                .collect(Collectors.toMap(e -> e[0].trim(), e -> e[1].trim()));
+    }
 }

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

@@ -13,16 +13,9 @@ public class UserConstants {
     public static final String TOKEN_USER_EMAIL = "token_user_email";
 
     public static final String TOKEN_IS_ADMIN = "token_is_admin";
-
-    public static final String TOKEN_ALGORITHM = "HS512";
-
     public static final String TOKEN_CREATE_TIME = "token_create_time";
 
     public static final String TOKEN_PREFIX = "Bearer";
-
-    public static final Long TOKEN_TIME_OUT = 25920000000L;
-
     public static final String INTERNAL = "internal";
 
-
 }

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

@@ -19,7 +19,9 @@ public interface UserService {
 
     void register(UserReq userCmd);
 
-    String login(UserReq userCmd);
+    String login(UserReq userCmd, HttpServletRequest request);
+
+    String login(UserReq userCmd, String appKey);
 
     Set<String> getUserAllOrgId(String userName);
 

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

@@ -11,4 +11,6 @@ public interface UserStrategy {
 
     User findUser(HttpServletRequest request, HttpServletResponse response);
 
+    User findUser(String token, String appKey);
+
 }

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

@@ -2,13 +2,12 @@ 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.config.SystemConfig;
+import com.tencent.supersonic.common.service.SystemConfigService;
 import com.tencent.supersonic.common.util.ContextUtils;
-import org.springframework.util.CollectionUtils;
-
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import org.springframework.util.CollectionUtils;
 
 public final class UserHolder {
 
@@ -20,10 +19,19 @@ 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())) {
+        return getUser(user);
+    }
+
+    public static User findUser(String token, String appKey) {
+        User user = REPO.findUser(token, appKey);
+        return getUser(user);
+    }
+
+    private static User getUser(User user) {
+        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/pom.xml

@@ -38,10 +38,6 @@
             <artifactId>druid</artifactId>
             <version>${alibaba.druid.version}</version>
         </dependency>
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
@@ -50,7 +46,6 @@
         <dependency>
             <groupId>com.github.pagehelper</groupId>
             <artifactId>pagehelper</artifactId>
-            <version>${pagehelper.version}</version>
             <scope>compile</scope>
         </dependency>
 

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

@@ -9,9 +9,13 @@ import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO;
 import com.tencent.supersonic.auth.authentication.persistence.repository.UserRepository;
+import com.tencent.supersonic.common.util.AESEncryptionUtil;
 import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
 import com.tencent.supersonic.common.util.ContextUtils;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
+
+import javax.servlet.http.HttpServletRequest;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -19,6 +23,7 @@ import java.util.stream.Collectors;
 /**
  * DefaultUserAdaptor provides a default method to obtain user and organization information
  */
+@Slf4j
 public class DefaultUserAdaptor implements UserAdaptor {
 
     private List<UserDO> getUserDOList() {
@@ -72,22 +77,53 @@ public class DefaultUserAdaptor implements UserAdaptor {
         }
         UserDO userDO = new UserDO();
         BeanUtils.copyProperties(userReq, userDO);
+        try {
+            byte[] salt = AESEncryptionUtil.generateSalt(userDO.getName());
+            userDO.setSalt(AESEncryptionUtil.getStringFromBytes(salt));
+            userDO.setPassword(AESEncryptionUtil.encrypt(userReq.getPassword(), salt));
+        } catch (Exception e) {
+            throw new RuntimeException("password encrypt error, please try again");
+        }
         userRepository.addUser(userDO);
     }
 
     @Override
-    public String login(UserReq userReq) {
+    public String login(UserReq userReq, HttpServletRequest request) {
         UserTokenUtils userTokenUtils = ContextUtils.getBean(UserTokenUtils.class);
+        String appKey = userTokenUtils.getAppKey(request);
+        return login(userReq, appKey);
+    }
+
+    @Override
+    public String login(UserReq userReq, String appKey) {
+        UserTokenUtils userTokenUtils = ContextUtils.getBean(UserTokenUtils.class);
+        try {
+            UserWithPassword user = getUserWithPassword(userReq);
+            return userTokenUtils.generateToken(user, appKey);
+        } catch (Exception e) {
+            log.error("", e);
+            throw new RuntimeException("password encrypt error, please try again");
+        }
+    }
+
+    private UserWithPassword getUserWithPassword(UserReq userReq) {
         UserDO userDO = getUser(userReq.getName());
         if (userDO == null) {
             throw new RuntimeException("user not exist,please register");
         }
-        if (userDO.getPassword().equals(userReq.getPassword())) {
-            UserWithPassword user = UserWithPassword.get(userDO.getId(), userDO.getName(), userDO.getDisplayName(),
-                    userDO.getEmail(), userDO.getPassword(), userDO.getIsAdmin());
-            return userTokenUtils.generateToken(user);
+        try {
+            String password = AESEncryptionUtil.encrypt(userReq.getPassword(),
+                    AESEncryptionUtil.getBytesFromString(userDO.getSalt()));
+            if (userDO.getPassword().equals(password)) {
+                UserWithPassword user = UserWithPassword.get(userDO.getId(), userDO.getName(), userDO.getDisplayName(),
+                        userDO.getEmail(), userDO.getPassword(), userDO.getIsAdmin());
+                return user;
+            } else {
+                throw new RuntimeException("password not correct, please try again");
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("password encrypt error, please try again");
         }
-        throw new RuntimeException("password not correct, please try again");
     }
 
     @Override

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

@@ -5,19 +5,20 @@ import com.tencent.supersonic.auth.api.authentication.constant.UserConstants;
 import com.tencent.supersonic.auth.authentication.service.UserServiceImpl;
 import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
 import com.tencent.supersonic.common.util.S2ThreadContext;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.catalina.connector.RequestFacade;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.util.Strings;
 import org.apache.tomcat.util.http.MimeHeaders;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.multipart.support.StandardMultipartHttpServletRequest;
 import org.springframework.web.servlet.HandlerInterceptor;
+
 import javax.servlet.http.HttpServletRequest;
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.List;
 
-
+@Slf4j
 public abstract class AuthenticationInterceptor implements HandlerInterceptor {
 
 
@@ -32,7 +33,7 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
 
     protected boolean isExcludedUri(String uri) {
         String excludePathStr = authenticationConfig.getExcludePath();
-        if (Strings.isEmpty(excludePathStr)) {
+        if (StringUtils.isEmpty(excludePathStr)) {
             return false;
         }
         List<String> excludePaths = Arrays.asList(excludePathStr.split(","));
@@ -44,7 +45,7 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
 
     protected boolean isIncludedUri(String uri) {
         String includePathStr = authenticationConfig.getIncludePath();
-        if (Strings.isEmpty(includePathStr)) {
+        if (StringUtils.isEmpty(includePathStr)) {
             return false;
         }
         List<String> includePaths = Arrays.asList(includePathStr.split(","));
@@ -64,7 +65,7 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
         return StringUtils.isNotBlank(appId);
     }
 
-    protected void reflectSetparam(HttpServletRequest request, String key, String value) {
+    protected void reflectSetParam(HttpServletRequest request, String key, String value) {
         try {
             if (request instanceof StandardMultipartHttpServletRequest) {
                 RequestFacade servletRequest =
@@ -98,7 +99,7 @@ public abstract class AuthenticationInterceptor implements HandlerInterceptor {
                 o2.addValue(key).setString(value);
             }
         } catch (Exception e) {
-            e.printStackTrace();
+            log.error("reflectSetParam error:", e);
         }
     }
 }

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

@@ -1,6 +1,7 @@
 package com.tencent.supersonic.auth.authentication.interceptor;
 
 
+import com.tencent.supersonic.auth.api.authentication.annotation.AuthenticationIgnore;
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
@@ -66,8 +67,8 @@ public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor
     }
 
     private void setFakerUser(HttpServletRequest request) {
-        String token = userTokenUtils.generateAdminToken();
-        reflectSetparam(request, authenticationConfig.getTokenHttpHeaderKey(), token);
+        String token = userTokenUtils.generateAdminToken(request);
+        reflectSetParam(request, authenticationConfig.getTokenHttpHeaderKey(), token);
         setContext(User.getFakeUser().getName(), request);
     }
 

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

@@ -16,6 +16,8 @@ public class UserDO {
      */
     private String password;
 
+    private String salt;
+
     /**
      * 
      */
@@ -79,6 +81,14 @@ public class UserDO {
         this.password = password == null ? null : password.trim();
     }
 
+    public String getSalt() {
+        return salt;
+    }
+
+    public void setSalt(String salt) {
+        this.salt = salt == null ? null : salt.trim();
+    }
+
     /**
      * 
      * @return display_name 

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

@@ -65,8 +65,8 @@ public class UserController {
     }
 
     @PostMapping("/login")
-    public String login(@RequestBody UserReq userCmd) {
-        return userService.login(userCmd);
+    public String login(@RequestBody UserReq userCmd, HttpServletRequest request) {
+        return userService.login(userCmd, request);
     }
 
 }

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.config.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);
             }
         }
@@ -68,8 +68,13 @@ public class UserServiceImpl implements UserService {
     }
 
     @Override
-    public String login(UserReq userReq) {
-        return ComponentFactory.getUserAdaptor().login(userReq);
+    public String login(UserReq userReq, HttpServletRequest request) {
+        return ComponentFactory.getUserAdaptor().login(userReq, request);
+    }
+
+    @Override
+    public String login(UserReq userReq, String appKey) {
+        return ComponentFactory.getUserAdaptor().login(userReq, appKey);
     }
 
 }

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

@@ -20,4 +20,9 @@ public class FakeUserStrategy implements UserStrategy {
         return User.getFakeUser();
     }
 
+    @Override
+    public User findUser(String token, String appKey) {
+        return User.getFakeUser();
+    }
+
 }

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

@@ -28,4 +28,9 @@ public class HttpHeaderUserStrategy implements UserStrategy {
     public User findUser(HttpServletRequest request, HttpServletResponse response) {
         return userTokenUtils.getUser(request);
     }
+
+    @Override
+    public User findUser(String token, String appKey) {
+        return userTokenUtils.getUser(token, appKey);
+    }
 }

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

@@ -1,15 +1,5 @@
 package com.tencent.supersonic.auth.authentication.utils;
 
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_ALGORITHM;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_CREATE_TIME;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_IS_ADMIN;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_PREFIX;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_TIME_OUT;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_DISPLAY_NAME;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_EMAIL;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_ID;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_NAME;
-import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_PASSWORD;
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
@@ -17,14 +7,25 @@ import com.tencent.supersonic.common.pojo.exception.AccessException;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.spec.SecretKeySpec;
+import javax.servlet.http.HttpServletRequest;
 import java.nio.charset.StandardCharsets;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
-import javax.servlet.http.HttpServletRequest;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.stereotype.Component;
+
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_CREATE_TIME;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_IS_ADMIN;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_PREFIX;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_DISPLAY_NAME;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_EMAIL;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_ID;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_NAME;
+import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_USER_PASSWORD;
 
 @Slf4j
 @Component
@@ -36,7 +37,12 @@ public class UserTokenUtils {
         this.authenticationConfig = authenticationConfig;
     }
 
-    public String generateToken(UserWithPassword user) {
+    public String generateToken(UserWithPassword user, HttpServletRequest request) {
+        String appKey = getAppKey(request);
+        return generateToken(user, appKey);
+    }
+
+    public String generateToken(UserWithPassword user, String appKey) {
         Map<String, Object> claims = new HashMap<>(5);
         claims.put(TOKEN_USER_ID, user.getId());
         claims.put(TOKEN_USER_NAME, StringUtils.isEmpty(user.getName()) ? "" : user.getName());
@@ -44,23 +50,31 @@ public class UserTokenUtils {
         claims.put(TOKEN_USER_DISPLAY_NAME, user.getDisplayName());
         claims.put(TOKEN_CREATE_TIME, System.currentTimeMillis());
         claims.put(TOKEN_IS_ADMIN, user.getIsAdmin());
-        return generate(claims);
+        return generate(claims, appKey);
     }
 
-    public String generateAdminToken() {
-        Map<String, Object> claims = new HashMap<>(5);
-        claims.put(TOKEN_USER_ID, "1");
-        claims.put(TOKEN_USER_NAME, "admin");
-        claims.put(TOKEN_USER_PASSWORD, "admin");
-        claims.put(TOKEN_USER_DISPLAY_NAME, "admin");
-        claims.put(TOKEN_CREATE_TIME, System.currentTimeMillis());
-        claims.put(TOKEN_IS_ADMIN, 1);
-        return generate(claims);
+    public String generateAdminToken(HttpServletRequest request) {
+        UserWithPassword admin = new UserWithPassword("admin");
+        admin.setId(1L);
+        admin.setName("admin");
+        admin.setPassword("c3VwZXJzb25pY0BiaWNvbdktJJYWw6A3rEmBUPzbn/6DNeYnD+y3mAwDKEMS3KVT");
+        admin.setDisplayName("admin");
+        admin.setIsAdmin(1);
+        return generateToken(admin, request);
     }
 
     public User getUser(HttpServletRequest request) {
         String token = request.getHeader(authenticationConfig.getTokenHttpHeaderKey());
-        final Claims claims = getClaims(token);
+        final Claims claims = getClaims(token, request);
+        return getUser(claims);
+    }
+
+    public User getUser(String token, String appKey) {
+        final Claims claims = getClaims(token, appKey);
+        return getUser(claims);
+    }
+
+    private User getUser(Claims claims) {
         Long userId = Long.parseLong(claims.getOrDefault(TOKEN_USER_ID, 0).toString());
         String userName = String.valueOf(claims.get(TOKEN_USER_NAME));
         String email = String.valueOf(claims.get(TOKEN_USER_EMAIL));
@@ -77,7 +91,7 @@ public class UserTokenUtils {
             log.warn("{}, uri: {}", message, request.getServletPath());
             throw new AccessException(message);
         }
-        final Claims claims = getClaims(token);
+        final Claims claims = getClaims(token, request);
         Long userId = Long.parseLong(claims.getOrDefault(TOKEN_USER_ID, 0).toString());
         String userName = String.valueOf(claims.get(TOKEN_USER_NAME));
         String email = String.valueOf(claims.get(TOKEN_USER_EMAIL));
@@ -88,35 +102,69 @@ public class UserTokenUtils {
         return UserWithPassword.get(userId, userName, displayName, email, password, isAdmin);
     }
 
-    private Claims getClaims(String token) {
+    private Claims getClaims(String token, HttpServletRequest request) {
         Claims claims;
         try {
-            claims = Jwts.parser()
-                    .setSigningKey(authenticationConfig.getTokenSecret().getBytes(StandardCharsets.UTF_8))
-                    .parseClaimsJws(token.startsWith(TOKEN_PREFIX)
-                            ? token.substring(token.indexOf(TOKEN_PREFIX) + TOKEN_PREFIX.length()).trim() :
-                            token.trim()).getBody();
+            String appKey = getAppKey(request);
+            claims = getClaims(token, appKey);
         } catch (Exception e) {
             throw new AccessException("parse user info from token failed :" + token);
         }
         return claims;
     }
 
-    private String generate(Map<String, Object> claims) {
-        return toTokenString(claims);
+    private Claims getClaims(String token, String appKey) {
+        Claims claims;
+        try {
+            String tokenSecret = getTokenSecret(appKey);
+            claims = Jwts.parser()
+                    .setSigningKey(tokenSecret.getBytes(StandardCharsets.UTF_8))
+                    .build().parseClaimsJws(getTokenString(token)).getBody();
+        } catch (Exception e) {
+            log.error("getClaims", e);
+            throw new AccessException("parse user info from token failed :" + token);
+        }
+        return claims;
     }
 
-    private String toTokenString(Map<String, Object> claims) {
-        long expiration = Long.parseLong(claims.get(TOKEN_CREATE_TIME) + "") + TOKEN_TIME_OUT;
+    private static String getTokenString(String token) {
+        return token.startsWith(TOKEN_PREFIX) ? token.substring(token.indexOf(TOKEN_PREFIX)
+                + TOKEN_PREFIX.length()).trim() : token.trim();
+    }
+
+    private String generate(Map<String, Object> claims, String appKey) {
+        return toTokenString(claims, appKey);
+    }
+
+    private String toTokenString(Map<String, Object> claims, String appKey) {
+        Long tokenTimeout = authenticationConfig.getTokenTimeout();
+        long expiration = Long.parseLong(claims.get(TOKEN_CREATE_TIME) + "") + tokenTimeout;
+        Date expirationDate = new Date(expiration);
+        String tokenSecret = getTokenSecret(appKey);
 
-        SignatureAlgorithm.valueOf(TOKEN_ALGORITHM);
         return Jwts.builder()
                 .setClaims(claims)
                 .setSubject(claims.get(TOKEN_USER_NAME).toString())
-                .setExpiration(new Date(expiration))
-                .signWith(SignatureAlgorithm.valueOf(TOKEN_ALGORITHM),
-                        authenticationConfig.getTokenSecret().getBytes(StandardCharsets.UTF_8))
+                .setExpiration(expirationDate)
+                .signWith(new SecretKeySpec(tokenSecret.getBytes(StandardCharsets.UTF_8),
+                        SignatureAlgorithm.HS512.getJcaName()), SignatureAlgorithm.HS512)
                 .compact();
     }
 
+    private String getTokenSecret(String appKey) {
+        Map<String, String> appKeyToSecretMap = authenticationConfig.getAppKeyToSecretMap();
+        String secret = appKeyToSecretMap.get(appKey);
+        if (StringUtils.isBlank(secret)) {
+            throw new AccessException("get secret from appKey failed :" + appKey);
+        }
+        return secret;
+    }
+
+    public String getAppKey(HttpServletRequest request) {
+        String appKey = request.getHeader(authenticationConfig.getTokenHttpHeaderAppKey());
+        if (StringUtils.isBlank(appKey)) {
+            appKey = authenticationConfig.getTokenDefaultAppKey();
+        }
+        return appKey;
+    }
 }

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

@@ -5,6 +5,7 @@
     <result column="id" jdbcType="BIGINT" property="id" />
     <result column="name" jdbcType="VARCHAR" property="name" />
     <result column="password" jdbcType="VARCHAR" property="password" />
+    <result column="salt" jdbcType="VARCHAR" property="salt" />
     <result column="display_name" jdbcType="VARCHAR" property="displayName" />
     <result column="email" jdbcType="VARCHAR" property="email" />
     <result column="is_admin" jdbcType="INTEGER" property="isAdmin" />
@@ -39,7 +40,7 @@
     </where>
   </sql>
   <sql id="Base_Column_List">
-    id, name, password, display_name, email, is_admin
+    id, name, password, salt, display_name, email, is_admin
   </sql>
   <select id="selectByExample" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample" resultMap="BaseResultMap">
     select
@@ -59,10 +60,10 @@
     </if>
   </select>
   <insert id="insert" parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
-    insert into s2_user (id, name, password, 
+    insert into s2_user (id, name, password, salt,
       display_name, email, is_admin
       )
-    values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
+    values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, #{salt,jdbcType=VARCHAR},
       #{displayName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR}, #{isAdmin,jdbcType=INTEGER}
       )
   </insert>
@@ -78,6 +79,9 @@
       <if test="password != null">
         password,
       </if>
+      <if test="password != null">
+        salt,
+      </if>
       <if test="displayName != null">
         display_name,
       </if>
@@ -98,6 +102,9 @@
       <if test="password != null">
         #{password,jdbcType=VARCHAR},
       </if>
+      <if test="salt != null">
+        #{salt,jdbcType=VARCHAR},
+      </if>
       <if test="displayName != null">
         #{displayName,jdbcType=VARCHAR},
       </if>

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

@@ -1,27 +1,28 @@
 package com.tencent.supersonic.auth.authorization.service;
 
-import com.google.common.base.Strings;
 import com.google.common.collect.Lists;
 import com.google.gson.Gson;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.service.UserService;
+import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthResGrp;
+import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
 import com.tencent.supersonic.auth.api.authorization.pojo.DimensionFilter;
 import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
 import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
 import com.tencent.supersonic.auth.api.authorization.service.AuthService;
-import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
-import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.Map;
-import java.util.ArrayList;
 import java.util.stream.Collectors;
 
 @Service
@@ -117,7 +118,8 @@ public class AuthServiceImpl implements AuthService {
             if (!CollectionUtils.isEmpty(authGroups)) {
                 for (AuthGroup group : authGroups) {
                     if (group.getDimensionFilters() != null
-                            && group.getDimensionFilters().stream().anyMatch(expr -> !Strings.isNullOrEmpty(expr))) {
+                            && group.getDimensionFilters().stream().anyMatch(expr ->
+                            !StringUtils.isEmpty(expr))) {
                         DimensionFilter df = new DimensionFilter();
                         df.setDescription(group.getDimensionFilterDescription());
                         df.setExpressions(group.getDimensionFilters());

benchmark/benchmark.md

@@ -0,0 +1,84 @@
+## 使用场景
+产品上线阶段批量测试问答对话的问题，统计测试结果。
+注意：与evaluation模块的区别，evaluation是构建数据集多个模型的横向评估，benchmark是选定模型下，批量自动化业务问题的测试。
+## 功能说明
+批量自动化测试问答对话测试，支持单轮问答测试。
+
+## 使用说明
+- 注意1：建议在开发测试环境的执行，如果需要在生产环境的测试，请避开用户使用高峰期。
+- 注意2: python版本要求3.8可以运行。3.8.5版本测试通过。以上python版本未测试。
+1. 准备测试问题
+
+将问题写入`test_data.csv`文件，格式如下：
+```csv
+question
+各BG期间在职、入职、离职人员的平均薪资是多少？（注意：薪资不包括香港视源、广视以及并购控股子公司青松、仙视的数据。）
+各BG期间入职且仍在职的人数有多少？
+各BG当月的净增长人数及其增长率是多少？
+```
+将文件放入`benchmark/data`目录下。
+
+2. 执行测试
+```bash
+python benchmark -u http://localhost:3100 -a 6 -c 141 -f data/renli.csv -p zds
+```
+参数说明：
+- -a: 问答对话的id
+- -c: chat_id
+- -f: 测试问题文件
+- -u: 用户id
+如果执行报错，没有安装相关python包，可以执行`pip install -r requirements.txt`安装相关包。
+
+3. 查看测试结果
+当前，只能在数据库中查看测试结果。
+```sql
+select question_id,chat_id,create_time,query_text,
+       JSON_EXTRACT(parse_info,'$.sqlInfo.s2SQL') as s2sql,
+       JSON_EXTRACT(parse_info,'$.sqlInfo.correctS2SQL') as correctS2SQL,
+       JSON_EXTRACT(parse_info,'$.sqlInfo.querySQL') as querySQL,
+       '请标记正确的SQL' as correctSQL,
+       '请标记生成SQL是否正确' as isOk,
+       '请分类不正确的原因' as reason
+from s2_chat_parse scp where user_name = 'zhaodongsheng' and chat_id = '141';
+
+select question_id,chat_id,create_time,query_text,
+       JSON_EXTRACT(query_result,'$.querySql') as querySql,
+       JSON_EXTRACT(query_result,'$.queryResults') as queryResults
+from s2_chat_query where user_name = 'zhaodongsheng' and chat_id = '141' and query_state = 1;
+
+```
+4. 查看帮助
+```bash
+python benchmark.py --help
+usage: benchmark.py [-h] -u URL -a AGENTID -c CHATID -f FILEPATH -p USERNAME
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -u URL, --url URL     url:问答系统url,例如：https://chatdata-dev.test.com
+  -a AGENTID, --agentId AGENTID
+                        agentId：助手ID
+  -c CHATID, --chatId CHATID
+                        chatId:会话ID,需要通过浏览器开发者模式获取
+  -f FILEPATH, --filePath FILEPATH
+                        filePath：问题文件路径, csv格式. 请提前上传到benchmark/data目录下
+  -p USERNAME, --userName USERNAME
+                        userName：用户名，用户获取登录token
+```
+
+## 演示效果
+```bash
+python benchmark.py -u https://chatdata-dev.test.com -a 3 -c 35 -f data/shuce.csv -p zds
+批量测试配置信息[url: https://chatdata-dev.test.com agentId: 3 chatId: 35 filePath: data/shuce.csv userName: zds ]
+请确认输入的压力测试信息是否正确:
+1. Yes
+2. No
+1
+start to ask question: 各BG期间在职、入职、离职人员的平均薪资是多少？（注意：薪资不包括香港视源、广视以及并购控股子公司青松、仙视的数据。）
+start to ask question: 各BG期间入职且仍在职的人数有多少？
+start to ask question: 各BG当月的净增长人数及其增长率是多少？
+```
+
+## TODO
+- [x] 问答对话测试
+- [ ] 多轮对话测试
+- [ ] 问答对话测试结果展示

benchmark/benchmark.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+# -----------------------------------------------------------------------------------
+'''
+@filename     : batchmark.py
+@time         : 2024/06/20
+@author       : zhaodongsheng
+@Version      : 1.0
+@description  : 批量问答测试
+'''
+# -----------------------------------------------------------------------------------
+import pandas as pd
+import json
+import requests
+import time
+import jwt
+import traceback
+
+class BatchTest:
+    def __init__(self, url, agentId, chatId, userName):
+        self.base_url = url + '/api/chat/query/'
+        self.agentId = agentId
+        self.auth_token = self.__get_authorization(userName)
+        self.chatId = chatId
+
+    def parse(self, query_text):
+        url = self.base_url + 'parse'
+        data = {
+            'queryText': query_text,
+            'agentId': self.agentId,
+            'chatId': self.chatId,
+        }
+        headers = {
+            'Authorization': 'Bearer ' + self.auth_token,
+            'Content-Type': 'application/json',
+        }
+
+        response = requests.post(url, headers=headers, data=json.dumps(data))
+        return response.json()
+
+    def execute(self, query_text, queryId):
+        url = self.base_url + 'execute'
+        data = {
+            'queryText': query_text,
+            'parseId': 1,
+            'chatId': self.chatId,
+            'queryId': queryId,
+        }
+        headers = {
+            'Authorization': 'Bearer ' + self.auth_token,
+            'Content-Type': 'application/json',
+        }
+
+        response = requests.post(url, headers=headers, data=json.dumps(data))
+        return response.json()
+
+    def read_question_from_csv(self, filePath):
+        df = pd.read_csv(filePath)
+        return df
+
+    def __get_authorization(self, userName):
+        # secret 请和 com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig.tokenAppSecret 保持一致
+        secret = "WIaO9YRRVt+7QtpPvyWsARFngnEcbaKBk783uGFwMrbJBaochsqCH62L4Kijcb0sZCYoSsiKGV/zPml5MnZ3uQ=="
+        exp = time.time() + 100000000
+        token= jwt.encode({"token_user_name": userName,"exp": exp}, secret, algorithm="HS512")
+        return token
+
+
+def benchmark(url:str, agentId:str, chatId:str, filePath:str, userName:str):
+    batch_test = BatchTest(url, agentId, chatId, userName)
+    df = batch_test.read_question_from_csv(filePath)
+    for index, row in df.iterrows():
+        question = row['question']
+        print('start to ask question:', question)
+        # 捕获异常，防止程序中断
+        try:
+            parse_resp = batch_test.parse(question)
+            batch_test.execute(question, parse_resp['data']['queryId'])
+        except Exception as e:
+            print('error:', e)
+            traceback.print_exc()
+            continue
+        time.sleep(1)
+
+if __name__ == '__main__':
+
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-u', '--url', type=str, required=True, help='url:问答系统url,例如：https://chatdata-dev.test.com')
+    parser.add_argument('-a', '--agentId', type=str, required=True, help='agentId：助手ID')
+    parser.add_argument('-c', '--chatId', type=str, required=True, help='chatId:会话ID,需要通过浏览器开发者模式获取')
+    parser.add_argument('-f', '--filePath', type=str, required=True, help='filePath：问题文件路径, csv格式. 请提前上传到benchmark/data目录下')
+    parser.add_argument('-p', '--userName', type=str, required=True, help='userName：用户名，用户获取登录token')
+    args = parser.parse_args()
+
+    print('批量测试配置信息[url:', args.url,'agentId:', args.agentId, 'chatId:', args.chatId, 'filePath:', args.filePath, 'userName:', args.userName, ']')
+    print('请确认输入的压力测试信息是否正确:')
+    print('1. Yes')
+    print('2. No')
+    confirm = input()
+    if confirm == '1' or confirm == 'Yes' or confirm == 'yes' or confirm == 'YES':
+        benchmark(args.url, args.agentId, args.chatId, args.filePath, args.userName)
+    else:
+        print('请重新输入压力测试配置信息: url, agentId, chatId, filePath, userName')

benchmark/data/caiwu.csv

@@ -0,0 +1,3 @@
+question
+每个业务组（BG）的员工人数是多少？
+每个业务组的损益情况如何？

benchmark/data/renli.csv

@@ -0,0 +1,8 @@
+question
+在职人员的男女比例是多少？
+期间入职且离职的人数及其占比如何？
+期间新入职社招人员的平均年龄是多少？
+期间入职且在职的人数有多少？
+期间在职人员的平均年龄是多少？
+当月的净增长人数及其增长率是多少？
+期间新入职社招人员的年龄分布情况如何？

benchmark/data/shuce.csv

@@ -0,0 +1,4 @@
+question
+在广东省内，哪一个学校的累计集备数最多，请返回该学校的学校名称
+在广东省内，哪一个学校的累计集体备课数最多，请返回该学校的学校名称
+

benchmark/requirements.txt

@@ -0,0 +1,5 @@
+pandas==2.0.3
+PyJWT==2.8.0
+requests==2.28.2
+
+

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

@@ -1,33 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import com.google.common.collect.Lists;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-public class SchemaMapInfo {
-
-    private Map<Long, List<SchemaElementMatch>> viewElementMatches = new HashMap<>();
-
-    public Set<Long> getMatchedViewInfos() {
-        return viewElementMatches.keySet();
-    }
-
-    public List<SchemaElementMatch> getMatchedElements(Long view) {
-        return viewElementMatches.getOrDefault(view, Lists.newArrayList());
-    }
-
-    public Map<Long, List<SchemaElementMatch>> getViewElementMatches() {
-        return viewElementMatches;
-    }
-
-    public void setViewElementMatches(Map<Long, List<SchemaElementMatch>> viewElementMatches) {
-        this.viewElementMatches = viewElementMatches;
-    }
-
-    public void setMatchedElements(Long view, List<SchemaElementMatch> elementMatches) {
-        viewElementMatches.put(view, elementMatches);
-    }
-}

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

@@ -1,157 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import com.tencent.supersonic.headless.api.pojo.SchemaElement;
-import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import org.springframework.util.CollectionUtils;
-
-public class SemanticSchema implements Serializable {
-
-    private List<ViewSchema> viewSchemaList;
-
-    public SemanticSchema(List<ViewSchema> viewSchemaList) {
-        this.viewSchemaList = viewSchemaList;
-    }
-
-    public void add(ViewSchema schema) {
-        viewSchemaList.add(schema);
-    }
-
-    public SchemaElement getElement(SchemaElementType elementType, long elementID) {
-        Optional<SchemaElement> element = Optional.empty();
-
-        switch (elementType) {
-            case ENTITY:
-                element = getElementsById(elementID, getEntities());
-                break;
-            case VIEW:
-                element = getElementsById(elementID, getViews());
-                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 Map<Long, String> getViewIdToName() {
-        return viewSchemaList.stream()
-                .collect(Collectors.toMap(a -> a.getView().getId(), a -> a.getView().getName(), (k1, k2) -> k1));
-    }
-
-    public List<SchemaElement> getDimensionValues() {
-        List<SchemaElement> dimensionValues = new ArrayList<>();
-        viewSchemaList.stream().forEach(d -> dimensionValues.addAll(d.getDimensionValues()));
-        return dimensionValues;
-    }
-
-    public List<SchemaElement> getDimensions() {
-        List<SchemaElement> dimensions = new ArrayList<>();
-        viewSchemaList.stream().forEach(d -> dimensions.addAll(d.getDimensions()));
-        return dimensions;
-    }
-
-    public List<SchemaElement> getDimensions(Long viewId) {
-        List<SchemaElement> dimensions = getDimensions();
-        return getElementsByViewId(viewId, dimensions);
-    }
-
-    public SchemaElement getDimension(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<>();
-        viewSchemaList.stream().forEach(d -> tags.addAll(d.getTags()));
-        return tags;
-    }
-
-    public List<SchemaElement> getTags(Long viewId) {
-        List<SchemaElement> tags = new ArrayList<>();
-        viewSchemaList.stream().filter(schemaElement ->
-                        viewId.equals(schemaElement.getView().getView()))
-                .forEach(d -> tags.addAll(d.getTags()));
-        return tags;
-    }
-
-    public List<SchemaElement> getMetrics() {
-        List<SchemaElement> metrics = new ArrayList<>();
-        viewSchemaList.stream().forEach(d -> metrics.addAll(d.getMetrics()));
-        return metrics;
-    }
-
-    public List<SchemaElement> getMetrics(Long viewId) {
-        List<SchemaElement> metrics = getMetrics();
-        return getElementsByViewId(viewId, metrics);
-    }
-
-    public List<SchemaElement> getEntities() {
-        List<SchemaElement> entities = new ArrayList<>();
-        viewSchemaList.stream().forEach(d -> entities.add(d.getEntity()));
-        return entities;
-    }
-
-    public List<SchemaElement> getEntities(Long viewId) {
-        List<SchemaElement> entities = getEntities();
-        return getElementsByViewId(viewId, entities);
-    }
-
-    private List<SchemaElement> getElementsByViewId(Long viewId, List<SchemaElement> elements) {
-        return elements.stream()
-                .filter(schemaElement -> viewId.equals(schemaElement.getView()))
-                .collect(Collectors.toList());
-    }
-
-    private Optional<SchemaElement> getElementsById(Long id, List<SchemaElement> elements) {
-        return elements.stream()
-                .filter(schemaElement -> id.equals(schemaElement.getId()))
-                .findFirst();
-    }
-
-    public SchemaElement getView(Long viewId) {
-        List<SchemaElement> views = getViews();
-        return getElementsById(viewId, views).orElse(null);
-    }
-
-    public List<SchemaElement> getViews() {
-        List<SchemaElement> views = new ArrayList<>();
-        viewSchemaList.stream().forEach(d -> views.add(d.getView()));
-        return views;
-    }
-
-    public Map<String, String> getBizNameToName(Long viewId) {
-        List<SchemaElement> allElements = new ArrayList<>();
-        allElements.addAll(getDimensions(viewId));
-        allElements.addAll(getMetrics(viewId));
-        return allElements.stream()
-                .collect(Collectors.toMap(SchemaElement::getBizName, SchemaElement::getName, (k1, k2) -> k1));
-    }
-
-    public Map<Long, ViewSchema> getViewSchemaMap() {
-        if (CollectionUtils.isEmpty(viewSchemaList)) {
-            return new HashMap<>();
-        }
-        return viewSchemaList.stream().collect(Collectors.toMap(viewSchema
-                -> viewSchema.getView().getView(), viewSchema -> viewSchema));
-    }
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/enums/MemoryReviewResult.java

@@ -0,0 +1,9 @@
+package com.tencent.supersonic.chat.api.pojo.enums;
+
+
+public enum MemoryReviewResult {
+
+    POSITIVE,
+    NEGATIVE
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/enums/MemoryStatus.java

@@ -0,0 +1,10 @@
+package com.tencent.supersonic.chat.api.pojo.enums;
+
+
+public enum MemoryStatus {
+
+    PENDING,
+    ENABLED,
+    DISABLED;
+
+}

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

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

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

@@ -0,0 +1,30 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.chat.api.pojo.enums.MemoryReviewResult;
+import com.tencent.supersonic.chat.api.pojo.enums.MemoryStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class ChatMemoryFilter {
+
+    private Integer agentId;
+
+    private String question;
+
+    private List<String> questions;
+
+    private MemoryStatus status;
+
+    private MemoryReviewResult llmReviewRet;
+
+    private MemoryReviewResult humanReviewRet;
+
+}

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

@@ -0,0 +1,27 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+
+import com.tencent.supersonic.chat.api.pojo.enums.MemoryReviewResult;
+import com.tencent.supersonic.chat.api.pojo.enums.MemoryStatus;
+import com.tencent.supersonic.common.pojo.RecordInfo;
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+
+@Data
+public class ChatMemoryUpdateReq extends RecordInfo {
+
+    @NotNull(message = "id不可为空")
+    private Long id;
+
+    private String dbSchema;
+
+    private String s2sql;
+
+    private MemoryStatus status;
+
+    private MemoryReviewResult humanReviewRet;
+
+    private String humanReviewCmt;
+
+}

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 viewId;
+    private Integer agentId;
+    private Integer topN = 10;
     private User user;
     private QueryFilters queryFilters;
     private boolean saveAnswer = true;
-    private Integer agentId;
+    private SchemaMapInfo mapInfo = new SchemaMapInfo();
+
 }

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

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

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

@@ -0,0 +1,12 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.common.pojo.PageBaseReq;
+import lombok.Data;
+
+
+@Data
+public class PageMemoryReq extends PageBaseReq {
+
+    private ChatMemoryFilter chatMemoryFilter = new ChatMemoryFilter();
+
+}

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 view;
+    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 Long viewId;
+    private Long dataSetId;
 
     private Integer agentId;
 

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,13 @@
 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.ParseTimeCostResp;
+import com.tencent.supersonic.headless.api.pojo.response.QueryResult;
 import lombok.Data;
 import java.util.Date;
 import java.util.List;
 
+
 @Data
 public class QueryResp {
 
@@ -17,6 +20,6 @@ public class QueryResp {
     private QueryResult queryResult;
     private List<SemanticParseInfo> parseInfos;
     private List<SimilarQueryRecallResp> similarQueries;
-
+    private ParseTimeCostResp parseTimeCost = new ParseTimeCostResp();
 
 }

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,110 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>chat</artifactId>
-        <groupId>com.tencent.supersonic</groupId>
-        <version>${revision}</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>chat-core</artifactId>
-
-    <properties>
-        <maven.compiler.source>8</maven.compiler.source>
-        <maven.compiler.target>8</maven.compiler.target>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-context</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.testng</groupId>
-            <artifactId>testng</artifactId>
-            <version>${org.testng.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-compress</artifactId>
-            <version>${commons.compress.version}</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.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/config/DefaultSemanticConfig.java

@@ -1,44 +0,0 @@
-package com.tencent.supersonic.chat.core.config;
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-public class DefaultSemanticConfig {
-
-    @Value("${semantic.url.prefix:http://localhost:8081}")
-    private String semanticUrl;
-
-    @Value("${searchByStruct.path:/api/semantic/query/struct}")
-    private String searchByStructPath;
-
-    @Value("${searchByStruct.path:/api/semantic/query/multiStruct}")
-    private String searchByMultiStructPath;
-
-    @Value("${searchByStruct.path:/api/semantic/query/sql}")
-    private String searchBySqlPath;
-
-    @Value("${searchByStruct.path:/api/semantic/query/queryDimValue}")
-    private String queryDimValuePath;
-
-    @Value("${fetchModelSchemaPath.path:/api/semantic/schema}")
-    private String fetchModelSchemaPath;
-
-    @Value("${fetchModelList.path:/api/semantic/schema/dimension/page}")
-    private String fetchDimensionPagePath;
-
-    @Value("${fetchModelList.path:/api/semantic/schema/metric/page}")
-    private String fetchMetricPagePath;
-
-    @Value("${fetchModelList.path:/api/semantic/schema/domain/list}")
-    private String fetchDomainListPath;
-
-    @Value("${fetchModelList.path:/api/semantic/schema/model/list}")
-    private String fetchModelListPath;
-
-    @Value("${explain.path:/api/semantic/query/explain}")
-    private String explainPath;
-
-}

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

@@ -1,27 +0,0 @@
-package com.tencent.supersonic.chat.core.config;
-
-
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@Data
-public class LLMParserConfig {
-
-
-    @Value("${llm.parser.url:}")
-    private String url;
-
-    @Value("${query2sql.path:/query2sql}")
-    private String queryToSqlPath;
-
-    @Value("${dimension.topn:10}")
-    private Integer dimensionTopN;
-
-    @Value("${metric.topn:10}")
-    private Integer metricTopN;
-
-    @Value("${all.model:false}")
-    private Boolean allModel;
-}

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

@@ -1,175 +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.01}")
-    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("${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/SelectCorrector.java

@@ -1,29 +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.SqlSelectHelper;
-import java.util.List;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-/**
- * Perform SQL corrections on the "Select" section in S2SQL.
- */
-@Slf4j
-public class SelectCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        List<String> aggregateFields = SqlSelectHelper.getAggregateFields(correctS2SQL);
-        List<String> selectFields = SqlSelectHelper.getSelectFields(correctS2SQL);
-        // If the number of aggregated fields is equal to the number of queried fields, do not add fields to select.
-        if (!CollectionUtils.isEmpty(aggregateFields)
-                && !CollectionUtils.isEmpty(selectFields)
-                && aggregateFields.size() == selectFields.size()) {
-            return;
-        }
-        addFieldsToSelect(semanticParseInfo, correctS2SQL);
-    }
-}

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

@@ -1,57 +0,0 @@
-package com.tencent.supersonic.chat.core.corrector;
-
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.util.jsqlparser.DateVisitor.DateBoundInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlDateSelectHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import java.util.Objects;
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.parser.CCJSqlParserUtil;
-import org.apache.commons.lang3.StringUtils;
-
-/**
- * Perform SQL corrections on the time in S2SQL.
- */
-@Slf4j
-public class TimeCorrector extends BaseSemanticCorrector {
-
-    @Override
-    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-
-        parserDateDiffFunction(semanticParseInfo);
-
-        addLowerBoundDate(semanticParseInfo);
-
-    }
-
-    private void addLowerBoundDate(SemanticParseInfo semanticParseInfo) {
-        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        DateBoundInfo dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(correctS2SQL);
-        if (Objects.isNull(dateBoundInfo)) {
-            return;
-        }
-        if (StringUtils.isBlank(dateBoundInfo.getLowerBound())
-                && StringUtils.isNotBlank(dateBoundInfo.getUpperBound())
-                && StringUtils.isNotBlank(dateBoundInfo.getUpperDate())) {
-            String upperDate = dateBoundInfo.getUpperDate();
-            try {
-                correctS2SQL = SqlAddHelper.addParenthesisToWhere(correctS2SQL);
-                String condExpr = dateBoundInfo.getColumName() + " >= '" + upperDate + "'";
-                correctS2SQL = SqlAddHelper.addWhere(correctS2SQL, CCJSqlParserUtil.parseCondExpression(condExpr));
-            } catch (JSQLParserException e) {
-                log.error("parseCondExpression", e);
-            }
-            semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
-        }
-    }
-
-    private void parserDateDiffFunction(SemanticParseInfo semanticParseInfo) {
-        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        correctS2SQL = SqlReplaceHelper.replaceFunction(correctS2SQL);
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
-    }
-
-}

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

@@ -1,99 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.tencent.supersonic.headless.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
-import com.tencent.supersonic.chat.api.pojo.ViewSchema;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.BeanUtils;
-
-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;
-
-@Slf4j
-public abstract class BaseMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContext queryContext) {
-
-        String simpleName = this.getClass().getSimpleName();
-        long startTime = System.currentTimeMillis();
-        log.debug("before {},mapInfo:{}", simpleName, queryContext.getMapInfo().getViewElementMatches());
-
-        try {
-            doMap(queryContext);
-        } catch (Exception e) {
-            log.error("work error", e);
-        }
-
-        long cost = System.currentTimeMillis() - startTime;
-        log.debug("after {},cost:{},mapInfo:{}", simpleName, cost, queryContext.getMapInfo().getViewElementMatches());
-    }
-
-    public abstract void doMap(QueryContext queryContext);
-
-    public void addToSchemaMap(SchemaMapInfo schemaMap, Long modelId, SchemaElementMatch newElementMatch) {
-        Map<Long, List<SchemaElementMatch>> modelElementMatches = schemaMap.getViewElementMatches();
-        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 viewId, SchemaElementType elementType, Long elementID,
-            SemanticSchema semanticSchema) {
-        SchemaElement element = new SchemaElement();
-        ViewSchema viewSchema = semanticSchema.getViewSchemaMap().get(viewId);
-        if (Objects.isNull(viewSchema)) {
-            return null;
-        }
-        SchemaElement elementDb = viewSchema.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/HanlpDictMatchStrategy.java

@@ -1,119 +0,0 @@
-package com.tencent.supersonic.chat.core.mapper;
-
-import com.tencent.supersonic.chat.core.config.OptimizationConfig;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.headless.api.pojo.response.S2Term;
-import com.tencent.supersonic.headless.core.knowledge.HanlpMapResult;
-import com.tencent.supersonic.headless.server.service.KnowledgeService;
-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;
-
-    @Autowired
-    private KnowledgeService knowledgeService;
-
-    @Override
-    public Map<MatchText, List<HanlpMapResult>> match(QueryContext queryContext, List<S2Term> terms,
-            Set<Long> detectViewIds) {
-        String text = queryContext.getQueryText();
-        if (Objects.isNull(terms) || StringUtils.isEmpty(text)) {
-            return null;
-        }
-
-        log.debug("retryCount:{},terms:{},,detectModelIds:{}", terms, detectViewIds);
-
-        List<HanlpMapResult> detects = detect(queryContext, terms, detectViewIds);
-        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> detectViewIds,
-            String detectSegment, int offset) {
-        // step1. pre search
-        Integer oneDetectionMaxSize = optimizationConfig.getOneDetectionMaxSize();
-        LinkedHashSet<HanlpMapResult> hanlpMapResults = knowledgeService.prefixSearch(detectSegment,
-                oneDetectionMaxSize, detectViewIds).stream().collect(Collectors.toCollection(LinkedHashSet::new));
-        // step2. suffix search
-        LinkedHashSet<HanlpMapResult> suffixHanlpMapResults = knowledgeService.suffixSearch(detectSegment,
-                oneDetectionMaxSize, detectViewIds).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/parser/JavaLLMProxy.java

@@ -1,66 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.tencent.supersonic.chat.core.parser.plugin.function.FunctionPromptGenerator;
-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.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.pojo.QueryContext;
-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 lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Component;
-
-import java.util.Objects;
-
-/**
- * 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, Long viewId) {
-
-        SqlGeneration sqlGeneration = SqlGenerationFactory.get(
-                SqlGenerationMode.getMode(llmReq.getSqlGenerationMode()));
-        String modelName = llmReq.getSchema().getViewName();
-        LLMResp result = sqlGeneration.generation(llmReq, viewId);
-        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, Long viewId);
-
-    FunctionResp requestFunction(FunctionReq functionReq);
-
-}

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

@@ -1,104 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.alibaba.fastjson.JSON;
-import com.tencent.supersonic.chat.core.config.LLMParserConfig;
-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.parser.sql.llm.OutputFormat;
-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.LLMResp;
-import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.JsonUtil;
-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;
-
-import java.net.URI;
-import java.net.URL;
-import java.util.ArrayList;
-
-/**
- * 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, Long viewId) {
-        long startTime = System.currentTimeMillis();
-        log.info("requestLLM request, viewId:{},llmReq:{}", viewId, llmReq);
-        keyPipelineLog.info("viewId:{},llmReq:{}", viewId, 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,87 +0,0 @@
-package com.tencent.supersonic.chat.core.parser;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.headless.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.SqlSelectHelper;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * 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
-        Long viewId = parseInfo.getViewId();
-        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 = SqlSelectHelper.getWhereFields(sqlInfo.getS2SQL())
-                    .stream().filter(field -> !TimeDimensionEnum.containsTimeDimension(field))
-                    .collect(Collectors.toList());
-
-            if (CollectionUtils.isNotEmpty(whereFields)) {
-                Set<String> ids = semanticSchema.getEntities(viewId).stream().map(SchemaElement::getName)
-                        .collect(Collectors.toSet());
-                if (CollectionUtils.isNotEmpty(ids) && ids.stream().anyMatch(whereFields::contains)) {
-                    return QueryType.ID;
-                }
-                Set<String> tags = semanticSchema.getTags(viewId).stream().map(SchemaElement::getName)
-                        .collect(Collectors.toSet());
-                if (CollectionUtils.isNotEmpty(tags) && tags.containsAll(whereFields)) {
-                    return QueryType.TAG;
-                }
-            }
-        }
-        //2. metric queryType
-        List<String> selectFields = SqlSelectHelper.getSelectFields(sqlInfo.getS2SQL());
-        List<SchemaElement> metrics = semanticSchema.getMetrics(viewId);
-        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,123 +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.headless.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.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> viewIds = pluginRecallResult.getViewIds();
-        if (plugin.isContainsAllModel()) {
-            viewIds = Sets.newHashSet(-1L);
-        }
-        for (Long viewId : viewIds) {
-            PluginSemanticQuery pluginQuery = QueryManager.createPluginQuery(plugin.getType());
-            SemanticParseInfo semanticParseInfo = buildSemanticParseInfo(viewId, 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 viewId, Plugin plugin,
-                                                       QueryContext queryContext, double distance) {
-        List<SchemaElementMatch> schemaElementMatches = queryContext.getMapInfo().getMatchedElements(viewId);
-        QueryFilters queryFilters = queryContext.getQueryFilters();
-        if (viewId == null && !CollectionUtils.isEmpty(plugin.getViewList())) {
-            viewId = plugin.getViewList().get(0);
-        }
-        if (schemaElementMatches == null) {
-            schemaElementMatches = Lists.newArrayList();
-        }
-        SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
-        semanticParseInfo.setElementMatches(schemaElementMatches);
-        semanticParseInfo.setView(queryContext.getSemanticSchema().getView(viewId));
-        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,127 +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 lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-import org.springframework.util.CollectionUtils;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * 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> viewList = pluginResolveResult.getRight();
-            if (CollectionUtils.isEmpty(viewList)) {
-                return null;
-            }
-            double score = queryContext.getQueryText().length();
-            return PluginRecallResult.builder().plugin(plugin).viewIds(viewList).score(score).build();
-        }
-        return null;
-    }
-
-    public FunctionResp functionCall(QueryContext queryContext) {
-        List<PluginParseConfig> pluginToFunctionCall =
-                getPluginToFunctionCall(queryContext.getViewId(), 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/HeuristicViewResolver.java

@@ -1,138 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.chat.core.query.SemanticQuery;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-@Slf4j
-public class HeuristicViewResolver implements ViewResolver {
-
-    protected static Long selectViewBySchemaElementMatchScore(Map<Long, SemanticQuery> viewQueryModes,
-            SchemaMapInfo schemaMap) {
-        //view count priority
-        Long viewIdByViewCount = getViewIdByMatchViewScore(schemaMap);
-        if (Objects.nonNull(viewIdByViewCount)) {
-            log.info("selectView by view count:{}", viewIdByViewCount);
-            return viewIdByViewCount;
-        }
-
-        Map<Long, ViewMatchResult> viewTypeMap = getViewTypeMap(schemaMap);
-        if (viewTypeMap.size() == 1) {
-            Long viewSelect = new ArrayList<>(viewTypeMap.entrySet()).get(0).getKey();
-            if (viewQueryModes.containsKey(viewSelect)) {
-                log.info("selectView with only one View [{}]", viewSelect);
-                return viewSelect;
-            }
-        } else {
-            Map.Entry<Long, ViewMatchResult> maxView = viewTypeMap.entrySet().stream()
-                    .filter(entry -> viewQueryModes.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 (maxView != null) {
-                log.info("selectView with multiple Views [{}]", maxView.getKey());
-                return maxView.getKey();
-            }
-        }
-        return null;
-    }
-
-    private static Long getViewIdByMatchViewScore(SchemaMapInfo schemaMap) {
-        Map<Long, List<SchemaElementMatch>> viewElementMatches = schemaMap.getViewElementMatches();
-        // calculate view match score, matched element gets 1.0 point, and inherit element gets 0.5 point
-        Map<Long, Double> viewIdToViewScore = new HashMap<>();
-        if (Objects.nonNull(viewElementMatches)) {
-            for (Entry<Long, List<SchemaElementMatch>> viewElementMatch : viewElementMatches.entrySet()) {
-                Long viewId = viewElementMatch.getKey();
-                List<Double> viewMatchesScore = viewElementMatch.getValue().stream()
-                        .filter(elementMatch -> elementMatch.getSimilarity() >= 1)
-                        .filter(elementMatch -> SchemaElementType.VIEW.equals(elementMatch.getElement().getType()))
-                        .map(elementMatch -> elementMatch.isInherited() ? 0.5 : 1.0).collect(Collectors.toList());
-
-                if (!CollectionUtils.isEmpty(viewMatchesScore)) {
-                    // get sum of view match score
-                    double score = viewMatchesScore.stream().mapToDouble(Double::doubleValue).sum();
-                    viewIdToViewScore.put(viewId, score);
-                }
-            }
-            Entry<Long, Double> maxViewScore = viewIdToViewScore.entrySet().stream()
-                    .max(Comparator.comparingDouble(Entry::getValue)).orElse(null);
-            log.info("maxViewCount:{},viewIdToViewCount:{}", maxViewScore, viewIdToViewScore);
-            if (Objects.nonNull(maxViewScore)) {
-                return maxViewScore.getKey();
-            }
-        }
-        return null;
-    }
-
-    public static Map<Long, ViewMatchResult> getViewTypeMap(SchemaMapInfo schemaMap) {
-        Map<Long, ViewMatchResult> viewCount = new HashMap<>();
-        for (Map.Entry<Long, List<SchemaElementMatch>> entry : schemaMap.getViewElementMatches().entrySet()) {
-            List<SchemaElementMatch> schemaElementMatches = schemaMap.getMatchedElements(entry.getKey());
-            if (schemaElementMatches != null && schemaElementMatches.size() > 0) {
-                if (!viewCount.containsKey(entry.getKey())) {
-                    viewCount.put(entry.getKey(), new ViewMatchResult());
-                }
-                ViewMatchResult viewMatchResult = viewCount.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) {
-                    viewMatchResult.setMaxSimilarity(schemaElementMatchMax.getSimilarity());
-                }
-                viewMatchResult.setCount(schemaElementTypes.size());
-
-            }
-        }
-        return viewCount;
-    }
-
-    public Long resolve(QueryContext queryContext, Set<Long> agentViewIds) {
-        SchemaMapInfo mapInfo = queryContext.getMapInfo();
-        Set<Long> matchedViews = mapInfo.getMatchedViewInfos();
-        Long viewId = queryContext.getViewId();
-        if (Objects.nonNull(viewId) && viewId > 0) {
-            if (CollectionUtils.isEmpty(agentViewIds) || agentViewIds.contains(viewId)) {
-                return viewId;
-            }
-            return null;
-        }
-        if (CollectionUtils.isNotEmpty(agentViewIds)) {
-            matchedViews.retainAll(agentViewIds);
-        }
-        Map<Long, SemanticQuery> viewQueryModes = new HashMap<>();
-        for (Long viewIds : matchedViews) {
-            viewQueryModes.put(viewIds, null);
-        }
-        if (viewQueryModes.size() == 1) {
-            return viewQueryModes.keySet().stream().findFirst().get();
-        }
-        return selectViewBySchemaElementMatchScore(viewQueryModes, mapInfo);
-    }
-
-}

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

@@ -1,252 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import com.google.common.collect.Lists;
-import com.tencent.supersonic.chat.core.utils.S2SqlDateHelper;
-import com.tencent.supersonic.headless.api.pojo.SchemaElement;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.headless.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.query.semantic.SemanticInterpreter;
-import com.tencent.supersonic.chat.core.parser.SatisfactionChecker;
-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.utils.ComponentFactory;
-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.pojo.response.ViewSchemaResp;
-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;
-
-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;
-
-@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 Long getViewId(QueryContext queryCtx) {
-        Agent agent = queryCtx.getAgent();
-        Set<Long> agentViewIds = new HashSet<>();
-        if (Objects.nonNull(agent)) {
-            agentViewIds = agent.getViewIds(AgentToolType.NL2SQL_LLM);
-        }
-        if (Agent.containsAllModel(agentViewIds)) {
-            agentViewIds = new HashSet<>();
-        }
-        ViewResolver viewResolver = ComponentFactory.getModelResolver();
-        return viewResolver.resolve(queryCtx, agentViewIds);
-    }
-
-    public NL2SQLTool getParserTool(QueryContext queryCtx, Long viewId) {
-        Agent agent = queryCtx.getAgent();
-        if (Objects.isNull(agent)) {
-            return null;
-        }
-        List<NL2SQLTool> commonAgentTools = agent.getParserTools(AgentToolType.NL2SQL_LLM);
-        Optional<NL2SQLTool> llmParserTool = commonAgentTools.stream()
-                .filter(tool -> {
-                    List<Long> viewIds = tool.getViewIds();
-                    if (Agent.containsAllModel(new HashSet<>(viewIds))) {
-                        return true;
-                    }
-                    return viewIds.contains(viewId);
-                })
-                .findFirst();
-        return llmParserTool.orElse(null);
-    }
-
-    public LLMReq getLlmReq(QueryContext queryCtx, Long viewId,
-                            SemanticSchema semanticSchema, List<ElementValue> linkingValues) {
-        Map<Long, String> viewIdToName = semanticSchema.getViewIdToName();
-        String queryText = queryCtx.getQueryText();
-
-        LLMReq llmReq = new LLMReq();
-        llmReq.setQueryText(queryText);
-        LLMReq.FilterCondition filterCondition = new LLMReq.FilterCondition();
-        llmReq.setFilterCondition(filterCondition);
-
-        LLMReq.LLMSchema llmSchema = new LLMReq.LLMSchema();
-        llmSchema.setViewName(viewIdToName.get(viewId));
-        llmSchema.setDomainName(viewIdToName.get(viewId));
-
-        List<String> fieldNameList = getFieldNameList(queryCtx, viewId, llmParserConfig);
-
-        String priorExts = getPriorExts(viewId, 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, viewId);
-        if (StringUtils.isEmpty(currentDate)) {
-            currentDate = DateUtils.getBeforeDate(0);
-        }
-        llmReq.setCurrentDate(currentDate);
-        llmReq.setSqlGenerationMode(optimizationConfig.getSqlGenerationMode().getName());
-        return llmReq;
-    }
-
-    public LLMResp requestLLM(LLMReq llmReq, Long viewId) {
-        return ComponentFactory.getLLMProxy().query2sql(llmReq, viewId);
-    }
-
-    protected List<String> getFieldNameList(QueryContext queryCtx, Long viewId,
-            LLMParserConfig llmParserConfig) {
-
-        Set<String> results = getTopNFieldNames(queryCtx, viewId, llmParserConfig);
-
-        Set<String> fieldNameList = getMatchedFieldNames(queryCtx, viewId);
-
-        results.addAll(fieldNameList);
-        return new ArrayList<>(results);
-    }
-
-    private String getPriorExts(Long viewId, List<String> fieldNameList) {
-        StringBuilder extraInfoSb = new StringBuilder();
-        List<ViewSchemaResp> viewSchemaResps = semanticInterpreter.fetchViewSchema(
-                Lists.newArrayList(viewId), true);
-        if (!CollectionUtils.isEmpty(viewSchemaResps)) {
-            ViewSchemaResp viewSchemaResp = viewSchemaResps.get(0);
-            Map<String, String> fieldNameToDataFormatType = viewSchemaResp.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, Long viewId) {
-        Map<Long, String> itemIdToName = getItemIdToName(queryCtx, viewId);
-        List<SchemaElementMatch> matchedElements = queryCtx.getMapInfo().getMatchedElements(viewId);
-        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, Long viewId) {
-        SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-        return semanticSchema.getDimensions(viewId).stream()
-                .collect(Collectors.toMap(SchemaElement::getId, SchemaElement::getName, (value1, value2) -> value2));
-    }
-
-    private Set<String> getTopNFieldNames(QueryContext queryCtx, Long viewId, LLMParserConfig llmParserConfig) {
-        SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-        Set<String> results = semanticSchema.getDimensions(viewId).stream()
-                .sorted(Comparator.comparing(SchemaElement::getUseCnt).reversed())
-                .limit(llmParserConfig.getDimensionTopN())
-                .map(entry -> entry.getName())
-                .collect(Collectors.toSet());
-
-        Set<String> metrics = semanticSchema.getMetrics(viewId).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, Long viewId) {
-        Map<Long, String> itemIdToName = getItemIdToName(queryCtx, viewId);
-        List<SchemaElementMatch> matchedElements = queryCtx.getMapInfo().getMatchedElements(viewId);
-        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,75 +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.util.ContextUtils;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.MapUtils;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-@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.
-            Long viewId = requestService.getViewId(queryCtx);
-            if (viewId == null) {
-                return;
-            }
-            //3.get agent tool and determine whether to skip this parser.
-            NL2SQLTool commonAgentTool = requestService.getParserTool(queryCtx, viewId);
-            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, viewId);
-            SemanticSchema semanticSchema = queryCtx.getSemanticSchema();
-            LLMReq llmReq = requestService.getLlmReq(queryCtx, viewId, semanticSchema, linkingValues);
-            LLMResp llmResp = requestService.requestLLM(llmReq, viewId);
-
-            if (Objects.isNull(llmResp)) {
-                return;
-            }
-            //5. deduplicate the SQL result list and build parserInfo
-            LLMResponseService responseService = ContextUtils.getBean(LLMResponseService.class);
-            Map<String, LLMSqlResp> deduplicationSqlResp = responseService.getDeduplicationSqlResp(llmResp);
-            ParseResult parseResult = ParseResult.builder()
-                    .viewId(viewId)
-                    .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/OnePassSCSqlGeneration.java

@@ -1,90 +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 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;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.stream.Collectors;
-
-@Service
-@Slf4j
-public class OnePassSCSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExamplarLoader sqlExamplarLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, Long viewId) {
-        //1.retriever sqlExamples and generate exampleListPool
-        keyPipelineLog.info("viewId:{},llmReq:{}", viewId, llmReq);
-
-        List<Map<String, String>> sqlExamples = sqlExamplarLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                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,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.chat.core.query.llm.s2sql.LLMSqlResp;
-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 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;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Service
-@Slf4j
-public class OnePassSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExamplarLoader sqlExampleLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, Long viewId) {
-        //1.retriever sqlExamples
-        keyPipelineLog.info("viewId:{},llmReq:{}", viewId, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExampleLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                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,32 +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 lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class ParseResult {
-
-    private Long viewId;
-
-    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/SqlExamplarLoader.java

@@ -1,81 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.tencent.supersonic.common.config.EmbeddingConfig;
-import com.tencent.supersonic.common.util.ComponentFactory;
-import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.common.util.embedding.EmbeddingQuery;
-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.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.CollectionUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.core.io.ClassPathResource;
-import org.springframework.stereotype.Component;
-
-@Slf4j
-@Component
-public class SqlExamplarLoader {
-
-    private static final String EXAMPLE_JSON_FILE = "s2ql_examplar.json";
-
-    private S2EmbeddingStore s2EmbeddingStore = ComponentFactory.getS2EmbeddingStore();
-    private TypeReference<List<SqlExample>> valueTypeRef = new TypeReference<List<SqlExample>>() {
-    };
-
-    @Autowired
-    private EmbeddingConfig embeddingConfig;
-
-    public List<SqlExample> getSqlExamples() throws IOException {
-        ClassPathResource resource = new ClassPathResource(EXAMPLE_JSON_FILE);
-        InputStream inputStream = resource.getInputStream();
-        return JsonUtil.INSTANCE.getObjectMapper().readValue(inputStream, valueTypeRef);
-    }
-
-    public void addEmbeddingStore(List<SqlExample> sqlExamples, String collectionName) {
-        List<EmbeddingQuery> queries = new ArrayList<>();
-        for (int i = 0; i < sqlExamples.size(); i++) {
-            SqlExample sqlExample = sqlExamples.get(i);
-            String question = sqlExample.getQuestion();
-            Map<String, Object> metaDataMap = JsonUtil.toMap(JsonUtil.toString(sqlExample), String.class, Object.class);
-            EmbeddingQuery embeddingQuery = new EmbeddingQuery();
-            embeddingQuery.setQueryId(String.valueOf(i));
-            embeddingQuery.setQuery(question);
-            embeddingQuery.setMetadata(metaDataMap);
-            queries.add(embeddingQuery);
-        }
-        s2EmbeddingStore.addQuery(collectionName, queries);
-    }
-
-    public List<Map<String, String>> retrieverSqlExamples(String queryText, int maxResults) {
-        String collectionName = embeddingConfig.getText2sqlCollectionName();
-        RetrieveQuery retrieveQuery = RetrieveQuery.builder().queryTextsList(Collections.singletonList(queryText))
-                .queryEmbeddings(null).build();
-
-        List<RetrieveQueryResult> resultList = s2EmbeddingStore.retrieveQuery(collectionName, retrieveQuery,
-                maxResults);
-        List<Map<String, String>> result = new ArrayList<>();
-        if (CollectionUtils.isEmpty(resultList)) {
-            return result;
-        }
-        for (Retrieval retrieval : resultList.get(0).getRetrieval()) {
-            if (Objects.nonNull(retrieval.getMetadata()) && !retrieval.getMetadata().isEmpty()) {
-                Map<String, String> convertedMap = retrieval.getMetadata().entrySet().stream()
-                        .collect(Collectors.toMap(Map.Entry::getKey, entry -> String.valueOf(entry.getValue())));
-                result.add(convertedMap);
-            }
-        }
-        return result;
-    }
-}

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

@@ -1,19 +0,0 @@
-package com.tencent.supersonic.chat.core.parser.sql.llm;
-
-import lombok.Data;
-
-@Data
-public class SqlExample {
-
-    private String question;
-
-    private String questionAugmented;
-
-    private String dbSchema;
-
-    private String sql;
-
-    private String generatedSchemaLinkingCoT;
-
-    private String generatedSchemaLinkings;
-}

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 viewId
-     * @return
-     */
-    LLMResp generation(LLMReq llmReq, Long viewId);
-
-}

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

@@ -1,132 +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.LLMReq.ElementValue;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.tuple.Pair;
-import org.springframework.stereotype.Component;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-@Component
-@Slf4j
-public class SqlPromptGenerator {
-
-    public String generatorLinkingAndSqlPrompt(LLMReq llmReq, List<Map<String, String>> exampleList) {
-        String instruction =
-                "# Find the schema_links for generating SQL queries for each question based on the database schema "
-                        + "and Foreign keys. Then use the the schema links to generate the "
-                        + "SQL queries for each of the questions.";
-
-        List<String> exampleKeys = Arrays.asList("questionAugmented", "dbSchema", "generatedSchemaLinkingCoT", "sql");
-        String exampleTemplate = "dbSchema\nQ: questionAugmented\nA: generatedSchemaLinkingCoT\nSQL: sql";
-
-        String exampleFormat = InputFormat.format(exampleTemplate, exampleKeys, exampleList);
-
-        Pair<String, String> questionPrompt = transformQuestionPrompt(llmReq);
-        String dbSchema = questionPrompt.getLeft();
-        String questionAugmented = questionPrompt.getRight();
-
-        String newCaseTemplate = "%s\nQ: %s\nA: Let’s think step by step. In the question \"%s\", we are asked:";
-        String newCasePrompt = String.format(newCaseTemplate, dbSchema, questionAugmented, questionAugmented);
-
-        return instruction + InputFormat.SEPERATOR + exampleFormat + InputFormat.SEPERATOR + newCasePrompt;
-    }
-
-    public String generateLinkingPrompt(LLMReq llmReq, List<Map<String, String>> exampleList) {
-        String instruction = "# Find the schema_links for generating SQL queries for each question "
-                + "based on the database schema and Foreign keys.";
-
-        List<String> exampleKeys = Arrays.asList("questionAugmented", "dbSchema", "generatedSchemaLinkingCoT");
-        String exampleTemplate = "dbSchema\nQ: questionAugmented\nA: generatedSchemaLinkingCoT";
-        String exampleFormat = InputFormat.format(exampleTemplate, exampleKeys, exampleList);
-
-        Pair<String, String> questionPrompt = transformQuestionPrompt(llmReq);
-        String dbSchema = questionPrompt.getLeft();
-        String questionAugmented = questionPrompt.getRight();
-        String newCaseTemplate = "%s\nQ: %s\nA: Let’s think step by step. In the question \"%s\", we are asked:";
-        String newCasePrompt = String.format(newCaseTemplate, dbSchema, questionAugmented, questionAugmented);
-
-        return instruction + InputFormat.SEPERATOR + exampleFormat + InputFormat.SEPERATOR + newCasePrompt;
-    }
-
-    public String generateSqlPrompt(LLMReq llmReq, String schemaLinkStr, List<Map<String, String>> fewshotExampleList) {
-        String instruction = "# Use the the schema links to generate the SQL queries for each of the questions.";
-        List<String> exampleKeys = Arrays.asList("questionAugmented", "dbSchema", "generatedSchemaLinkings", "sql");
-        String exampleTemplate = "dbSchema\nQ: questionAugmented\n" + "Schema_links: generatedSchemaLinkings\n"
-                + "SQL: sql";
-
-        String schemaLinkingPrompt = InputFormat.format(exampleTemplate, exampleKeys, fewshotExampleList);
-        Pair<String, String> questionPrompt = transformQuestionPrompt(llmReq);
-        String dbSchema = questionPrompt.getLeft();
-        String questionAugmented = questionPrompt.getRight();
-        String newCaseTemplate = "%s\nQ: %s\nSchema_links: %s\nSQL: ";
-        String newCasePrompt = String.format(newCaseTemplate, dbSchema, questionAugmented, schemaLinkStr);
-        return instruction + InputFormat.SEPERATOR + schemaLinkingPrompt + InputFormat.SEPERATOR + newCasePrompt;
-    }
-
-    public List<String> generatePromptPool(LLMReq llmReq, List<List<Map<String, String>>> exampleListPool,
-            boolean isSqlPrompt) {
-        List<String> promptPool = new ArrayList<>();
-        for (List<Map<String, String>> exampleList : exampleListPool) {
-            String prompt;
-            if (isSqlPrompt) {
-                prompt = generatorLinkingAndSqlPrompt(llmReq, exampleList);
-            } else {
-                prompt = generateLinkingPrompt(llmReq, exampleList);
-            }
-            promptPool.add(prompt);
-        }
-        return promptPool;
-    }
-
-    public List<List<Map<String, String>>> getExampleCombos(List<Map<String, String>> exampleList, int numFewShots,
-            int numSelfConsistency) {
-        List<List<Map<String, String>>> results = new ArrayList<>();
-        for (int i = 0; i < numSelfConsistency; i++) {
-            List<Map<String, String>> shuffledList = new ArrayList<>(exampleList);
-            Collections.shuffle(shuffledList);
-            results.add(shuffledList.subList(0, numFewShots));
-        }
-        return results;
-    }
-
-    public Pair<String, String> transformQuestionPrompt(LLMReq llmReq) {
-        String modelName = llmReq.getSchema().getViewName();
-        List<String> fieldNameList = llmReq.getSchema().getFieldNameList();
-        List<ElementValue> linking = llmReq.getLinking();
-        String currentDate = llmReq.getCurrentDate();
-        String priorExts = llmReq.getPriorExts();
-
-        String dbSchema = "Table: " + modelName + ", Columns = " + fieldNameList + "\nForeign_keys: []";
-
-        List<String> priorLinkingList = new ArrayList<>();
-        for (ElementValue priorLinking : linking) {
-            String fieldName = priorLinking.getFieldName();
-            String fieldValue = priorLinking.getFieldValue();
-            priorLinkingList.add("‘" + fieldValue + "‘是一个‘" + fieldName + "‘");
-        }
-        String currentDataStr = "当前的日期是" + currentDate;
-        String linkingListStr = String.join("，", priorLinkingList);
-        String questionAugmented = String.format("%s (补充信息:%s 。 %s) (备注: %s)", llmReq.getQueryText(), linkingListStr,
-                currentDataStr, priorExts);
-        return Pair.of(dbSchema, questionAugmented);
-    }
-
-    public List<String> generateSqlPromptPool(LLMReq llmReq, List<String> schemaLinkStrPool,
-            List<List<Map<String, String>>> fewshotExampleListPool) {
-        List<String> sqlPromptPool = new ArrayList<>();
-        for (int i = 0; i < schemaLinkStrPool.size(); i++) {
-            String schemaLinkStr = schemaLinkStrPool.get(i);
-            List<Map<String, String>> fewshotExampleList = fewshotExampleListPool.get(i);
-            String sqlPrompt = generateSqlPrompt(llmReq, schemaLinkStr, fewshotExampleList);
-            sqlPromptPool.add(sqlPrompt);
-        }
-        return sqlPromptPool;
-    }
-
-}

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

@@ -1,92 +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 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;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-@Service
-public class TwoPassSCSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExamplarLoader sqlExamplarLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, Long viewId) {
-        //1.retriever sqlExamples and generate exampleListPool
-        keyPipelineLog.info("viewId:{},llmReq:{}", viewId, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExamplarLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                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,76 +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 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;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Service
-@Slf4j
-public class TwoPassSqlGeneration implements SqlGeneration, InitializingBean {
-
-    private static final Logger keyPipelineLog = LoggerFactory.getLogger("keyPipeline");
-    @Autowired
-    private ChatLanguageModel chatLanguageModel;
-
-    @Autowired
-    private SqlExamplarLoader sqlExamplarLoader;
-
-    @Autowired
-    private OptimizationConfig optimizationConfig;
-
-    @Autowired
-    private SqlPromptGenerator sqlPromptGenerator;
-
-    @Override
-    public LLMResp generation(LLMReq llmReq, Long viewId) {
-        keyPipelineLog.info("viewId:{},llmReq:{}", viewId, llmReq);
-        List<Map<String, String>> sqlExamples = sqlExamplarLoader.retrieverSqlExamples(llmReq.getQueryText(),
-                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/llm/ViewResolver.java

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

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

@@ -1,88 +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 lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-@Slf4j
-public class AgentCheckParser implements SemanticParser {
-
-    @Override
-    public void parse(QueryContext queryContext, ChatContext chatContext) {
-        List<SemanticQuery> queries = queryContext.getCandidateQueries();
-        log.info("query size before agent filter:{}", queryContext.getCandidateQueries().size());
-        filterQueries(queryContext, queries);
-        log.info("query size after agent filter: {}", queryContext.getCandidateQueries().size());
-    }
-
-    private void filterQueries(QueryContext queryContext, List<SemanticQuery> queries) {
-        Agent agent = queryContext.getAgent();
-        if (agent == null) {
-            return;
-        }
-        List<RuleParserTool> queryTools = getRuleTools(agent);
-        if (CollectionUtils.isEmpty(queryTools)) {
-            queryContext.setCandidateQueries(Lists.newArrayList());
-            return;
-        }
-        log.info("agent name :{}, 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())) {
-                        if (!tool.getQueryTypes().contains(QueryType.TAG.name())) {
-                            return true;
-                        }
-                    }
-                    if (QueryManager.isMetricQuery(query.getQueryMode())) {
-                        if (!tool.getQueryTypes().contains(QueryType.METRIC.name())) {
-                            return true;
-                        }
-                    }
-                }
-                if (CollectionUtils.isEmpty(tool.getViewIds())) {
-                    return true;
-                }
-                if (tool.isContainsAllModel()) {
-                    return false;
-                }
-                return !tool.getViewIds().contains(query.getParseInfo().getViewId());
-            }
-            return true;
-        });
-        queryContext.setCandidateQueries(queries);
-        log.info("agent name :{}, 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/plugin/event/PluginAddEvent.java

@@ -1,18 +0,0 @@
-package com.tencent.supersonic.chat.core.plugin.event;
-
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import org.springframework.context.ApplicationEvent;
-
-public class PluginAddEvent extends ApplicationEvent {
-
-    private Plugin plugin;
-
-    public PluginAddEvent(Object source, Plugin plugin) {
-        super(source);
-        this.plugin = plugin;
-    }
-
-    public Plugin getPlugin() {
-        return plugin;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/plugin/event/PluginDelEvent.java

@@ -1,18 +0,0 @@
-package com.tencent.supersonic.chat.core.plugin.event;
-
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import org.springframework.context.ApplicationEvent;
-
-public class PluginDelEvent extends ApplicationEvent {
-
-    private Plugin plugin;
-
-    public PluginDelEvent(Object source, Plugin plugin) {
-        super(source);
-        this.plugin = plugin;
-    }
-
-    public Plugin getPlugin() {
-        return plugin;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/core/plugin/event/PluginUpdateEvent.java

@@ -1,26 +0,0 @@
-package com.tencent.supersonic.chat.core.plugin.event;
-
-import com.tencent.supersonic.chat.core.plugin.Plugin;
-import org.springframework.context.ApplicationEvent;
-
-public class PluginUpdateEvent extends ApplicationEvent {
-
-    private Plugin oldPlugin;
-
-    private Plugin newPlugin;
-
-    public PluginUpdateEvent(Object source, Plugin oldPlugin, Plugin newPlugin) {
-        super(source);
-        this.oldPlugin = oldPlugin;
-        this.newPlugin = newPlugin;
-    }
-
-    public Plugin getOldPlugin() {
-        return oldPlugin;
-    }
-
-    public Plugin getNewPlugin() {
-        return newPlugin;
-    }
-
-}

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

@@ -1,61 +0,0 @@
-package com.tencent.supersonic.chat.core.pojo;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-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 lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class QueryContext {
-
-    private String queryText;
-    private Integer chatId;
-    private Long viewId;
-    private User user;
-    private boolean saveAnswer = true;
-    private Integer agentId;
-    private QueryFilters queryFilters;
-    private List<SemanticQuery> candidateQueries = new ArrayList<>();
-    private SchemaMapInfo mapInfo = new SchemaMapInfo();
-    @JsonIgnore
-    private SemanticSchema semanticSchema;
-    @JsonIgnore
-    private Agent agent;
-    @JsonIgnore
-    private Map<Long, ChatConfigRichResp> modelIdToChatRichConfig;
-    @JsonIgnore
-    private Map<String, Plugin> nameToPlugin;
-    @JsonIgnore
-    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;
-    }
-}