flowllm 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

llmflow/op/__init__.py

@@ -1,10 +0,0 @@
-from llmflow.utils.registry import Registry
-
-OP_REGISTRY = Registry()
-
-from llmflow.op.mock_op import Mock1Op, Mock2Op, Mock3Op, Mock4Op, Mock5Op, Mock6Op
-
-from llmflow.op.vector_store.update_vector_store_op import UpdateVectorStoreOp
-from llmflow.op.vector_store.recall_vector_store_op import RecallVectorStoreOp
-from llmflow.op.vector_store.vector_store_action_op import VectorStoreActionOp
-from llmflow.op.react.react_v1_op import ReactV1Op

llmflow/op/base_op.py

@@ -1,125 +0,0 @@
-from abc import abstractmethod, ABC
-from concurrent.futures import Future
-from pathlib import Path
-from typing import List
-
-from loguru import logger
-from tqdm import tqdm
-
-from llmflow.embedding_model import EMBEDDING_MODEL_REGISTRY
-from llmflow.embedding_model.base_embedding_model import BaseEmbeddingModel
-from llmflow.llm import LLM_REGISTRY
-from llmflow.llm.base_llm import BaseLLM
-from llmflow.op.prompt_mixin import PromptMixin
-from llmflow.pipeline.pipeline_context import PipelineContext
-from llmflow.schema.app_config import OpConfig, LLMConfig, EmbeddingModelConfig
-from llmflow.utils.common_utils import camel_to_snake
-from llmflow.utils.timer import Timer
-from llmflow.vector_store.base_vector_store import BaseVectorStore
-
-
-class BaseOp(PromptMixin, ABC):
-    current_path: str = __file__
-
-    def __init__(self, context: PipelineContext, op_config: OpConfig):
-        super().__init__()
-        self.context: PipelineContext = context
-        self.op_config: OpConfig = op_config
-        self.timer = Timer(name=self.simple_name)
-
-        self._prepare_prompt()
-
-        self._llm: BaseLLM | None = None
-        self._embedding_model: BaseEmbeddingModel | None = None
-        self._vector_store: BaseVectorStore | None = None
-
-        self.task_list: List[Future] = []
-
-    def _prepare_prompt(self):
-        if self.op_config.prompt_file_path:
-            prompt_file_path = self.op_config.prompt_file_path
-        else:
-            prompt_name = self.simple_name.replace("_op", "_prompt.yaml")
-            prompt_file_path = Path(self.current_path).parent / prompt_name
-
-        # Load custom prompts from prompt file
-        self.load_prompt_by_file(prompt_file_path=prompt_file_path)
-
-        # Load custom prompts from config
-        self.load_prompt_dict(prompt_dict=self.op_config.prompt_dict)
-
-    @property
-    def simple_name(self) -> str:
-        return camel_to_snake(self.__class__.__name__)
-
-    @property
-    def op_params(self) -> dict:
-        return self.op_config.params
-
-    @abstractmethod
-    def execute(self):
-        ...
-
-    def execute_wrap(self):
-        try:
-            with self.timer:
-                return self.execute()
-
-        except Exception as e:
-            logger.exception(f"op={self.simple_name} execute failed, error={e.args}")
-
-    def submit_task(self, fn, *args, **kwargs):
-        task = self.context.thread_pool.submit(fn, *args, **kwargs)
-        self.task_list.append(task)
-        return self
-
-    def join_task(self, task_desc: str = None) -> list:
-        result = []
-        for task in tqdm(self.task_list, desc=task_desc or (self.simple_name + ".join_task")):
-            t_result = task.result()
-            if t_result:
-                if isinstance(t_result, list):
-                    result.extend(t_result)
-                else:
-                    result.append(t_result)
-        self.task_list.clear()
-        return result
-
-    @property
-    def llm(self) -> BaseLLM:
-        if self._llm is None:
-            llm_name: str = self.op_config.llm
-            assert llm_name in self.context.app_config.llm, f"llm={llm_name} not found in app_config.llm!"
-            llm_config: LLMConfig = self.context.app_config.llm[llm_name]
-
-            assert llm_config.backend in LLM_REGISTRY, f"llm.backend={llm_config.backend} not found in LLM_REGISTRY!"
-            llm_cls = LLM_REGISTRY[llm_config.backend]
-            self._llm = llm_cls(model_name=llm_config.model_name, **llm_config.params)
-
-        return self._llm
-
-    @property
-    def embedding_model(self):
-        if self._embedding_model is None:
-            embedding_model_name: str = self.op_config.embedding_model
-            assert embedding_model_name in self.context.app_config.embedding_model, \
-                f"embedding_model={embedding_model_name} not found in app_config.embedding_model!"
-            embedding_model_config: EmbeddingModelConfig = self.context.app_config.embedding_model[embedding_model_name]
-
-            assert embedding_model_config.backend in EMBEDDING_MODEL_REGISTRY, \
-                f"embedding_model.backend={embedding_model_config.backend} not found in EMBEDDING_MODEL_REGISTRY!"
-            embedding_model_cls = EMBEDDING_MODEL_REGISTRY[embedding_model_config.backend]
-            self._embedding_model = embedding_model_cls(model_name=embedding_model_config.model_name,
-                                                        **embedding_model_config.params)
-
-        return self._embedding_model
-
-    @property
-    def vector_store(self):
-        if self._vector_store is None:
-            vector_store_name: str = self.op_config.vector_store
-            assert vector_store_name in self.context.vector_store_dict, \
-                f"vector_store={vector_store_name} not found in vector_store_dict!"
-            self._vector_store = self.context.vector_store_dict[vector_store_name]
-
-        return self._vector_store

llmflow/op/mock_op.py

@@ -1,40 +0,0 @@
-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/react/react_v1_op.py

@@ -1,88 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,13 +0,0 @@
-"""
-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

@@ -1,48 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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)