headless integrates knowledge (#722)

2025-12-11 20:25:12 +00:00 · 2024-02-05 20:30:57 +08:00
parent 74d0ec2b23
commit 9600456bae
174 changed files with 1908 additions and 1817 deletions
--- a/headless/core/pom.xml
+++ b/headless/core/pom.xml
@@ -75,6 +75,44 @@
                </exclusion>
            </exclusions>
        </dependency>
+        <dependency>
+            <groupId>org.apache.hadoop</groupId>
+            <artifactId>hadoop-common</artifactId>
+            <version>${hadoop.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-log4j12</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>log4j</groupId>
+                    <artifactId>log4j</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.zookeeper</groupId>
+                    <artifactId>zookeeper</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.curator</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>javax.servlet</groupId>
+                    <artifactId>servlet-api</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>com.hankcs</groupId>-->
+<!--            <artifactId>hanlp</artifactId>-->
+<!--            <version>${hanlp.version}</version>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-compress</artifactId>
+            <version>${commons.compress.version}</version>
+            <scope>compile</scope>
+        </dependency>
    </dependencies>


--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/FileHandler.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/FileHandler.java
@@ -0,0 +1,57 @@
+package com.tencent.supersonic.headless.core.file;
+
+import java.util.List;
+
+public interface FileHandler {
+
+    /**
+     * backup files to a specific directory
+     * config: dict.directory.backup
+     *
+     * @param fileName
+     */
+    void backupFile(String fileName);
+
+    /**
+     * create a directory
+     *
+     * @param path
+     */
+    void createDir(String path);
+
+    Boolean existPath(String path);
+
+    /**
+     * write data to a specific file,
+     * config dir: dict.directory.latest
+     *
+     * @param data
+     * @param fileName
+     * @param append
+     */
+    void writeFile(List<String> data, String fileName, Boolean append);
+
+    /**
+     * get the knowledge file root directory
+     *
+     * @return
+     */
+    String getDictRootPath();
+
+    /**
+     * delete dictionary file
+     * automatic backup
+     *
+     * @param fileName
+     * @return
+     */
+    Boolean deleteDictFile(String fileName);
+
+    /**
+     * delete files directly without backup
+     *
+     * @param fileName
+     */
+    void deleteFile(String fileName);
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/FileHandlerImpl.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/FileHandlerImpl.java
@@ -0,0 +1,130 @@
+package com.tencent.supersonic.headless.core.file;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+@Slf4j
+@Component
+public class FileHandlerImpl implements FileHandler {
+
+    private final LocalFileConfig localFileConfig;
+
+    public FileHandlerImpl(LocalFileConfig localFileConfig) {
+        this.localFileConfig = localFileConfig;
+    }
+
+    @Override
+    public void backupFile(String fileName) {
+        String dictDirectoryBackup = localFileConfig.getDictDirectoryBackup();
+        if (!existPath(dictDirectoryBackup)) {
+            createDir(dictDirectoryBackup);
+        }
+
+        String source = localFileConfig.getDictDirectoryLatest() + "/" + fileName;
+        String target = dictDirectoryBackup + "/" + fileName;
+        Path sourcePath = Paths.get(source);
+        Path targetPath = Paths.get(target);
+        try {
+            Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
+            log.info("backupFile successfully! path:{}", targetPath.toAbsolutePath());
+        } catch (IOException e) {
+            log.info("Failed to copy file: " + e.getMessage());
+        }
+
+    }
+
+    @Override
+    public void createDir(String directoryPath) {
+        Path path = Paths.get(directoryPath);
+        try {
+            Files.createDirectories(path);
+            log.info("Directory created successfully!");
+        } catch (IOException e) {
+            log.info("Failed to create directory: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void deleteFile(String filePath) {
+        Path path = Paths.get(filePath);
+        try {
+            Files.delete(path);
+            log.info("File:{} deleted successfully!", getAbsolutePath(filePath));
+        } catch (IOException e) {
+            log.warn("Failed to delete file:{}, e:", getAbsolutePath(filePath), e);
+        }
+    }
+
+    @Override
+    public Boolean existPath(String pathStr) {
+        Path path = Paths.get(pathStr);
+        if (Files.exists(path)) {
+            log.info("path:{} exists!", getAbsolutePath(pathStr));
+            return true;
+        } else {
+            log.info("path:{} not exists!", getAbsolutePath(pathStr));
+        }
+        return false;
+    }
+
+    @Override
+    public void writeFile(List<String> lines, String fileName, Boolean append) {
+        if (CollectionUtils.isEmpty(lines)) {
+            log.info("lines is empty");
+            return;
+        }
+        String dictDirectoryLatest = localFileConfig.getDictDirectoryLatest();
+        if (!existPath(dictDirectoryLatest)) {
+            createDir(dictDirectoryLatest);
+        }
+        String filePath = dictDirectoryLatest + "/" + fileName;
+        if (existPath(filePath)) {
+            backupFile(fileName);
+        }
+        try (BufferedWriter writer = getWriter(filePath, append)) {
+            if (!CollectionUtils.isEmpty(lines)) {
+                for (String line : lines) {
+                    writer.write(line);
+                    writer.newLine();
+                }
+            }
+            log.info("File:{} written successfully!", getAbsolutePath(filePath));
+        } catch (IOException e) {
+            log.info("Failed to write file:{}, e:", getAbsolutePath(filePath), e);
+        }
+    }
+
+    public String getAbsolutePath(String path) {
+        return Paths.get(path).toAbsolutePath().toString();
+    }
+
+    @Override
+    public String getDictRootPath() {
+        return Paths.get(localFileConfig.getDictDirectoryLatest()).toAbsolutePath().toString();
+    }
+
+    @Override
+    public Boolean deleteDictFile(String fileName) {
+        backupFile(fileName);
+        deleteFile(localFileConfig.getDictDirectoryLatest() + "/" + fileName);
+        return true;
+    }
+
+    private BufferedWriter getWriter(String filePath, Boolean append) throws IOException {
+        if (append) {
+            return Files.newBufferedWriter(Paths.get(filePath), StandardCharsets.UTF_8, StandardOpenOption.APPEND);
+        }
+        return Files.newBufferedWriter(Paths.get(filePath), StandardCharsets.UTF_8);
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/LocalFileConfig.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/file/LocalFileConfig.java
@@ -0,0 +1,33 @@
+package com.tencent.supersonic.headless.core.file;
+
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+@Data
+@Configuration
+@Slf4j
+public class LocalFileConfig {
+
+
+    @Value("${dict.directory.latest:/data/dictionary/custom}")
+    private String dictDirectoryLatest;
+
+    @Value("${dict.directory.backup:./data/dictionary/backup}")
+    private String dictDirectoryBackup;
+
+    public String getDictDirectoryLatest() {
+        return getResourceDir() + dictDirectoryLatest;
+    }
+
+    public String getDictDirectoryBackup() {
+        return getResourceDir() + dictDirectoryBackup;
+    }
+
+    private String getResourceDir() {
+        //return hanlpPropertiesPath = HanlpHelper.getHanlpPropertiesPath();
+        return ClassLoader.getSystemClassLoader().getResource("").getPath();
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DatabaseMapResult.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DatabaseMapResult.java
@@ -0,0 +1,30 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.google.common.base.Objects;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import lombok.Data;
+import lombok.ToString;
+
+@Data
+@ToString
+public class DatabaseMapResult extends MapResult {
+
+    private SchemaElement schemaElement;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DatabaseMapResult that = (DatabaseMapResult) o;
+        return Objects.equal(name, that.name) && Objects.equal(schemaElement, that.schemaElement);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(name, schemaElement);
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictUpdateMode.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictUpdateMode.java
@@ -0,0 +1,31 @@
+
+package com.tencent.supersonic.headless.core.knowledge;
+
+public enum DictUpdateMode {
+
+    OFFLINE_FULL("OFFLINE_FULL"),
+    OFFLINE_MODEL("OFFLINE_MODEL"),
+    REALTIME_ADD("REALTIME_ADD"),
+    REALTIME_DELETE("REALTIME_DELETE"),
+    NOT_SUPPORT("NOT_SUPPORT");
+
+    private String value;
+
+    DictUpdateMode(String value) {
+        this.value = value;
+    }
+
+    public static DictUpdateMode of(String value) {
+        for (DictUpdateMode item : DictUpdateMode.values()) {
+            if (item.value.equalsIgnoreCase(value)) {
+                return item;
+            }
+        }
+        return DictUpdateMode.NOT_SUPPORT;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictWord.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictWord.java
@@ -0,0 +1,34 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import java.util.Objects;
+import lombok.Data;
+import lombok.ToString;
+
+/***
+ * word nature
+ */
+@Data
+@ToString
+public class DictWord {
+
+    private String word;
+    private String nature;
+    private String natureWithFrequency;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DictWord that = (DictWord) o;
+        return Objects.equals(word, that.word) && Objects.equals(natureWithFrequency, that.natureWithFrequency);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(word, natureWithFrequency);
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictionaryAttributeUtil.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/DictionaryAttributeUtil.java
@@ -0,0 +1,38 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.hankcs.hanlp.corpus.tag.Nature;
+import com.hankcs.hanlp.dictionary.CoreDictionary;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * Dictionary Attribute Util
+ */
+public class DictionaryAttributeUtil {
+
+    public static CoreDictionary.Attribute getAttribute(CoreDictionary.Attribute old, CoreDictionary.Attribute add) {
+        Map<Nature, Integer> map = new HashMap<>();
+        IntStream.range(0, old.nature.length).boxed().forEach(i -> map.put(old.nature[i], old.frequency[i]));
+        IntStream.range(0, add.nature.length).boxed().forEach(i -> map.put(add.nature[i], add.frequency[i]));
+        List<Map.Entry<Nature, Integer>> list = new LinkedList<Map.Entry<Nature, Integer>>(map.entrySet());
+        Collections.sort(list, new Comparator<Map.Entry<Nature, Integer>>() {
+            public int compare(Map.Entry<Nature, Integer> o1, Map.Entry<Nature, Integer> o2) {
+                return o2.getValue() - o1.getValue();
+            }
+        });
+        CoreDictionary.Attribute attribute = new CoreDictionary.Attribute(
+                list.stream().map(i -> i.getKey()).collect(Collectors.toList()).toArray(new Nature[0]),
+                list.stream().map(i -> i.getValue()).mapToInt(Integer::intValue).toArray(),
+                list.stream().map(i -> i.getValue()).findFirst().get());
+        if (old.original != null || add.original != null) {
+            attribute.original = add.original != null ? add.original : old.original;
+        }
+        return attribute;
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/EmbeddingResult.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/EmbeddingResult.java
@@ -0,0 +1,34 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.google.common.base.Objects;
+import java.util.Map;
+import lombok.Data;
+import lombok.ToString;
+
+@Data
+@ToString
+public class EmbeddingResult extends MapResult {
+
+    private String id;
+
+    private double distance;
+
+    private Map<String, String> metadata;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        EmbeddingResult that = (EmbeddingResult) o;
+        return Objects.equal(id, that.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(id);
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/HadoopFileIOAdapter.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/HadoopFileIOAdapter.java
@@ -0,0 +1,32 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.hankcs.hanlp.corpus.io.IIOAdapter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+
+@Slf4j
+public class HadoopFileIOAdapter implements IIOAdapter {
+
+    @Override
+    public InputStream open(String path) throws IOException {
+        log.info("open:{}", path);
+        Configuration conf = new Configuration();
+        FileSystem fs = FileSystem.get(URI.create(path), conf);
+        return fs.open(new Path(path));
+    }
+
+    @Override
+    public OutputStream create(String path) throws IOException {
+        log.info("create:{}", path);
+        Configuration conf = new Configuration();
+        FileSystem fs = FileSystem.get(URI.create(path), conf);
+        return fs.create(new Path(path));
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/HanlpMapResult.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/HanlpMapResult.java
@@ -0,0 +1,44 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.google.common.base.Objects;
+import java.util.List;
+import lombok.Data;
+import lombok.ToString;
+
+@Data
+@ToString
+public class HanlpMapResult extends MapResult {
+
+    private List<String> natures;
+    private int offset = 0;
+
+    private double similarity;
+
+    public HanlpMapResult(String name, List<String> natures, String detectWord) {
+        this.name = name;
+        this.natures = natures;
+        this.detectWord = detectWord;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        HanlpMapResult hanlpMapResult = (HanlpMapResult) o;
+        return Objects.equal(name, hanlpMapResult.name) && Objects.equal(natures, hanlpMapResult.natures);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(name, natures);
+    }
+
+    public void setOffset(int offset) {
+        this.offset = offset;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/MapResult.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/MapResult.java
@@ -0,0 +1,13 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import java.io.Serializable;
+import lombok.Data;
+import lombok.ToString;
+
+@Data
+@ToString
+public class MapResult implements Serializable {
+
+    protected String name;
+    protected String detectWord;
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/MultiCustomDictionary.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/MultiCustomDictionary.java
@@ -0,0 +1,397 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import static com.hankcs.hanlp.utility.Predefine.logger;
+
+import com.hankcs.hanlp.HanLP;
+import com.hankcs.hanlp.collection.trie.DoubleArrayTrie;
+import com.hankcs.hanlp.collection.trie.bintrie.BinTrie;
+import com.hankcs.hanlp.corpus.io.ByteArray;
+import com.hankcs.hanlp.corpus.io.IOUtil;
+import com.hankcs.hanlp.corpus.tag.Nature;
+import com.hankcs.hanlp.dictionary.CoreDictionary;
+import com.hankcs.hanlp.dictionary.DynamicCustomDictionary;
+import com.hankcs.hanlp.dictionary.other.CharTable;
+import com.hankcs.hanlp.seg.common.Term;
+import com.hankcs.hanlp.utility.LexiconUtility;
+import com.hankcs.hanlp.utility.Predefine;
+import com.hankcs.hanlp.utility.TextUtility;
+import com.tencent.supersonic.headless.core.knowledge.helper.HanlpHelper;
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.PriorityQueue;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class MultiCustomDictionary extends DynamicCustomDictionary {
+
+    public static int MAX_SIZE = 10;
+    public static Boolean removeDuplicates = true;
+    public static ConcurrentHashMap<String, PriorityQueue<Term>> NATURE_TO_VALUES = new ConcurrentHashMap<>();
+    private static boolean addToSuggesterTrie = true;
+
+    public MultiCustomDictionary() {
+        this(HanLP.Config.CustomDictionaryPath);
+    }
+
+    public MultiCustomDictionary(String... path) {
+        super(path);
+    }
+
+    /***
+     * load dictionary
+     * @param path
+     * @param defaultNature
+     * @param map
+     * @param customNatureCollector
+     * @param addToSuggeterTrie
+     * @return
+     */
+    public static boolean load(String path, Nature defaultNature, TreeMap<String, CoreDictionary.Attribute> map,
+            LinkedHashSet<Nature> customNatureCollector, boolean addToSuggeterTrie) {
+        try {
+            String splitter = "\\s";
+            if (path.endsWith(".csv")) {
+                splitter = ",";
+            }
+
+            BufferedReader br = new BufferedReader(new InputStreamReader(IOUtil.newInputStream(path), "UTF-8"));
+            boolean firstLine = true;
+
+            while (true) {
+                String[] param;
+                do {
+                    String line;
+                    if ((line = br.readLine()) == null) {
+                        br.close();
+                        return true;
+                    }
+
+                    if (firstLine) {
+                        line = IOUtil.removeUTF8BOM(line);
+                        firstLine = false;
+                    }
+
+                    param = line.split(splitter);
+                } while (param[0].length() == 0);
+
+                if (HanLP.Config.Normalization) {
+                    param[0] = CharTable.convert(param[0]);
+                }
+
+                int natureCount = (param.length - 1) / 2;
+                CoreDictionary.Attribute attribute;
+                boolean isLetters = isLetters(param[0]);
+                String original = null;
+                String word = getWordBySpace(param[0]);
+                if (isLetters) {
+                    original = word;
+                    word = word.toLowerCase();
+                }
+                if (natureCount == 0) {
+                    attribute = new CoreDictionary.Attribute(defaultNature);
+                } else {
+                    attribute = new CoreDictionary.Attribute(natureCount);
+
+                    for (int i = 0; i < natureCount; ++i) {
+                        attribute.nature[i] = LexiconUtility.convertStringToNature(param[1 + 2 * i],
+                                customNatureCollector);
+                        attribute.frequency[i] = Integer.parseInt(param[2 + 2 * i]);
+                        attribute.totalFrequency += attribute.frequency[i];
+                    }
+                }
+                attribute.original = original;
+
+                if (removeDuplicates && map.containsKey(word)) {
+                    attribute = DictionaryAttributeUtil.getAttribute(map.get(word), attribute);
+                }
+                map.put(word, attribute);
+                if (addToSuggeterTrie) {
+                    SearchService.put(word, attribute);
+                }
+                for (int i = 0; i < attribute.nature.length; i++) {
+                    Nature nature = attribute.nature[i];
+                    PriorityQueue<Term> priorityQueue = NATURE_TO_VALUES.get(nature.toString());
+                    if (Objects.isNull(priorityQueue)) {
+                        priorityQueue = new PriorityQueue<>(MAX_SIZE,
+                                Comparator.comparingInt(Term::getFrequency).reversed());
+                        NATURE_TO_VALUES.put(nature.toString(), priorityQueue);
+                    }
+                    Term term = new Term(word, nature);
+                    term.setFrequency(attribute.frequency[i]);
+                    if (!priorityQueue.contains(term) && priorityQueue.size() < MAX_SIZE) {
+                        priorityQueue.add(term);
+                    }
+                }
+            }
+        } catch (Exception var12) {
+            logger.severe("自定义词典" + path + "读取错误！" + var12);
+            return false;
+        }
+    }
+
+    public boolean load(String... path) {
+        this.path = path;
+        long start = System.currentTimeMillis();
+        if (!this.loadMainDictionary(path[0])) {
+            Predefine.logger.warning("自定义词典" + Arrays.toString(path) + "加载失败");
+            return false;
+        } else {
+            Predefine.logger.info(
+                    "自定义词典加载成功:" + this.dat.size() + "个词条，耗时" + (System.currentTimeMillis() - start) + "ms");
+            this.path = path;
+            return true;
+        }
+    }
+
+    /***
+     * load main dictionary
+     * @param mainPath
+     * @param path
+     * @param dat
+     * @param isCache
+     * @param addToSuggestTrie
+     * @return
+     */
+    public static boolean loadMainDictionary(String mainPath, String[] path,
+                                             DoubleArrayTrie<CoreDictionary.Attribute> dat, boolean isCache,
+                                             boolean addToSuggestTrie) {
+        Predefine.logger.info("自定义词典开始加载:" + mainPath);
+        if (loadDat(mainPath, dat)) {
+            return true;
+        } else {
+            TreeMap<String, CoreDictionary.Attribute> map = new TreeMap();
+            LinkedHashSet customNatureCollector = new LinkedHashSet();
+
+            try {
+                for (String p : path) {
+                    Nature defaultNature = Nature.n;
+                    File file = new File(p);
+                    String fileName = file.getName();
+                    int cut = fileName.lastIndexOf(32);
+                    if (cut > 0) {
+                        String nature = fileName.substring(cut + 1);
+                        p = file.getParent() + File.separator + fileName.substring(0, cut);
+
+                        try {
+                            defaultNature = LexiconUtility.convertStringToNature(nature, customNatureCollector);
+                        } catch (Exception var16) {
+                            Predefine.logger.severe("配置文件【" + p + "】写错了！" + var16);
+                            continue;
+                        }
+                    }
+
+                    Predefine.logger.info("以默认词性[" + defaultNature + "]加载自定义词典" + p + "中……");
+                    boolean success = load(p, defaultNature, map, customNatureCollector, addToSuggestTrie);
+                    if (!success) {
+                        Predefine.logger.warning("失败：" + p);
+                    }
+                }
+
+                if (map.size() == 0) {
+                    Predefine.logger.warning("没有加载到任何词条");
+                    map.put("未##它", null);
+                }
+
+                logger.info("正在构建DoubleArrayTrie……");
+                dat.build(map);
+                if (addToSuggestTrie) {
+                    // SearchService.save();
+                }
+                if (isCache) {
+                    // 缓存成dat文件，下次加载会快很多
+                    logger.info("正在缓存词典为dat文件……");
+                    // 缓存值文件
+                    List<CoreDictionary.Attribute> attributeList = new LinkedList<CoreDictionary.Attribute>();
+                    for (Map.Entry<String, CoreDictionary.Attribute> entry : map.entrySet()) {
+                        attributeList.add(entry.getValue());
+                    }
+
+                    DataOutputStream out = new DataOutputStream(
+                            new BufferedOutputStream(IOUtil.newOutputStream(mainPath + ".bin")));
+                    if (customNatureCollector.isEmpty()) {
+                        for (int i = Nature.begin.ordinal() + 1; i < Nature.values().length; ++i) {
+                            Nature nature = Nature.values()[i];
+                            if (Objects.nonNull(nature)) {
+                                customNatureCollector.add(nature);
+                            }
+                        }
+                    }
+
+                    IOUtil.writeCustomNature(out, customNatureCollector);
+                    out.writeInt(attributeList.size());
+
+                    for (CoreDictionary.Attribute attribute : attributeList) {
+                        attribute.save(out);
+                    }
+
+                    dat.save(out);
+                    out.close();
+                }
+            } catch (FileNotFoundException var17) {
+                logger.severe("自定义词典" + mainPath + "不存在！" + var17);
+                return false;
+            } catch (IOException var18) {
+                logger.severe("自定义词典" + mainPath + "读取错误！" + var18);
+                return false;
+            } catch (Exception var19) {
+                logger.warning("自定义词典" + mainPath + "缓存失败！\n" + TextUtility.exceptionToString(var19));
+            }
+
+            return true;
+        }
+    }
+
+    public boolean loadMainDictionary(String mainPath) {
+        return loadMainDictionary(mainPath, this.path, this.dat, true, addToSuggesterTrie);
+    }
+
+    public static boolean loadDat(String path, DoubleArrayTrie<CoreDictionary.Attribute> dat) {
+        return loadDat(path, HanLP.Config.CustomDictionaryPath, dat);
+    }
+
+    public static boolean loadDat(String path, String[] customDicPath, DoubleArrayTrie<CoreDictionary.Attribute> dat) {
+        try {
+            if (HanLP.Config.CustomDictionaryAutoRefreshCache && isDicNeedUpdate(path, customDicPath)) {
+                return false;
+            } else {
+                ByteArray byteArray = ByteArray.createByteArray(path + ".bin");
+                if (byteArray == null) {
+                    return false;
+                } else {
+                    int size = byteArray.nextInt();
+                    if (size < 0) {
+                        while (true) {
+                            ++size;
+                            if (size > 0) {
+                                size = byteArray.nextInt();
+                                break;
+                            }
+
+                            Nature.create(byteArray.nextString());
+                        }
+                    }
+
+                    CoreDictionary.Attribute[] attributes = new CoreDictionary.Attribute[size];
+                    Nature[] natureIndexArray = Nature.values();
+
+                    for (int i = 0; i < size; ++i) {
+                        int currentTotalFrequency = byteArray.nextInt();
+                        int length = byteArray.nextInt();
+                        attributes[i] = new CoreDictionary.Attribute(length);
+                        attributes[i].totalFrequency = currentTotalFrequency;
+
+                        for (int j = 0; j < length; ++j) {
+                            attributes[i].nature[j] = natureIndexArray[byteArray.nextInt()];
+                            attributes[i].frequency[j] = byteArray.nextInt();
+                        }
+                    }
+
+                    if (!dat.load(byteArray, attributes)) {
+                        return false;
+                    } else {
+                        return true;
+                    }
+                }
+            }
+        } catch (Exception var11) {
+            logger.warning("读取失败，问题发生在" + TextUtility.exceptionToString(var11));
+            return false;
+        }
+    }
+
+    public static boolean isLetters(String str) {
+        char[] chars = str.toCharArray();
+        if (chars.length <= 1) {
+            return false;
+        }
+        for (int i = 0; i < chars.length; i++) {
+            if ((chars[i] >= 'A' && chars[i] <= 'Z')) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isLowerLetter(String str) {
+        char[] chars = str.toCharArray();
+        for (int i = 0; i < chars.length; i++) {
+            if ((chars[i] >= 'a' && chars[i] <= 'z')) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static String getWordBySpace(String word) {
+        if (word.contains(HanlpHelper.SPACE_SPILT)) {
+            return word.replace(HanlpHelper.SPACE_SPILT, " ");
+        }
+        return word;
+    }
+
+    public boolean reload() {
+        if (this.path != null && this.path.length != 0) {
+            IOUtil.deleteFile(this.path[0] + ".bin");
+            Boolean loadCacheOk = this.loadDat(this.path[0], this.path, this.dat);
+            if (!loadCacheOk) {
+                return this.loadMainDictionary(this.path[0], this.path, this.dat, true, addToSuggesterTrie);
+            }
+        }
+        return false;
+
+    }
+
+    public synchronized boolean insert(String word, String natureWithFrequency) {
+        if (word == null) {
+            return false;
+        } else {
+            if (HanLP.Config.Normalization) {
+                word = CharTable.convert(word);
+            }
+            CoreDictionary.Attribute att = natureWithFrequency == null ? new CoreDictionary.Attribute(Nature.nz, 1)
+                    : CoreDictionary.Attribute.create(natureWithFrequency);
+            boolean isLetters = isLetters(word);
+            word = getWordBySpace(word);
+            String original = null;
+            if (isLetters) {
+                original = word;
+                word = word.toLowerCase();
+            }
+            if (att == null) {
+                return false;
+            } else if (this.dat.containsKey(word)) {
+                att.original = original;
+                att = DictionaryAttributeUtil.getAttribute(this.dat.get(word), att);
+                this.dat.set(word, att);
+                // return true;
+            } else {
+                if (this.trie == null) {
+                    this.trie = new BinTrie();
+                }
+                att.original = original;
+                if (this.trie.containsKey(word)) {
+                    att = DictionaryAttributeUtil.getAttribute(this.trie.get(word), att);
+                }
+                this.trie.put(word, att);
+                // return true;
+            }
+            if (addToSuggesterTrie) {
+                SearchService.put(word, att);
+            }
+            return true;
+        }
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/SearchService.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/SearchService.java
@@ -0,0 +1,170 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import com.hankcs.hanlp.collection.trie.bintrie.BaseNode;
+import com.hankcs.hanlp.collection.trie.bintrie.BinTrie;
+import com.hankcs.hanlp.corpus.tag.Nature;
+import com.hankcs.hanlp.dictionary.CoreDictionary;
+import com.hankcs.hanlp.seg.common.Term;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import com.tencent.supersonic.headless.api.pojo.request.DimensionValueReq;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.util.CollectionUtils;
+
+@Slf4j
+public class SearchService {
+
+    public static final int SEARCH_SIZE = 200;
+    private static BinTrie<List<String>> trie;
+    private static BinTrie<List<String>> suffixTrie;
+
+    static {
+        trie = new BinTrie<>();
+        suffixTrie = new BinTrie<>();
+    }
+
+    /***
+     * prefix Search
+     * @param key
+     * @return
+     */
+    public static List<HanlpMapResult> prefixSearch(String key, int limit, Set<Long> detectModelIds) {
+        return prefixSearch(key, limit, trie, detectModelIds);
+    }
+
+    public static List<HanlpMapResult> prefixSearch(String key, int limit, BinTrie<List<String>> binTrie,
+                                                    Set<Long> detectModelIds) {
+        Set<Map.Entry<String, List<String>>> result = prefixSearchLimit(key, limit, binTrie, detectModelIds);
+        return result.stream().map(
+                        entry -> {
+                            String name = entry.getKey().replace("#", " ");
+                            return new HanlpMapResult(name, entry.getValue(), key);
+                        }
+                ).sorted((a, b) -> -(b.getName().length() - a.getName().length()))
+                .limit(SEARCH_SIZE)
+                .collect(Collectors.toList());
+    }
+
+    /***
+     * suffix Search
+     * @param key
+     * @return
+     */
+    public static List<HanlpMapResult> suffixSearch(String key, int limit, Set<Long> detectModelIds) {
+        String reverseDetectSegment = StringUtils.reverse(key);
+        return suffixSearch(reverseDetectSegment, limit, suffixTrie, detectModelIds);
+    }
+
+    public static List<HanlpMapResult> suffixSearch(String key, int limit, BinTrie<List<String>> binTrie,
+                                                    Set<Long> detectModelIds) {
+        Set<Map.Entry<String, List<String>>> result = prefixSearchLimit(key, limit, binTrie, detectModelIds);
+        return result.stream().map(
+                        entry -> {
+                            String name = entry.getKey().replace("#", " ");
+                            List<String> natures = entry.getValue().stream()
+                                    .map(nature -> nature.replaceAll(DictWordType.SUFFIX.getType(), ""))
+                                    .collect(Collectors.toList());
+                            name = StringUtils.reverse(name);
+                            return new HanlpMapResult(name, natures, key);
+                        }
+                ).sorted((a, b) -> -(b.getName().length() - a.getName().length()))
+                .limit(SEARCH_SIZE)
+                .collect(Collectors.toList());
+    }
+
+    private static Set<Map.Entry<String, List<String>>> prefixSearchLimit(String key, int limit,
+            BinTrie<List<String>> binTrie, Set<Long> detectModelIds) {
+        key = key.toLowerCase();
+        Set<Map.Entry<String, List<String>>> entrySet = new TreeSet<Map.Entry<String, List<String>>>();
+
+        StringBuilder sb = new StringBuilder();
+        if (StringUtils.isNotBlank(key)) {
+            sb = new StringBuilder(key.substring(0, key.length() - 1));
+        }
+        BaseNode branch = binTrie;
+        char[] chars = key.toCharArray();
+        for (char aChar : chars) {
+            if (branch == null) {
+                return entrySet;
+            }
+            branch = branch.getChild(aChar);
+        }
+
+        if (branch == null) {
+            return entrySet;
+        }
+        branch.walkLimit(sb, entrySet, limit, detectModelIds);
+        return entrySet;
+    }
+
+    public static void clear() {
+        log.info("clear all trie");
+        trie = new BinTrie<>();
+        suffixTrie = new BinTrie<>();
+    }
+
+    public static void put(String key, CoreDictionary.Attribute attribute) {
+        trie.put(key, getValue(attribute.nature));
+    }
+
+    public static void loadSuffix(List<DictWord> suffixes) {
+        if (CollectionUtils.isEmpty(suffixes)) {
+            return;
+        }
+        TreeMap<String, CoreDictionary.Attribute> map = new TreeMap();
+        for (DictWord suffix : suffixes) {
+            CoreDictionary.Attribute attributeNew = suffix.getNatureWithFrequency() == null
+                    ? new CoreDictionary.Attribute(Nature.nz, 1)
+                    : CoreDictionary.Attribute.create(suffix.getNatureWithFrequency());
+            if (map.containsKey(suffix.getWord())) {
+                attributeNew = DictionaryAttributeUtil.getAttribute(map.get(suffix.getWord()), attributeNew);
+            }
+            map.put(suffix.getWord(), attributeNew);
+        }
+        for (Map.Entry<String, CoreDictionary.Attribute> stringAttributeEntry : map.entrySet()) {
+            putSuffix(stringAttributeEntry.getKey(), stringAttributeEntry.getValue());
+        }
+    }
+
+    public static void putSuffix(String key, CoreDictionary.Attribute attribute) {
+        Nature[] nature = attribute.nature;
+        suffixTrie.put(key, getValue(nature));
+    }
+
+    private static List<String> getValue(Nature[] nature) {
+        return Arrays.stream(nature).map(entry -> entry.toString()).collect(Collectors.toList());
+    }
+
+    public static void remove(DictWord dictWord, Nature[] natures) {
+        trie.remove(dictWord.getWord());
+        if (Objects.nonNull(natures) && natures.length > 0) {
+            trie.put(dictWord.getWord(), getValue(natures));
+        }
+        if (dictWord.getNature().contains(DictWordType.METRIC.getType()) || dictWord.getNature()
+                .contains(DictWordType.DIMENSION.getType())) {
+            suffixTrie.remove(dictWord.getWord());
+        }
+    }
+
+    public static List<String> getDimensionValue(DimensionValueReq dimensionValueReq) {
+        String nature = DictWordType.NATURE_SPILT + dimensionValueReq.getModelId() + DictWordType.NATURE_SPILT
+                + dimensionValueReq.getElementID();
+        PriorityQueue<Term> terms = MultiCustomDictionary.NATURE_TO_VALUES.get(nature);
+        if (org.apache.commons.collections.CollectionUtils.isEmpty(terms)) {
+            return new ArrayList<>();
+        }
+        return terms.stream().map(term -> term.getWord()).collect(Collectors.toList());
+    }
+}
+
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/ViewInfoStat.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/ViewInfoStat.java
@@ -0,0 +1,22 @@
+package com.tencent.supersonic.headless.core.knowledge;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.ToString;
+
+import java.io.Serializable;
+
+@Data
+@ToString
+@Builder
+public class ViewInfoStat implements Serializable {
+
+    private long viewCount;
+
+    private long metricViewCount;
+
+    private long dimensionViewCount;
+
+    private long dimensionValueViewCount;
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/BaseWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/BaseWordBuilder.java
@@ -0,0 +1,38 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * base word nature
+ */
+@Slf4j
+public abstract class BaseWordBuilder {
+
+    public static final Long DEFAULT_FREQUENCY = 100000L;
+
+    public List<DictWord> getDictWords(List<SchemaElement> schemaElements) {
+        List<DictWord> dictWords = new ArrayList<>();
+        try {
+            dictWords = getDictWordsWithException(schemaElements);
+        } catch (Exception e) {
+            log.error("getWordNatureList error,", e);
+        }
+        return dictWords;
+    }
+
+    protected List<DictWord> getDictWordsWithException(List<SchemaElement> schemaElements) {
+
+        List<DictWord> dictWords = new ArrayList<>();
+
+        for (SchemaElement schemaElement : schemaElements) {
+            dictWords.addAll(doGet(schemaElement.getName(), schemaElement));
+        }
+        return dictWords;
+    }
+
+    protected abstract List<DictWord> doGet(String word, SchemaElement schemaElement);
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/DimensionWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/DimensionWordBuilder.java
@@ -0,0 +1,64 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * dimension word nature
+ */
+@Service
+public class DimensionWordBuilder extends BaseWordBuilder {
+
+    @Value("${nlp.dimension.use.suffix:true}")
+    private boolean nlpDimensionUseSuffix = true;
+
+    @Override
+    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
+        List<DictWord> result = Lists.newArrayList();
+        result.add(getOnwWordNature(word, schemaElement, false));
+        result.addAll(getOnwWordNatureAlias(schemaElement, false));
+        if (nlpDimensionUseSuffix) {
+            String reverseWord = StringUtils.reverse(word);
+            if (StringUtils.isNotEmpty(word) && !word.equalsIgnoreCase(reverseWord)) {
+                result.add(getOnwWordNature(reverseWord, schemaElement, true));
+            }
+        }
+        return result;
+    }
+
+    private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
+        DictWord dictWord = new DictWord();
+        dictWord.setWord(word);
+        Long viewId = schemaElement.getView();
+        String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+                + DictWordType.DIMENSION.getType();
+        if (isSuffix) {
+            nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+                    + DictWordType.SUFFIX.getType() + DictWordType.DIMENSION.getType();
+        }
+        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
+        return dictWord;
+    }
+
+    private List<DictWord> getOnwWordNatureAlias(SchemaElement schemaElement, boolean isSuffix) {
+        List<DictWord> dictWords = new ArrayList<>();
+        if (CollectionUtils.isEmpty(schemaElement.getAlias())) {
+            return dictWords;
+        }
+
+        for (String alias : schemaElement.getAlias()) {
+            dictWords.add(getOnwWordNature(alias, schemaElement, false));
+        }
+        return dictWords;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/EntityWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/EntityWordBuilder.java
@@ -0,0 +1,45 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * dimension value wordNature
+ */
+@Service
+@Slf4j
+public class EntityWordBuilder extends BaseWordBuilder {
+
+    @Override
+    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
+        List<DictWord> result = Lists.newArrayList();
+
+        if (Objects.isNull(schemaElement)) {
+            return result;
+        }
+
+        Long view = schemaElement.getView();
+        String nature = DictWordType.NATURE_SPILT + view + DictWordType.NATURE_SPILT + schemaElement.getId()
+                + DictWordType.ENTITY.getType();
+
+        if (!CollectionUtils.isEmpty(schemaElement.getAlias())) {
+            schemaElement.getAlias().stream().forEach(alias -> {
+                DictWord dictWordAlias = new DictWord();
+                dictWordAlias.setWord(alias);
+                dictWordAlias.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY * 2, nature));
+                result.add(dictWordAlias);
+            });
+        }
+        return result;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/MetricWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/MetricWordBuilder.java
@@ -0,0 +1,64 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Metric DictWord
+ */
+@Service
+public class MetricWordBuilder extends BaseWordBuilder {
+
+    @Value("${nlp.metric.use.suffix:true}")
+    private boolean nlpMetricUseSuffix = true;
+
+    @Override
+    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
+        List<DictWord> result = Lists.newArrayList();
+        result.add(getOnwWordNature(word, schemaElement, false));
+        result.addAll(getOnwWordNatureAlias(schemaElement, false));
+        if (nlpMetricUseSuffix) {
+            String reverseWord = StringUtils.reverse(word);
+            if (!word.equalsIgnoreCase(reverseWord)) {
+                result.add(getOnwWordNature(reverseWord, schemaElement, true));
+            }
+        }
+        return result;
+    }
+
+    private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
+        DictWord dictWord = new DictWord();
+        dictWord.setWord(word);
+        Long viewId = schemaElement.getView();
+        String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+                + DictWordType.METRIC.getType();
+        if (isSuffix) {
+            nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+                    + DictWordType.SUFFIX.getType() + DictWordType.METRIC.getType();
+        }
+        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
+        return dictWord;
+    }
+
+    private List<DictWord> getOnwWordNatureAlias(SchemaElement schemaElement, boolean isSuffix) {
+        List<DictWord> dictWords = new ArrayList<>();
+        if (CollectionUtils.isEmpty(schemaElement.getAlias())) {
+            return dictWords;
+        }
+
+        for (String alias : schemaElement.getAlias()) {
+            dictWords.add(getOnwWordNature(alias, schemaElement, false));
+        }
+        return dictWords;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/ModelWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/ModelWordBuilder.java
@@ -0,0 +1,44 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * model word nature
+ */
+@Service
+@Slf4j
+public class ModelWordBuilder extends BaseWordBuilder {
+
+    @Override
+    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
+        List<DictWord> result = Lists.newArrayList();
+        //modelName
+        DictWord dictWord = buildDictWord(word, schemaElement.getView());
+        result.add(dictWord);
+        //alias
+        List<String> aliasList = schemaElement.getAlias();
+        if (CollectionUtils.isNotEmpty(aliasList)) {
+            for (String alias : aliasList) {
+                result.add(buildDictWord(alias, schemaElement.getView()));
+            }
+        }
+        return result;
+    }
+
+    private DictWord buildDictWord(String word, Long modelId) {
+        DictWord dictWord = new DictWord();
+        dictWord.setWord(word);
+        String nature = DictWordType.NATURE_SPILT + modelId;
+        dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
+        return dictWord;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/ValueWordBuilder.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/ValueWordBuilder.java
@@ -0,0 +1,41 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * dimension value wordNature
+ */
+@Service
+@Slf4j
+public class ValueWordBuilder extends BaseWordBuilder {
+
+    @Override
+    public List<DictWord> doGet(String word, SchemaElement schemaElement) {
+
+        List<DictWord> result = Lists.newArrayList();
+        if (Objects.nonNull(schemaElement) && !CollectionUtils.isEmpty(schemaElement.getAlias())) {
+
+            schemaElement.getAlias().stream().forEach(value -> {
+                DictWord dictWord = new DictWord();
+                Long viewId = schemaElement.getView();
+                String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId();
+                dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
+                dictWord.setWord(value);
+                result.add(dictWord);
+            });
+        }
+        log.debug("ValueWordBuilder, result:{}", result);
+        return result;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/WordBuilderFactory.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/WordBuilderFactory.java
@@ -0,0 +1,26 @@
+package com.tencent.supersonic.headless.core.knowledge.builder;
+
+
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * DictWord Strategy Factory
+ */
+public class WordBuilderFactory {
+
+    private static Map<DictWordType, BaseWordBuilder> wordNatures = new ConcurrentHashMap<>();
+
+    static {
+        wordNatures.put(DictWordType.DIMENSION, new DimensionWordBuilder());
+        wordNatures.put(DictWordType.METRIC, new MetricWordBuilder());
+        wordNatures.put(DictWordType.VIEW, new ModelWordBuilder());
+        wordNatures.put(DictWordType.ENTITY, new EntityWordBuilder());
+        wordNatures.put(DictWordType.VALUE, new ValueWordBuilder());
+    }
+
+    public static BaseWordBuilder get(DictWordType strategyType) {
+        return wordNatures.get(strategyType);
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/FileHelper.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/FileHelper.java
@@ -0,0 +1,82 @@
+package com.tencent.supersonic.headless.core.knowledge.helper;
+
+import static com.hankcs.hanlp.HanLP.Config.CustomDictionaryPath;
+
+import com.hankcs.hanlp.dictionary.DynamicCustomDictionary;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class FileHelper {
+
+    public static final String FILE_SPILT = File.separator;
+
+    public static void deleteCacheFile(String[] path) throws IOException {
+
+        String customPath = getCustomPath(path);
+        File customFolder = new File(customPath);
+
+        File[] customSubFiles = getFileList(customFolder, ".bin");
+
+        for (File file : customSubFiles) {
+            try {
+                file.delete();
+                log.info("customPath:{},delete file:{}", customPath, file);
+            } catch (Exception e) {
+                log.error("delete " + file, e);
+            }
+        }
+    }
+
+    private static File[] getFileList(File customFolder, String suffix) {
+        File[] customSubFiles = customFolder.listFiles(file -> {
+            if (file.isDirectory()) {
+                return false;
+            }
+            if (file.getName().toLowerCase().endsWith(suffix)) {
+                return true;
+            }
+            return false;
+        });
+        return customSubFiles;
+    }
+
+    private static String getCustomPath(String[] path) {
+        return path[0].substring(0, path[0].lastIndexOf(FILE_SPILT)) + FILE_SPILT;
+    }
+
+    /**
+     * reset path
+     *
+     * @param customDictionary
+     */
+    public static void resetCustomPath(DynamicCustomDictionary customDictionary) {
+        String[] path = CustomDictionaryPath;
+
+        String customPath = getCustomPath(path);
+        File customFolder = new File(customPath);
+
+        File[] customSubFiles = getFileList(customFolder, ".txt");
+
+        List<String> fileList = new ArrayList<>();
+
+        for (File file : customSubFiles) {
+            if (file.isFile()) {
+                fileList.add(file.getAbsolutePath());
+            }
+        }
+
+        log.debug("CustomDictionaryPath:{}", fileList);
+        CustomDictionaryPath = fileList.toArray(new String[0]);
+        customDictionary.path = (CustomDictionaryPath == null || CustomDictionaryPath.length == 0) ? path
+                : CustomDictionaryPath;
+        if (CustomDictionaryPath == null || CustomDictionaryPath.length == 0) {
+            CustomDictionaryPath = path;
+        }
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/HanlpHelper.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/HanlpHelper.java
@@ -0,0 +1,229 @@
+package com.tencent.supersonic.headless.core.knowledge.helper;
+
+import static com.hankcs.hanlp.HanLP.Config.CustomDictionaryPath;
+
+import com.hankcs.hanlp.HanLP;
+import com.hankcs.hanlp.corpus.tag.Nature;
+import com.hankcs.hanlp.dictionary.CoreDictionary;
+import com.hankcs.hanlp.dictionary.DynamicCustomDictionary;
+import com.hankcs.hanlp.seg.Segment;
+import com.tencent.supersonic.headless.api.pojo.response.S2Term;
+import com.tencent.supersonic.headless.core.knowledge.DictWord;
+import com.tencent.supersonic.headless.core.knowledge.HadoopFileIOAdapter;
+import com.tencent.supersonic.headless.core.knowledge.MapResult;
+import com.tencent.supersonic.headless.core.knowledge.MultiCustomDictionary;
+import com.tencent.supersonic.headless.core.knowledge.SearchService;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import com.hankcs.hanlp.seg.common.Term;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ResourceUtils;
+
+/**
+ * HanLP helper
+ */
+@Slf4j
+public class HanlpHelper {
+
+    public static final String FILE_SPILT = File.separator;
+    public static final String SPACE_SPILT = "#";
+    private static volatile DynamicCustomDictionary CustomDictionary;
+    private static volatile Segment segment;
+
+    static {
+        // reset hanlp config
+        try {
+            resetHanlpConfig();
+        } catch (FileNotFoundException e) {
+            log.error("resetHanlpConfig error", e);
+        }
+    }
+
+    public static Segment getSegment() {
+        if (segment == null) {
+            synchronized (HanlpHelper.class) {
+                if (segment == null) {
+                    segment = HanLP.newSegment()
+                            .enableIndexMode(true).enableIndexMode(4)
+                            .enableCustomDictionary(true).enableCustomDictionaryForcing(true).enableOffset(true)
+                            .enableJapaneseNameRecognize(false).enableNameRecognize(false)
+                            .enableAllNamedEntityRecognize(false)
+                            .enableJapaneseNameRecognize(false).enableNumberQuantifierRecognize(false)
+                            .enablePlaceRecognize(false)
+                            .enableOrganizationRecognize(false).enableCustomDictionary(getDynamicCustomDictionary());
+                }
+            }
+        }
+        return segment;
+    }
+
+    public static DynamicCustomDictionary getDynamicCustomDictionary() {
+        if (CustomDictionary == null) {
+            synchronized (HanlpHelper.class) {
+                if (CustomDictionary == null) {
+                    CustomDictionary = new MultiCustomDictionary(CustomDictionaryPath);
+                }
+            }
+        }
+        return CustomDictionary;
+    }
+
+    /***
+     * reload custom dictionary
+     */
+    public static boolean reloadCustomDictionary() throws IOException {
+
+        log.info("reloadCustomDictionary start");
+
+        final long startTime = System.currentTimeMillis();
+
+        if (CustomDictionaryPath == null || CustomDictionaryPath.length == 0) {
+            return false;
+        }
+        if (HanLP.Config.IOAdapter instanceof HadoopFileIOAdapter) {
+            // 1.delete hdfs file
+            HdfsFileHelper.deleteCacheFile(HanLP.Config.CustomDictionaryPath);
+            // 2.query txt files，update CustomDictionaryPath
+            HdfsFileHelper.resetCustomPath(getDynamicCustomDictionary());
+        } else {
+            FileHelper.deleteCacheFile(HanLP.Config.CustomDictionaryPath);
+            FileHelper.resetCustomPath(getDynamicCustomDictionary());
+        }
+        // 3.clear trie
+        SearchService.clear();
+
+        boolean reload = getDynamicCustomDictionary().reload();
+        log.info("reloadCustomDictionary end ,cost:{},reload:{}", System.currentTimeMillis() - startTime, reload);
+        return reload;
+    }
+
+    private static void resetHanlpConfig() throws FileNotFoundException {
+        if (HanLP.Config.IOAdapter instanceof HadoopFileIOAdapter) {
+            return;
+        }
+        String hanlpPropertiesPath = getHanlpPropertiesPath();
+
+        HanLP.Config.CustomDictionaryPath = Arrays.stream(HanLP.Config.CustomDictionaryPath)
+                .map(path -> hanlpPropertiesPath + FILE_SPILT + path)
+                .toArray(String[]::new);
+        log.info("hanlpPropertiesPath:{},CustomDictionaryPath:{}", hanlpPropertiesPath,
+                HanLP.Config.CustomDictionaryPath);
+
+        HanLP.Config.CoreDictionaryPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.BiGramDictionaryPath;
+        HanLP.Config.CoreDictionaryTransformMatrixDictionaryPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.CoreDictionaryTransformMatrixDictionaryPath;
+        HanLP.Config.BiGramDictionaryPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.BiGramDictionaryPath;
+        HanLP.Config.CoreStopWordDictionaryPath =
+                hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CoreStopWordDictionaryPath;
+        HanLP.Config.CoreSynonymDictionaryDictionaryPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.CoreSynonymDictionaryDictionaryPath;
+        HanLP.Config.PersonDictionaryPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PersonDictionaryPath;
+        HanLP.Config.PersonDictionaryTrPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PersonDictionaryTrPath;
+
+        HanLP.Config.PinyinDictionaryPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PinyinDictionaryPath;
+        HanLP.Config.TranslatedPersonDictionaryPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.TranslatedPersonDictionaryPath;
+        HanLP.Config.JapanesePersonDictionaryPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.JapanesePersonDictionaryPath;
+        HanLP.Config.PlaceDictionaryPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PlaceDictionaryPath;
+        HanLP.Config.PlaceDictionaryTrPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PlaceDictionaryTrPath;
+        HanLP.Config.OrganizationDictionaryPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.OrganizationDictionaryPath;
+        HanLP.Config.OrganizationDictionaryTrPath = hanlpPropertiesPath + FILE_SPILT
+                + HanLP.Config.OrganizationDictionaryTrPath;
+        HanLP.Config.CharTypePath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CharTypePath;
+        HanLP.Config.CharTablePath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CharTablePath;
+        HanLP.Config.PartOfSpeechTagDictionary =
+                hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PartOfSpeechTagDictionary;
+        HanLP.Config.WordNatureModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.WordNatureModelPath;
+        HanLP.Config.MaxEntModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.MaxEntModelPath;
+        HanLP.Config.NNParserModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.NNParserModelPath;
+        HanLP.Config.PerceptronParserModelPath =
+                hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PerceptronParserModelPath;
+        HanLP.Config.CRFSegmentModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CRFSegmentModelPath;
+        HanLP.Config.HMMSegmentModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.HMMSegmentModelPath;
+        HanLP.Config.CRFCWSModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CRFCWSModelPath;
+        HanLP.Config.CRFPOSModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CRFPOSModelPath;
+        HanLP.Config.CRFNERModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.CRFNERModelPath;
+        HanLP.Config.PerceptronCWSModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PerceptronCWSModelPath;
+        HanLP.Config.PerceptronPOSModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PerceptronPOSModelPath;
+        HanLP.Config.PerceptronNERModelPath = hanlpPropertiesPath + FILE_SPILT + HanLP.Config.PerceptronNERModelPath;
+    }
+
+    public static String getHanlpPropertiesPath() throws FileNotFoundException {
+        return ResourceUtils.getFile("classpath:hanlp.properties").getParent();
+    }
+
+    public static boolean addToCustomDictionary(DictWord dictWord) {
+        log.info("dictWord:{}", dictWord);
+        return getDynamicCustomDictionary().insert(dictWord.getWord(), dictWord.getNatureWithFrequency());
+    }
+
+    public static void removeFromCustomDictionary(DictWord dictWord) {
+        log.info("dictWord:{}", dictWord);
+        CoreDictionary.Attribute attribute = getDynamicCustomDictionary().get(dictWord.getWord());
+        if (attribute == null) {
+            return;
+        }
+        log.info("get attribute:{}", attribute);
+        getDynamicCustomDictionary().remove(dictWord.getWord());
+        StringBuilder sb = new StringBuilder();
+        List<Nature> natureList = new ArrayList<>();
+        for (int i = 0; i < attribute.nature.length; i++) {
+            if (!attribute.nature[i].toString().equals(dictWord.getNature())) {
+                sb.append(attribute.nature[i].toString() + " ");
+                sb.append(attribute.frequency[i] + " ");
+                natureList.add((attribute.nature[i]));
+            }
+        }
+        String natureWithFrequency = sb.toString();
+        int len = natureWithFrequency.length();
+        log.info("filtered natureWithFrequency:{}", natureWithFrequency);
+        if (StringUtils.isNotBlank(natureWithFrequency)) {
+            getDynamicCustomDictionary().add(dictWord.getWord(), natureWithFrequency.substring(0, len - 1));
+        }
+        SearchService.remove(dictWord, natureList.toArray(new Nature[0]));
+    }
+
+    public static <T extends MapResult> void transLetterOriginal(List<T> mapResults) {
+        if (CollectionUtils.isEmpty(mapResults)) {
+            return;
+        }
+        for (T mapResult : mapResults) {
+            if (MultiCustomDictionary.isLowerLetter(mapResult.getName())) {
+                if (CustomDictionary.contains(mapResult.getName())) {
+                    CoreDictionary.Attribute attribute = CustomDictionary.get(mapResult.getName());
+                    if (attribute != null && attribute.original != null) {
+                        mapResult.setName(attribute.original);
+                    }
+                }
+            }
+        }
+    }
+
+    public static List<com.tencent.supersonic.headless.api.pojo.response.S2Term> getTerms(String text) {
+        return getSegment().seg(text.toLowerCase()).stream()
+                .filter(term -> term.getNature().startsWith(DictWordType.NATURE_SPILT))
+                .map(term -> transform2ApiTerm(term))
+                .collect(Collectors.toList());
+    }
+
+    public static S2Term transform2ApiTerm(Term term) {
+        S2Term knowledgeTerm = new S2Term();
+        BeanUtils.copyProperties(term, knowledgeTerm);
+        knowledgeTerm.setFrequency(term.getFrequency());
+        return knowledgeTerm;
+    }
+
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/HdfsFileHelper.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/HdfsFileHelper.java
@@ -0,0 +1,85 @@
+package com.tencent.supersonic.headless.core.knowledge.helper;
+
+import static com.hankcs.hanlp.HanLP.Config.CustomDictionaryPath;
+
+import com.hankcs.hanlp.HanLP;
+import com.hankcs.hanlp.dictionary.DynamicCustomDictionary;
+import com.hankcs.hanlp.utility.Predefine;
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+
+/**
+ * Hdfs File Helper
+ */
+@Slf4j
+public class HdfsFileHelper {
+
+    /***
+     * delete cache file
+     * @param path
+     * @throws IOException
+     */
+    public static void deleteCacheFile(String[] path) throws IOException {
+        FileSystem fs = FileSystem.get(URI.create(path[0]), new Configuration());
+        String cacheFilePath = path[0] + Predefine.BIN_EXT;
+        log.info("delete cache file:{}", cacheFilePath);
+        try {
+            fs.delete(new Path(cacheFilePath), false);
+        } catch (Exception e) {
+            log.error("delete:" + cacheFilePath, e);
+        }
+        int customBase = cacheFilePath.lastIndexOf(FileHelper.FILE_SPILT);
+        String customPath = cacheFilePath.substring(0, customBase) + FileHelper.FILE_SPILT + "*.bin";
+        List<String> fileList = getFileList(fs, new Path(customPath));
+        for (String file : fileList) {
+            try {
+                fs.delete(new Path(file), false);
+                log.info("delete cache file:{}", file);
+            } catch (Exception e) {
+                log.error("delete " + file, e);
+            }
+        }
+        log.info("fileList:{}", fileList);
+    }
+
+    /**
+     * reset path
+     *
+     * @param customDictionary
+     * @throws IOException
+     */
+    public static void resetCustomPath(DynamicCustomDictionary customDictionary) throws IOException {
+        String[] path = HanLP.Config.CustomDictionaryPath;
+        FileSystem fs = FileSystem.get(URI.create(path[0]), new Configuration());
+        String cacheFilePath = path[0] + Predefine.BIN_EXT;
+        int customBase = cacheFilePath.lastIndexOf(FileHelper.FILE_SPILT);
+        String customPath = cacheFilePath.substring(0, customBase) + FileHelper.FILE_SPILT + "*.txt";
+        log.info("customPath:{}", customPath);
+        List<String> fileList = getFileList(fs, new Path(customPath));
+        log.info("CustomDictionaryPath:{}", fileList);
+        CustomDictionaryPath = fileList.toArray(new String[0]);
+        customDictionary.path = (CustomDictionaryPath == null || CustomDictionaryPath.length == 0) ? path
+                : CustomDictionaryPath;
+        if (CustomDictionaryPath == null || CustomDictionaryPath.length == 0) {
+            CustomDictionaryPath = path;
+        }
+    }
+
+    public static List<String> getFileList(FileSystem fs, Path folderPath) throws IOException {
+        List<String> paths = new ArrayList();
+        FileStatus[] fileStatuses = fs.globStatus(folderPath);
+        for (int i = 0; i < fileStatuses.length; i++) {
+            FileStatus fileStatus = fileStatuses[i];
+            paths.add(fileStatus.getPath().toString());
+        }
+        return paths;
+    }
+}
--- a/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/NatureHelper.java
+++ b/headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/NatureHelper.java
@@ -0,0 +1,180 @@
+package com.tencent.supersonic.headless.core.knowledge.helper;
+
+import com.hankcs.hanlp.corpus.tag.Nature;
+import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
+import com.tencent.supersonic.headless.api.pojo.response.S2Term;
+import com.tencent.supersonic.headless.core.knowledge.ViewInfoStat;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * nature parse helper
+ */
+@Slf4j
+public class NatureHelper {
+
+    public static SchemaElementType convertToElementType(String nature) {
+        DictWordType dictWordType = DictWordType.getNatureType(nature);
+        if (Objects.isNull(dictWordType)) {
+            return null;
+        }
+        SchemaElementType result = null;
+        switch (dictWordType) {
+            case METRIC:
+                result = SchemaElementType.METRIC;
+                break;
+            case DIMENSION:
+                result = SchemaElementType.DIMENSION;
+                break;
+            case ENTITY:
+                result = SchemaElementType.ENTITY;
+                break;
+            case VIEW:
+                result = SchemaElementType.VIEW;
+                break;
+            case VALUE:
+                result = SchemaElementType.VALUE;
+                break;
+            case TAG:
+                result = SchemaElementType.TAG;
+                break;
+            default:
+                break;
+        }
+        return result;
+    }
+
+    private static boolean isViewOrEntity(S2Term term, Integer model) {
+        return (DictWordType.NATURE_SPILT + model).equals(term.nature.toString()) || term.nature.toString()
+                .endsWith(DictWordType.ENTITY.getType());
+    }
+
+    public static Integer getViewByNature(Nature nature) {
+        if (nature.startsWith(DictWordType.NATURE_SPILT)) {
+            String[] dimensionValues = nature.toString().split(DictWordType.NATURE_SPILT);
+            if (StringUtils.isNumeric(dimensionValues[1])) {
+                return Integer.valueOf(dimensionValues[1]);
+            }
+        }
+        return 0;
+    }
+
+    public static Long getViewId(String nature) {
+        try {
+            String[] split = nature.split(DictWordType.NATURE_SPILT);
+            if (split.length <= 1) {
+                return null;
+            }
+            return Long.valueOf(split[1]);
+        } catch (NumberFormatException e) {
+            log.error("", e);
+        }
+        return null;
+    }
+
+    public static boolean isDimensionValueViewId(String nature) {
+        if (StringUtils.isEmpty(nature)) {
+            return false;
+        }
+        if (!nature.startsWith(DictWordType.NATURE_SPILT)) {
+            return false;
+        }
+        String[] split = nature.split(DictWordType.NATURE_SPILT);
+        if (split.length <= 1) {
+            return false;
+        }
+        return !nature.endsWith(DictWordType.METRIC.getType()) && !nature.endsWith(DictWordType.DIMENSION.getType())
+                && StringUtils.isNumeric(split[1]);
+    }
+
+    public static ViewInfoStat getViewStat(List<S2Term> terms) {
+        return ViewInfoStat.builder()
+                .viewCount(getViewCount(terms))
+                .dimensionViewCount(getDimensionCount(terms))
+                .metricViewCount(getMetricCount(terms))
+                .dimensionValueViewCount(getDimensionValueCount(terms))
+                .build();
+    }
+
+    private static long getViewCount(List<S2Term> terms) {
+        return terms.stream().filter(term -> isViewOrEntity(term, getViewByNature(term.nature))).count();
+    }
+
+    private static long getDimensionValueCount(List<S2Term> terms) {
+        return terms.stream().filter(term -> isDimensionValueViewId(term.nature.toString())).count();
+    }
+
+    private static long getDimensionCount(List<S2Term> terms) {
+        return terms.stream().filter(term -> term.nature.startsWith(DictWordType.NATURE_SPILT) && term.nature.toString()
+                .endsWith(DictWordType.DIMENSION.getType())).count();
+    }
+
+    private static long getMetricCount(List<S2Term> terms) {
+        return terms.stream().filter(term -> term.nature.startsWith(DictWordType.NATURE_SPILT) && term.nature.toString()
+                .endsWith(DictWordType.METRIC.getType())).count();
+    }
+
+    /**
+     * Get the number of types of class parts of speech
+     * modelId -> (nature , natureCount)
+     *
+     * @param terms
+     * @return
+     */
+    public static Map<Long, Map<DictWordType, Integer>> getViewToNatureStat(List<S2Term> terms) {
+        Map<Long, Map<DictWordType, Integer>> modelToNature = new HashMap<>();
+        terms.stream().filter(
+                term -> term.nature.startsWith(DictWordType.NATURE_SPILT)
+        ).forEach(term -> {
+            DictWordType dictWordType = DictWordType.getNatureType(String.valueOf(term.nature));
+            Long model = getViewId(String.valueOf(term.nature));
+
+            Map<DictWordType, Integer> natureTypeMap = new HashMap<>();
+            natureTypeMap.put(dictWordType, 1);
+
+            Map<DictWordType, Integer> original = modelToNature.get(model);
+            if (Objects.isNull(original)) {
+                modelToNature.put(model, natureTypeMap);
+            } else {
+                Integer count = original.get(dictWordType);
+                if (Objects.isNull(count)) {
+                    count = 1;
+                } else {
+                    count = count + 1;
+                }
+                original.put(dictWordType, count);
+            }
+        });
+        return modelToNature;
+    }
+
+    public static List<Long> selectPossibleViews(List<S2Term> terms) {
+        Map<Long, Map<DictWordType, Integer>> modelToNatureStat = getViewToNatureStat(terms);
+        Integer maxViewTypeSize = modelToNatureStat.entrySet().stream()
+                .max(Comparator.comparingInt(o -> o.getValue().size())).map(entry -> entry.getValue().size())
+                .orElse(null);
+        if (Objects.isNull(maxViewTypeSize) || maxViewTypeSize == 0) {
+            return new ArrayList<>();
+        }
+        return modelToNatureStat.entrySet().stream().filter(entry -> entry.getValue().size() == maxViewTypeSize)
+                .map(entry -> entry.getKey()).collect(Collectors.toList());
+    }
+
+    public static Long getElementID(String nature) {
+        String[] split = nature.split(DictWordType.NATURE_SPILT);
+        if (split.length >= 3) {
+            return Long.valueOf(split[2]);
+        }
+        return 0L;
+    }
+
+}
--- a/headless/core/src/main/resources/META-INF/spring.factories
+++ b/headless/core/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,2 @@
+com.tencent.supersonic.headless.core.file.FileHandler=\
+    com.tencent.supersonic.headless.core.file.FileHandlerImpl