(fix)[solver]: language (#19)

* fix builder init

* fix language

* fix req

KAG_VERSION

@@ -1 +1 @@
-0.5-beta1
+0.5.2-beta1

kag/__init__.py

@@ -202,7 +202,7 @@
 
 
 __package_name__ = "openspg-kag"
-__version__ = "0.5-beta1"
+__version__ = "0.5.2-beta1"
 
 from kag.common.env import init_env
 

kag/solver/common/base.py

@@ -2,7 +2,6 @@ import os
 from string import Template
 
 from knext.project.client import ProjectClient
-
 from kag.common.llm.client import LLMClient
 import logging
 logger = logging.getLogger(__name__)
@@ -108,10 +107,11 @@ class KagBaseModule(object):
         """
         self.host_addr = kwargs.get("KAG_PROJECT_HOST_ADDR") or os.getenv("KAG_PROJECT_HOST_ADDR")
         self.project_id = kwargs.get("KAG_PROJECT_ID") or os.getenv("KAG_PROJECT_ID")
+        self.config = ProjectClient().get_config(self.project_id)
 
         self._init_llm()
         self.biz_scene = kwargs.get("KAG_PROMPT_BIZ_SCENE") or os.getenv("KAG_PROMPT_BIZ_SCENE", "default")
-        self.language = kwargs.get("KAG_PROMPT_LANGUAGE") or os.getenv("KAG_PROMPT_LANGUAGE", "en")
+        self.language = self.config.get("prompt").get("language") or os.getenv("KAG_PROMPT_LANGUAGE", "en")
 
 
     def _init_llm(self):

kag/solver/logic/core_modules/lf_executor.py

@@ -92,13 +92,13 @@ class LogicExecutor:
         # Initialize executors for different operations.
         self.retrieval_executor = RetrievalExecutor(query, self.kg_graph, self.schema, self.kg_retriever,
                                                     self.el,
-                                                    self.dsl_runner, self.debug_info, text_similarity)
-        self.deduce_executor = DeduceExecutor(query, self.kg_graph, self.schema, self.op_runner, self.debug_info)
-        self.sort_executor = SortExecutor(query, self.kg_graph, self.schema, self.debug_info)
-        self.math_executor = MathExecutor(query, self.kg_graph, self.schema, self.debug_info)
+                                                    self.dsl_runner, self.debug_info, text_similarity,KAG_PROJECT_ID = self.project_id)
+        self.deduce_executor = DeduceExecutor(query, self.kg_graph, self.schema, self.op_runner, self.debug_info, KAG_PROJECT_ID = self.project_id)
+        self.sort_executor = SortExecutor(query, self.kg_graph, self.schema, self.debug_info, KAG_PROJECT_ID = self.project_id)
+        self.math_executor = MathExecutor(query, self.kg_graph, self.schema, self.debug_info, KAG_PROJECT_ID = self.project_id)
         self.output_executor = OutputExecutor(query, self.kg_graph, self.schema, self.el,
                                               self.dsl_runner,
-                                              self.retrieval_executor.query_one_graph_cache, self.debug_info)
+                                              self.retrieval_executor.query_one_graph_cache, self.debug_info, KAG_PROJECT_ID = self.project_id)
 
         self.with_sub_answer = os.getenv("KAG_QA_WITH_SUB_ANSWER", True)
 

kag/solver/logic/core_modules/op_executor/op_deduce/deduce_executor.py

@@ -14,8 +14,10 @@ from kag.solver.logic.core_modules.rule_runner.rule_runner import OpRunner
 
 
 class DeduceExecutor(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, rule_runner: OpRunner, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, rule_runner: OpRunner, debug_info: dict,
+                 **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
+        self.KAG_PROJECT_ID = kwargs.get('KAG_PROJECT_ID')
         self.rule_runner = rule_runner
         self.op_register_map = {
             'verify': self.rule_runner.run_verify_op,
@@ -25,10 +27,10 @@ class DeduceExecutor(OpExecutor):
 
     def _deduce_call(self, node: DeduceNode, req_id: str, param: dict) -> list:
         op_mapping = {
-            'choice': ChoiceOp(self.nl_query, self.kg_graph, self.schema, self.debug_info),
-            'multiChoice': MultiChoiceOp(self.nl_query, self.kg_graph, self.schema, self.debug_info),
-            'entailment': EntailmentOp(self.nl_query, self.kg_graph, self.schema, self.debug_info),
-            'judgement': JudgementOp(self.nl_query, self.kg_graph, self.schema, self.debug_info)
+            'choice': ChoiceOp(self.nl_query, self.kg_graph, self.schema, self.debug_info,KAG_PROJECT_ID = self.KAG_PROJECT_ID),
+            'multiChoice': MultiChoiceOp(self.nl_query, self.kg_graph, self.schema, self.debug_info,KAG_PROJECT_ID = self.KAG_PROJECT_ID),
+            'entailment': EntailmentOp(self.nl_query, self.kg_graph, self.schema, self.debug_info,KAG_PROJECT_ID = self.KAG_PROJECT_ID),
+            'judgement': JudgementOp(self.nl_query, self.kg_graph, self.schema, self.debug_info,KAG_PROJECT_ID = self.KAG_PROJECT_ID)
         }
         result = []
         for op in node.deduce_ops:

kag/solver/logic/core_modules/op_executor/op_deduce/module/choice.py

@@ -6,8 +6,8 @@ from kag.solver.logic.core_modules.op_executor.op_executor import OpExecutor
 
 
 class ChoiceOp(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.prompt = PromptOp.load(self.biz_scene, "deduce_choice")(
             language=self.language
         )

kag/solver/logic/core_modules/op_executor/op_deduce/module/entailment.py

@@ -6,8 +6,8 @@ from kag.solver.logic.core_modules.op_executor.op_executor import OpExecutor
 
 
 class EntailmentOp(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.prompt = PromptOp.load(self.biz_scene, "deduce_entail")(
             language=self.language
         )

kag/solver/logic/core_modules/op_executor/op_deduce/module/judgement.py

@@ -6,8 +6,8 @@ from kag.solver.logic.core_modules.op_executor.op_executor import OpExecutor
 
 
 class JudgementOp(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.prompt = PromptOp.load(self.biz_scene, "deduce_judge")(
             language=self.language
         )

kag/solver/logic/core_modules/op_executor/op_deduce/module/multi_choice.py

@@ -6,8 +6,8 @@ from kag.solver.logic.core_modules.op_executor.op_executor import OpExecutor
 
 
 class MultiChoiceOp(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.prompt = PromptOp.load(self.biz_scene, "deduce_multi_choice")(
             language=self.language
         )

kag/solver/logic/core_modules/op_executor/op_executor.py

@@ -13,7 +13,7 @@ class OpExecutor(KagBaseModule, ABC):
 
     Each subclass must implement the execution and judgment functions.
     """
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
         """
         Initializes the operator executor with necessary components.
 
@@ -23,7 +23,7 @@ class OpExecutor(KagBaseModule, ABC):
             schema (SchemaUtils): Semantic structure definition to assist in the parsing process.
             debug_info (dict): Debug information dictionary to record debugging information during parsing.
         """
-        super().__init__()
+        super().__init__(**kwargs)
         self.kg_graph = kg_graph
         self.schema = schema
         self.nl_query = nl_query

kag/solver/logic/core_modules/op_executor/op_math/math_executor.py

@@ -8,8 +8,8 @@ from kag.solver.logic.core_modules.parser.logic_node_parser import CountNode, Su
 
 
 class MathExecutor(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
 
     def is_this_op(self, logic_node: LogicNode) -> bool:
         return isinstance(logic_node, (CountNode, SumNode))

kag/solver/logic/core_modules/op_executor/op_output/module/get_executor.py

@@ -9,8 +9,8 @@ from kag.solver.logic.core_modules.retriver.graph_retriver.dsl_executor import D
 
 class GetExecutor(OpExecutor):
     def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, el: EntityLinkerBase,
-                 dsl_runner: DslRunner, cached_map: dict, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+                 dsl_runner: DslRunner, cached_map: dict, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
 
         self.el = el
         self.dsl_runner = dsl_runner

kag/solver/logic/core_modules/op_executor/op_output/output_executor.py

@@ -11,10 +11,11 @@ from kag.solver.logic.core_modules.retriver.graph_retriver.dsl_executor import D
 
 
 class OutputExecutor(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, el: EntityLinkerBase, dsl_runner: DslRunner, cached_map: dict, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, el: EntityLinkerBase, dsl_runner: DslRunner, cached_map: dict, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
+        self.KAG_PROJECT_ID = kwargs.get('KAG_PROJECT_ID')
         self.op_register_map = {
-            'get': GetExecutor(nl_query, kg_graph, schema, el, dsl_runner, cached_map, self.debug_info)
+            'get': GetExecutor(nl_query, kg_graph, schema, el, dsl_runner, cached_map, self.debug_info,KAG_PROJECT_ID = kwargs.get('KAG_PROJECT_ID'))
         }
 
     def is_this_op(self, logic_node: LogicNode) -> bool:

kag/solver/logic/core_modules/op_executor/op_retrieval/module/get_spo_executor.py

@@ -25,7 +25,7 @@ class GetSPOExecutor(OpExecutor):
     """
     def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, retrieval_spo: KGRetrieverABC,
                  el: EntityLinkerBase,
-                 dsl_runner: DslRunner, query_one_graph_cache: dict, debug_info: dict, text_similarity: TextSimilarity=None):
+                 dsl_runner: DslRunner, query_one_graph_cache: dict, debug_info: dict, text_similarity: TextSimilarity=None,**kwargs):
         """
         Initializes the GetSPOExecutor with necessary components.
 
@@ -39,7 +39,7 @@ class GetSPOExecutor(OpExecutor):
             query_one_graph_cache (dict): Cache for storing results of one-hop graph queries.
             debug_info (dict): Debug information dictionary to record debugging information during parsing.
         """
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.retrieval_spo = retrieval_spo
         self.dsl_runner = dsl_runner
         self.query_one_graph_cache = query_one_graph_cache

kag/solver/logic/core_modules/op_executor/op_retrieval/module/search_s.py

@@ -5,8 +5,8 @@ from kag.solver.logic.core_modules.op_executor.op_executor import OpExecutor
 
 
 class SearchS(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
 
     def executor(self, logic_node: LogicNode, req_id: str, param: dict) -> KgGraph:
         raise NotImplementedError("search s not impl")

kag/solver/logic/core_modules/op_executor/op_retrieval/retrieval_executor.py

@@ -17,12 +17,12 @@ logger = logging.getLogger()
 
 class RetrievalExecutor(OpExecutor):
     def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, retrieval_spo: KGRetrieverABC, el: EntityLinkerBase,
-                 dsl_runner: DslRunner, debug_info: dict, text_similarity: TextSimilarity=None):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+                 dsl_runner: DslRunner, debug_info: dict, text_similarity: TextSimilarity=None,**kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
         self.query_one_graph_cache = {}
         self.op_register_map = {
-            'get_spo': GetSPOExecutor(nl_query, kg_graph, schema, retrieval_spo, el, dsl_runner, self.query_one_graph_cache, self.debug_info, text_similarity),
-            'search_s': SearchS(nl_query, kg_graph, schema, self.debug_info)
+            'get_spo': GetSPOExecutor(nl_query, kg_graph, schema, retrieval_spo, el, dsl_runner, self.query_one_graph_cache, self.debug_info, text_similarity,KAG_PROJECT_ID = kwargs.get('KAG_PROJECT_ID')),
+            'search_s': SearchS(nl_query, kg_graph, schema, self.debug_info,KAG_PROJECT_ID = kwargs.get('KAG_PROJECT_ID'))
         }
 
     def is_this_op(self, logic_node: LogicNode) -> bool:

kag/solver/logic/core_modules/op_executor/op_sort/sort_executor.py

@@ -8,8 +8,8 @@ from kag.solver.logic.core_modules.parser.logic_node_parser import SortNode
 
 
 class SortExecutor(OpExecutor):
-    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict):
-        super().__init__(nl_query, kg_graph, schema, debug_info)
+    def __init__(self, nl_query: str, kg_graph: KgGraph, schema: SchemaUtils, debug_info: dict, **kwargs):
+        super().__init__(nl_query, kg_graph, schema, debug_info, **kwargs)
 
     def is_this_op(self, logic_node: LogicNode) -> bool:
         return isinstance(logic_node, SortNode)

requirements.txt

@@ -37,5 +37,5 @@ openai
 python-docx
 charset_normalizer==3.3.2
 pdfminer.six==20231228
-openspg-knext==0.5b1
+openspg-knext==0.5.2b1
 ollama