flowllm 0.1.0__py3-none-any.whl

llmflow/op/mock_op.py

@@ -0,0 +1,40 @@
+import time
+
+from loguru import logger
+
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+
+
+@OP_REGISTRY.register()
+class Mock1Op(BaseOp):
+    def execute(self):
+        time.sleep(1)
+        a: int = self.op_params["a"]
+        b: str = self.op_params["b"]
+        logger.info(f"enter class={self.simple_name}. a={a} b={b}")
+
+
+@OP_REGISTRY.register()
+class Mock2Op(Mock1Op):
+    ...
+
+
+@OP_REGISTRY.register()
+class Mock3Op(Mock1Op):
+    ...
+
+
+@OP_REGISTRY.register()
+class Mock4Op(Mock1Op):
+    ...
+
+
+@OP_REGISTRY.register()
+class Mock5Op(Mock1Op):
+    ...
+
+
+@OP_REGISTRY.register()
+class Mock6Op(Mock1Op):
+    ...

llmflow/op/prompt_mixin.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+import yaml
+from loguru import logger
+
+
+class PromptMixin:
+
+    def __init__(self):
+        self._prompt_dict: dict = {}
+
+    def load_prompt_by_file(self, prompt_file_path: Path | str = None):
+        if prompt_file_path is None:
+            return
+
+        if isinstance(prompt_file_path, str):
+            prompt_file_path = Path(prompt_file_path)
+
+        if not prompt_file_path.exists():
+            return
+
+        with prompt_file_path.open() as f:
+            prompt_dict = yaml.load(f, yaml.FullLoader)
+            self.load_prompt_dict(prompt_dict)
+
+    def load_prompt_dict(self, prompt_dict: dict = None):
+        if not prompt_dict:
+            return
+
+        for key, value in prompt_dict.items():
+            if isinstance(value, str):
+                if key in self._prompt_dict:
+                    self._prompt_dict[key] = value
+                    logger.warning(f"prompt_dict key={key} overwrite!")
+
+                else:
+                    self._prompt_dict[key] = value
+                    logger.info(f"add prompt_dict key={key}")
+
+    def prompt_format(self, prompt_name: str, **kwargs):
+        prompt = self._prompt_dict[prompt_name]
+
+        flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)}
+        other_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)}
+
+        if flag_kwargs:
+            split_prompt = []
+            for line in prompt.strip().split("\n"):
+                hit = False
+                hit_flag = True
+                for key, flag in kwargs.items():
+                    if not line.startswith(f"[{key}]"):
+                        continue
+
+                    else:
+                        hit = True
+                        hit_flag = flag
+                        line = line.strip(f"[{key}]")
+                        break
+
+                if not hit:
+                    split_prompt.append(line)
+                elif hit_flag:
+                    split_prompt.append(line)
+
+            prompt = "\n".join(split_prompt)
+
+        if other_kwargs:
+            prompt = prompt.format(**other_kwargs)
+
+        return prompt
+
+    def get_prompt(self, key: str):
+        return self._prompt_dict[key]

llmflow/op/react/react_v1_op.py

@@ -0,0 +1,88 @@
+import datetime
+import time
+from typing import List, Dict
+
+from loguru import logger
+
+from llmflow.enumeration.role import Role
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+from llmflow.schema.message import Message
+from llmflow.schema.request import AgentRequest
+from llmflow.schema.response import AgentResponse
+from llmflow.tool import TOOL_REGISTRY
+from llmflow.tool.base_tool import BaseTool
+
+
+@OP_REGISTRY.register()
+class ReactV1Op(BaseOp):
+    current_path: str = __file__
+
+    def execute(self):
+        request: AgentRequest = self.context.request
+        response: AgentResponse = self.context.response
+
+        max_steps: int = int(self.op_params.get("max_steps", 10))
+        # dashscope_search_tool tavily_search_tool
+        tool_names = self.op_params.get("tool_names", "code_tool,tavily_search_tool,terminate_tool")
+        tools: List[BaseTool] = [TOOL_REGISTRY[x.strip()]() for x in tool_names.split(",") if x]
+        tool_dict: Dict[str, BaseTool] = {x.name: x for x in tools}
+        now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        has_terminate_tool = False
+
+        user_prompt = self.prompt_format(prompt_name="role_prompt",
+                                         time=now_time,
+                                         tools=",".join([x.name for x in tools]),
+                                         query=request.query)
+        messages: List[Message] = [Message(role=Role.USER, content=user_prompt)]
+        logger.info(f"step.0 user_prompt={user_prompt}")
+
+        for i in range(max_steps):
+            if has_terminate_tool:
+                assistant_message: Message = self.llm.chat(messages)
+            else:
+                assistant_message: Message = self.llm.chat(messages, tools=tools)
+
+            messages.append(assistant_message)
+            logger.info(f"assistant.{i}.reasoning_content={assistant_message.reasoning_content}\n"
+                        f"content={assistant_message.content}\n"
+                        f"tool.size={len(assistant_message.tool_calls)}")
+
+            if has_terminate_tool:
+                break
+
+            for tool in assistant_message.tool_calls:
+                if tool.name == "terminate":
+                    has_terminate_tool = True
+                    logger.info(f"step={i} find terminate tool, break.")
+                    break
+
+            if not has_terminate_tool and not assistant_message.tool_calls:
+                logger.warning(f"【bugfix】step={i} no tools, break.")
+                has_terminate_tool = True
+
+            for j, tool_call in enumerate(assistant_message.tool_calls):
+                logger.info(f"submit step={i} tool_calls.name={tool_call.name} argument_dict={tool_call.argument_dict}")
+
+                if tool_call.name not in tool_dict:
+                    continue
+
+                self.submit_task(tool_dict[tool_call.name].execute, **tool_call.argument_dict)
+                time.sleep(1)
+
+            if not has_terminate_tool:
+                user_content_list = []
+                for tool_result, tool_call in zip(self.join_task(), assistant_message.tool_calls):
+                    logger.info(f"submit step={i} tool_calls.name={tool_call.name} tool_result={tool_result}")
+                    assert isinstance(tool_result, str)
+                    user_content_list.append(f"<tool_response>\n{tool_result}\n</tool_response>")
+                user_content_list.append(self.prompt_format(prompt_name="next_prompt"))
+                assistant_message.tool_calls.clear()
+                messages.append(Message(role=Role.USER, content="\n".join(user_content_list)))
+
+            else:
+                assistant_message.tool_calls.clear()
+                messages.append(Message(role=Role.USER, content=self.prompt_format(prompt_name="final_prompt")))
+
+        response.messages = messages
+        response.answer = response.messages[-1].content

llmflow/op/react/react_v1_prompt.yaml

@@ -0,0 +1,28 @@
+role_prompt: |
+  You are a helpful assistant.
+  The current time is {time}.
+  Please proactively choose the most suitable tool or combination of tools based on the user's question, including {tools} etc.
+  Please first think about how to break down the problem into subtasks, what tools and parameters should be used for each subtask, and finally provide the tool call name and parameters.
+  Try calling the same tool multiple times with different parameters to obtain information from various perspectives.
+  Please determine the response language based on the language of the user's question.
+  
+  {query}
+
+# write a complete and rigorous report to answer user's questions based on the context.
+next_prompt: |
+  Think based on the current content and the user's question: Is the current context sufficient to answer the user's question?  
+  
+  - If the current context is not sufficient to answer the user's question, consider what information is missing. 
+    Re-plan and think about how to break down the missing information into subtasks. 
+    For each subtask, determine what tools and parameters should be used for the query.
+    Please first provide the reasoning process, then give the tool call name and parameters.
+  
+  - If the current context is sufficient to answer the user's question, use the **terminate** tool.
+
+#   Please determine the response language based on the language of the user's question.
+final_prompt: |
+  Please integrate the context and provide a complete answer to the user's question.
+
+  # User's Question
+  {query}
+

llmflow/op/vector_store/__init__.py

@@ -0,0 +1,13 @@
+"""
+1. retrieve:
+    search: query(context), workspace_id(request), top_k(request)
+2. summary:
+    insert: nodes(context), workspace_id(request)
+    delete: ids(context), workspace_id(request)
+    search: query(context), workspace_id(request), top_k(request.config.op)
+3. vector:
+    dump: workspace_id(request), path(str), max_size(int)
+    load: workspace_id(request), path(str)
+    delete: workspace_id(request)
+    copy: source_id, target_id, max_size(int)
+"""

llmflow/op/vector_store/recall_vector_store_op.py

@@ -0,0 +1,48 @@
+from typing import List
+
+from loguru import logger
+
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+from llmflow.schema.experience import BaseExperience, vector_node_to_experience
+from llmflow.schema.request import RetrieverRequest
+from llmflow.schema.response import RetrieverResponse
+from llmflow.schema.vector_node import VectorNode
+
+
+@OP_REGISTRY.register()
+class RecallVectorStoreOp(BaseOp):
+    SEARCH_QUERY = "search_query"
+    SEARCH_MESSAGE = "search_message"
+
+    def execute(self):
+        # get query
+        query = self.context.get_context(self.SEARCH_QUERY)
+        assert query, "query should be not empty!"
+
+        # retrieve from vector store
+        request: RetrieverRequest = self.context.request
+        nodes: List[VectorNode] = self.vector_store.search(query=query,
+                                                           workspace_id=request.workspace_id,
+                                                           top_k=request.top_k)
+
+        # convert to experience, filter duplicate
+        experience_list: List[BaseExperience] = []
+        experience_content_list: List[str] = []
+        for node in nodes:
+            experience: BaseExperience = vector_node_to_experience(node)
+            if experience.content not in experience_content_list:
+                experience_list.append(experience)
+                experience_content_list.append(experience.content)
+        experience_size = len(experience_list)
+        logger.info(f"retrieve experience size={experience_size}")
+
+        # filter by score
+        threshold_score: float | None = self.op_params.get("threshold_score", None)
+        if threshold_score is not None:
+            experience_list = [e for e in experience_list if e.score >= threshold_score or e.score is None]
+            logger.info(f"after filter by threshold_score size={len(experience_list)}")
+
+        # set response
+        response: RetrieverResponse = self.context.response
+        response.experience_list = experience_list

llmflow/op/vector_store/update_vector_store_op.py

@@ -0,0 +1,28 @@
+import json
+from typing import List
+
+from loguru import logger
+
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+from llmflow.schema.experience import BaseExperience
+from llmflow.schema.request import BaseRequest
+from llmflow.schema.vector_node import VectorNode
+
+
+@OP_REGISTRY.register()
+class UpdateVectorStoreOp(BaseOp):
+
+    def execute(self):
+        request: BaseRequest = self.context.request
+
+        experience_ids: List[str] | None = self.context.response.deleted_experience_ids
+        if experience_ids:
+            self.vector_store.delete(node_ids=experience_ids, workspace_id=request.workspace_id)
+            logger.info(f"delete experience_ids={json.dumps(experience_ids, indent=2)}")
+
+        insert_experience_list: List[BaseExperience] | None = self.context.response.experience_list
+        if insert_experience_list:
+            insert_nodes: List[VectorNode] = [x.to_vector_node() for x in insert_experience_list]
+            self.vector_store.insert(nodes=insert_nodes, workspace_id=request.workspace_id)
+            logger.info(f"insert insert_node.size={len(insert_nodes)}")

llmflow/op/vector_store/vector_store_action_op.py

@@ -0,0 +1,46 @@
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+from llmflow.schema.experience import vector_node_to_experience, dict_to_experience, BaseExperience
+from llmflow.schema.request import VectorStoreRequest
+from llmflow.schema.response import VectorStoreResponse
+from llmflow.schema.vector_node import VectorNode
+
+
+@OP_REGISTRY.register()
+class VectorStoreActionOp(BaseOp):
+
+    def execute(self):
+        request: VectorStoreRequest = self.context.request
+        response: VectorStoreResponse = self.context.response
+
+        if request.action == "copy":
+            result = self.vector_store.copy_workspace(src_workspace_id=request.src_workspace_id,
+                                                      dest_workspace_id=request.workspace_id)
+
+        elif request.action == "delete":
+            result = self.vector_store.delete_workspace(workspace_id=request.workspace_id)
+
+        elif request.action == "dump":
+            def node_to_experience(node: VectorNode) -> dict:
+                return vector_node_to_experience(node).model_dump()
+
+            result = self.vector_store.dump_workspace(workspace_id=request.workspace_id,
+                                                      path=request.path,
+                                                      callback_fn=node_to_experience)
+
+        elif request.action == "load":
+            def experience_dict_to_node(experience_dict: dict) -> VectorNode:
+                experience: BaseExperience = dict_to_experience(experience_dict=experience_dict)
+                return experience.to_vector_node()
+
+            result = self.vector_store.load_workspace(workspace_id=request.workspace_id,
+                                                      path=request.path,
+                                                      callback_fn=experience_dict_to_node)
+
+        else:
+            raise ValueError(f"invalid action={request.action}")
+
+        if isinstance(result, dict):
+            response.metadata.update(result)
+        else:
+            response.metadata["result"] = str(result)

llmflow/pipeline/pipeline.py

@@ -0,0 +1,94 @@
+from concurrent.futures import as_completed
+from itertools import zip_longest
+from typing import List
+
+from loguru import logger
+
+from llmflow.op import OP_REGISTRY
+from llmflow.op.base_op import BaseOp
+from llmflow.pipeline.pipeline_context import PipelineContext
+from llmflow.utils.timer import Timer, timer
+
+
+class Pipeline:
+    seq_symbol: str = "->"
+    parallel_symbol: str = "|"
+
+    def __init__(self, pipeline: str, context: PipelineContext):
+        self.pipeline_list: List[str | List[str]] = self._parse_pipline(pipeline)
+        self.context: PipelineContext = context
+
+    def _parse_pipline(self, pipeline: str) -> List[str | List[str]]:
+        pipeline_list: List[str | List[str]] = []
+
+        for pipeline_split1 in pipeline.split("["):
+            for sub_pipeline in pipeline_split1.split("]"):
+                sub_pipeline = sub_pipeline.strip().strip(self.seq_symbol)
+                if not sub_pipeline:
+                    continue
+
+                if self.parallel_symbol in sub_pipeline:
+                    pipeline_list.append(sub_pipeline.split(self.parallel_symbol))
+                else:
+                    pipeline_list.append(sub_pipeline)
+                logger.info(f"add sub_pipeline={sub_pipeline}")
+        return pipeline_list
+
+    def _execute_sub_pipeline(self, pipeline: str):
+        op_config_dict = self.context.app_config.op
+        for op in pipeline.split(self.seq_symbol):
+            op = op.strip()
+            if not op:
+                continue
+
+            assert op in op_config_dict, f"op={op} config is missing!"
+            op_config = op_config_dict[op]
+
+            assert op_config.backend in OP_REGISTRY, f"op={op} backend={op_config.backend} is not registered!"
+            op_cls = OP_REGISTRY[op_config.backend]
+
+            op_obj: BaseOp = op_cls(context=self.context, op_config=op_config)
+            op_obj.execute_wrap()
+
+    def _parse_sub_pipeline(self, pipeline: str):
+        for op in pipeline.split(self.seq_symbol):
+            op = op.strip()
+            if not op:
+                continue
+
+            yield op
+
+    def print_pipeline(self):
+        i: int = 0
+        for pipeline in self.pipeline_list:
+            if isinstance(pipeline, str):
+                for op in self._parse_sub_pipeline(pipeline):
+                    i += 1
+                    logger.info(f"stage_{i}: {op}")
+
+            elif isinstance(pipeline, list):
+                parallel_pipeline = [self._parse_sub_pipeline(x) for x in pipeline]
+                for op_list in zip_longest(*parallel_pipeline, fillvalue="-"):
+                    i += 1
+                    logger.info(f"stage{i}: {' | '.join(op_list)}")
+            else:
+                raise ValueError(f"unknown pipeline.type={type(pipeline)}")
+
+    @timer(name="pipeline.execute")
+    def __call__(self, enable_print: bool = True):
+        if enable_print:
+            self.print_pipeline()
+
+        for i, pipeline in enumerate(self.pipeline_list):
+            with Timer(f"step_{i}"):
+                if isinstance(pipeline, str):
+                    self._execute_sub_pipeline(pipeline)
+
+                else:
+                    future_list = []
+                    for sub_pipeline in pipeline:
+                        future = self.context.thread_pool.submit(self._execute_sub_pipeline, pipeline=sub_pipeline)
+                        future_list.append(future)
+
+                    for future in as_completed(future_list):
+                        future.result()

llmflow/pipeline/pipeline_context.py

@@ -0,0 +1,37 @@
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict
+
+from llmflow.schema.app_config import AppConfig
+from llmflow.vector_store.base_vector_store import BaseVectorStore
+
+
+class PipelineContext:
+
+    def __init__(self, **kwargs):
+        self._context: dict = {**kwargs}
+
+    def get_context(self, key: str, default=None):
+        return self._context.get(key, default)
+
+    def set_context(self, key: str, value):
+        self._context[key] = value
+
+    @property
+    def request(self):
+        return self._context["request"]
+
+    @property
+    def response(self):
+        return self._context["response"]
+
+    @property
+    def app_config(self) -> AppConfig:
+        return self._context["app_config"]
+
+    @property
+    def thread_pool(self) -> ThreadPoolExecutor:
+        return self._context["thread_pool"]
+
+    @property
+    def vector_store_dict(self) -> Dict[str, BaseVectorStore]:
+        return self._context["vector_store_dict"]

llmflow/schema/app_config.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class HttpServiceConfig:
+    host: str = field(default="0.0.0.0")
+    port: int = field(default=8001)
+    timeout_keep_alive: int = field(default=600)
+    limit_concurrency: int = field(default=64)
+
+
+@dataclass
+class ThreadPoolConfig:
+    max_workers: int = field(default=10)
+
+
+@dataclass
+class APIConfig:
+    retriever: str = field(default="")
+    summarizer: str = field(default="")
+    vector_store: str = field(default="")
+    agent: str = field(default="")
+
+
+@dataclass
+class OpConfig:
+    backend: str = field(default="")
+    prompt_file_path: str = field(default="")
+    prompt_dict: dict = field(default_factory=dict)
+    llm: str = field(default="")
+    embedding_model: str = field(default="")
+    vector_store: str = field(default="")
+    params: dict = field(default_factory=dict)
+
+
+@dataclass
+class LLMConfig:
+    backend: str = field(default="")
+    model_name: str = field(default="")
+    params: dict = field(default_factory=dict)
+
+
+@dataclass
+class EmbeddingModelConfig:
+    backend: str = field(default="")
+    model_name: str = field(default="")
+    params: dict = field(default_factory=dict)
+
+
+@dataclass
+class VectorStoreConfig:
+    backend: str = field(default="")
+    embedding_model: str = field(default="")
+    params: dict = field(default_factory=dict)
+
+
+@dataclass
+class AppConfig:
+    pre_defined_config: str = field(default="mock_config")
+    config_path: str = field(default="")
+    mcp_transport: str = field(default="sse")
+    http_service: HttpServiceConfig = field(default_factory=HttpServiceConfig)
+    thread_pool: ThreadPoolConfig = field(default_factory=ThreadPoolConfig)
+    api: APIConfig = field(default_factory=APIConfig)
+    op: Dict[str, OpConfig] = field(default_factory=dict)
+    llm: Dict[str, LLMConfig] = field(default_factory=dict)
+    embedding_model: Dict[str, EmbeddingModelConfig] = field(default_factory=dict)
+    vector_store: Dict[str, VectorStoreConfig] = field(default_factory=dict)