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

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/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)

llmflow/schema/experience.py

@@ -1,144 +0,0 @@
-import datetime
-from abc import ABC
-from typing import List
-from uuid import uuid4
-
-from loguru import logger
-from pydantic import BaseModel, Field
-
-from llmflow.schema.vector_node import VectorNode
-
-
-class ExperienceMeta(BaseModel):
-    author: str = Field(default="")
-    created_time: str = Field(default_factory=lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-    modified_time: str = Field(default_factory=lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-    extra_info: dict | None = Field(default=None)
-
-    def update_modified_time(self):
-        self.modified_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-
-class BaseExperience(BaseModel, ABC):
-    workspace_id: str = Field(default="")
-
-    experience_id: str = Field(default_factory=lambda: uuid4().hex)
-    experience_type: str = Field(default="")
-
-    when_to_use: str = Field(default="")
-    content: str | bytes = Field(default="")
-    score: float | None = Field(default=None)
-    metadata: ExperienceMeta = Field(default_factory=ExperienceMeta)
-
-    def to_vector_node(self) -> VectorNode:
-        raise NotImplementedError
-
-    @classmethod
-    def from_vector_node(cls, node: VectorNode):
-        raise NotImplementedError
-
-
-class TextExperience(BaseExperience):
-    experience_type: str = Field(default="text")
-
-    def to_vector_node(self) -> VectorNode:
-        return VectorNode(unique_id=self.experience_id,
-                          workspace_id=self.workspace_id,
-                          content=self.when_to_use,
-                          metadata={
-                              "experience_type": self.experience_type,
-                              "experience_content": self.content,
-                              "score": self.score,
-                              "metadata": self.metadata.model_dump(),
-                          })
-
-    @classmethod
-    def from_vector_node(cls, node: VectorNode):
-        return cls(workspace_id=node.workspace_id,
-                   experience_id=node.unique_id,
-                   experience_type=node.metadata.get("experience_type"),
-                   when_to_use=node.content,
-                   content=node.metadata.get("experience_content"),
-                   score=node.metadata.get("score"),
-                   metadata=node.metadata.get("metadata"))
-
-
-class FunctionArg(BaseModel):
-    arg_name: str = Field(default=...)
-    arg_type: str = Field(default=...)
-    required: bool = Field(default=True)
-
-
-class Function(BaseModel):
-    func_code: str = Field(default=..., description="function code")
-    func_name: str = Field(default=..., description="function name")
-    func_args: List[FunctionArg] = Field(default_factory=list)
-
-
-class FuncExperience(BaseExperience):
-    experience_type: str = Field(default="function")
-    functions: List[Function] = Field(default_factory=list)
-
-
-class PersonalExperience(BaseExperience):
-    experience_type: str = Field(default="personal")
-    person: str = Field(default="")
-    topic: str = Field(default="")
-
-
-class KnowledgeExperience(BaseExperience):
-    experience_type: str = Field(default="knowledge")
-    topic: str = Field(default="")
-
-
-def vector_node_to_experience(node: VectorNode) -> BaseExperience:
-    experience_type = node.metadata.get("experience_type")
-    if experience_type == "text":
-        return TextExperience.from_vector_node(node)
-
-    elif experience_type == "function":
-        return FuncExperience.from_vector_node(node)
-
-    elif experience_type == "personal":
-        return PersonalExperience.from_vector_node(node)
-
-    elif experience_type == "knowledge":
-        return KnowledgeExperience.from_vector_node(node)
-
-    else:
-        logger.warning(f"experience type {experience_type} not supported")
-        return TextExperience.from_vector_node(node)
-
-
-def dict_to_experience(experience_dict: dict) -> BaseExperience:
-    experience_type = experience_dict.get("experience_type", "text")
-    if experience_type == "text":
-        return TextExperience(**experience_dict)
-
-    elif experience_type == "function":
-        return FuncExperience(**experience_dict)
-
-    elif experience_type == "personal":
-        return PersonalExperience(**experience_dict)
-
-    elif experience_type == "knowledge":
-        return KnowledgeExperience(**experience_dict)
-
-    else:
-        logger.warning(f"experience type {experience_type} not supported")
-        return TextExperience(**experience_dict)
-
-
-if __name__ == "__main__":
-    e1 = TextExperience(
-        workspace_id="w_1024",
-        experience_id="123",
-        when_to_use="test case use",
-        content="test content",
-        score=0.99,
-        metadata=ExperienceMeta(author="user"))
-    print(e1.model_dump_json(indent=2))
-    v1 = e1.to_vector_node()
-    print(v1.model_dump_json(indent=2))
-    e2 = vector_node_to_experience(v1)
-    print(e2.model_dump_json(indent=2))