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

flowllm/schema/vector_node.py

@@ -1,5 +1,6 @@
 from typing import List
 from uuid import uuid4
+
 from pydantic import BaseModel, Field
 
 

flowllm/service/__init__.py

@@ -1,2 +1,3 @@
-from flowllm.service.mcp_service import MCPService
-from flowllm.service.http_service import HttpService
+from .cmd_service import CmdService
+from .http_service import HttpService
+from .mcp_service import MCPService

flowllm/service/base_service.py

@@ -1,59 +1,68 @@
-from concurrent.futures import ThreadPoolExecutor
-from typing import Dict
+from abc import abstractmethod, ABC
+from typing import Dict, Optional
 
 from loguru import logger
+from pydantic import create_model, Field
 
-from flowllm.context.flow_context import FlowContext
+from flowllm.config.pydantic_config_parser import PydanticConfigParser
 from flowllm.context.service_context import C
-from flowllm.flow_engine.base_flow_engine import BaseFlowEngine
-from flowllm.schema.flow_response import FlowResponse
-from flowllm.schema.service_config import ServiceConfig, EmbeddingModelConfig, FlowConfig
+from flowllm.schema.flow_request import FlowRequest
+from flowllm.schema.service_config import ServiceConfig
+from flowllm.schema.tool_call import ParamAttrs
+from flowllm.utils.common_utils import snake_to_camel
 
 
-class BaseService:
+class BaseService(ABC):
+    TYPE_MAPPING = {
+        "str": str,
+        "int": int,
+        "float": float,
+        "bool": bool,
+        "list": list,
+        "dict": dict,
+    }
 
     def __init__(self, service_config: ServiceConfig):
         self.service_config = service_config
 
-        C.language = self.service_config.language
-        C.thread_pool = ThreadPoolExecutor(max_workers=self.service_config.thread_pool_max_workers)
-        for name, config in self.service_config.vector_store.items():
-            vector_store_cls = C.resolve_vector_store(config.backend)
-            embedding_model_config: EmbeddingModelConfig = self.service_config.embedding_model[config.embedding_model]
-            embedding_model_cls = C.resolve_embedding_model(embedding_model_config.backend)
-            embedding_model = embedding_model_cls(model_name=embedding_model_config.model_name,
-                                                  **embedding_model_config.params)
-            C.set_vector_store(name, vector_store_cls(embedding_model=embedding_model, **config.params))
-
-        self.flow_engine_config = self.service_config.flow_engine
-        self.flow_engine_cls = C.resolve_flow_engine(self.flow_engine_config.backend)
-        self.flow_config_dict: Dict[str, FlowConfig] = \
-            {name: config.set_name(name) for name, config in self.service_config.flow.items()}
-
         self.mcp_config = self.service_config.mcp
         self.http_config = self.service_config.http
+        C.init_by_service_config(self.service_config)
+
+    @classmethod
+    def get_service(cls, *args, parser: type[PydanticConfigParser] = PydanticConfigParser) -> "BaseService":
+        config_parser = parser(ServiceConfig)
+        service_config: ServiceConfig = config_parser.parse_args(*args)
+        service_cls = C.resolve_service(service_config.backend)
+        return service_cls(service_config)
+
+    def _create_pydantic_model(self, flow_name: str, input_schema: Dict[str, ParamAttrs]):
+        fields = {}
+
+        for param_name, param_config in input_schema.items():
+            field_type = self.TYPE_MAPPING.get(param_config.type, str)
+
+            if not param_config.required:
+                fields[param_name] = (Optional[field_type], Field(default=None, description=param_config.description))
+            else:
+                fields[param_name] = (field_type, Field(default=..., description=param_config.description))
+
+        return create_model(f"{snake_to_camel(flow_name)}Model", __base__=FlowRequest, **fields)
 
-    def execute_flow(self, flow_name: str, **kwargs) -> FlowResponse:
-        response = FlowResponse()
-        try:
-            logger.info(f"request.params={kwargs}")
-            flow_context = FlowContext(**kwargs,
-                                       response=response,
-                                       service_config=self.service_config.model_copy(deep=True))
+    def integrate_tool_flow(self, tool_flow_name: str):
+        ...
 
-            flow_config = self.flow_config_dict[flow_name]
-            flow_engine: BaseFlowEngine = self.flow_engine_cls(flow_name=flow_name,
-                                                               flow_content=flow_config.flow_content,
-                                                               flow_context=flow_context,
-                                                               **self.flow_engine_config.params)
-            flow_engine()
+    def integrate_tool_flows(self):
+        for tool_flow_name in C.tool_flow_names:
+            self.integrate_tool_flow(tool_flow_name)
+            logger.info(f"integrate flow_endpoint={tool_flow_name}")
 
-        except Exception as e:
-            logger.exception(f"flow_name={flow_name} encounter error={e.args}")
-            response.success = False
-            response.answer = str(e.args)
+    def __enter__(self):
+        return self
 
-        return response
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        ...
 
+    @abstractmethod
     def __call__(self):
-        raise NotImplementedError
+        ...

flowllm/service/cmd_service.py

@@ -0,0 +1,15 @@
+from loguru import logger
+
+from flowllm.context.service_context import C
+from flowllm.flow.gallery import CmdFlow
+from flowllm.service.base_service import BaseService
+
+
+@C.register_service("cmd")
+class CmdService(BaseService):
+
+    def __call__(self):
+        flow = CmdFlow(flow=self.service_config.cmd.flow)
+        response = flow.__call__(**self.service_config.cmd.params)
+        if response.answer:
+            logger.info(f"final_answer={response.answer}")

flowllm/service/http_service.py

@@ -1,33 +1,24 @@
 import asyncio
 from functools import partial
-from typing import Dict, Optional
 
 import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from loguru import logger
-from pydantic import BaseModel, create_model, Field
 
 from flowllm.context.service_context import C
+from flowllm.flow.base_tool_flow import BaseToolFlow
 from flowllm.schema.flow_response import FlowResponse
-from flowllm.schema.tool_call import ParamAttrs
 from flowllm.service.base_service import BaseService
-from flowllm.utils.common_utils import snake_to_camel
 
 
 @C.register_service("http")
 class HttpService(BaseService):
-    TYPE_MAPPING = {
-        "str": str,
-        "int": int,
-        "float": float,
-        "bool": bool
-    }
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.app = FastAPI(title="FlowLLM", description="HTTP API for FlowLLM")
-        
+
         # Add CORS middleware
         self.app.add_middleware(
             CORSMiddleware,
@@ -36,50 +27,51 @@ class HttpService(BaseService):
             allow_methods=["*"],
             allow_headers=["*"],
         )
-        
+
         # Add health check endpoint
         self.app.get("/health")(self.health_check)
 
     @staticmethod
     def health_check():
         return {"status": "healthy"}
-    
-    def _create_pydantic_model(self, flow_name: str, input_schema: Dict[str, ParamAttrs]) -> BaseModel:
-        # Create a dynamic Pydantic model based on flow input schema
-        fields = {}
-
-        for param_name, param_config in input_schema.items():
-            field_type = self.TYPE_MAPPING.get(param_config.type, str)
-
-            if not param_config.required:
-                fields[param_name] = (Optional[field_type], Field(default=None, description=param_config.description))
-            else:
-                fields[param_name] = (field_type, Field(default=..., description=param_config.description))
-
-        return create_model(f"{snake_to_camel(flow_name)}Model", **fields)
-    
-    def register_flow(self, flow_name: str):
-        """Register a flow as an HTTP endpoint"""
-        flow_config = self.flow_config_dict[flow_name]
-        request_model = self._create_pydantic_model(flow_name, flow_config.input_schema)
-
-        async def execute_flow_endpoint(request: request_model) -> FlowResponse:
+
+    def integrate_tool_flow(self, tool_flow_name: str):
+        tool_flow: BaseToolFlow = C.get_tool_flow(tool_flow_name)
+        request_model = self._create_pydantic_model(tool_flow_name, tool_flow.tool_call.input_schema)
+
+        async def execute_endpoint(request: request_model) -> FlowResponse:
             loop = asyncio.get_event_loop()
             response: FlowResponse = await loop.run_in_executor(
                 executor=C.thread_pool,
-                func=partial(self.execute_flow, flow_name=flow_name, **request.model_dump()))  # noqa
+                func=partial(tool_flow.__call__, **request.model_dump()))  # noqa
 
             return response
 
-        endpoint_path = f"/{flow_name}"
-        self.app.post(endpoint_path, response_model=FlowResponse)(execute_flow_endpoint)
-        logger.info(f"register flow={flow_name} endpoint={endpoint_path}")
-    
+        endpoint_path = f"/{tool_flow.name}"
+        self.app.post(endpoint_path, response_model=FlowResponse)(execute_endpoint)
+
+    def integrate_tool_flows(self):
+        super().integrate_tool_flows()
+
+        async def execute_endpoint() -> list:
+            loop = asyncio.get_event_loop()
+
+            def list_tool_flows() -> list:
+                tool_flow_schemas = []
+                for name, tool_flow in C.tool_flow_dict.items():
+                    assert isinstance(tool_flow, BaseToolFlow)
+                    tool_flow_schemas.append(tool_flow.tool_call.simple_input_dump())
+                return tool_flow_schemas
+
+            return await loop.run_in_executor(executor=C.thread_pool, func=list_tool_flows)  # noqa
+
+        endpoint_path = "/list"
+        self.app.get(endpoint_path, response_model=list)(execute_endpoint)
+        logger.info(f"integrate endpoint={endpoint_path}")
+
     def __call__(self):
-        for flow_name in self.flow_config_dict:
-            self.register_flow(flow_name)
-        
-        # Start the server
+        self.integrate_tool_flows()
+
         uvicorn.run(self.app,
                     host=self.http_config.host,
                     port=self.http_config.port,

flowllm/service/mcp_service.py

@@ -3,9 +3,9 @@ from functools import partial
 
 from fastmcp import FastMCP
 from fastmcp.tools import FunctionTool
-from loguru import logger
 
 from flowllm.context.service_context import C
+from flowllm.flow.base_tool_flow import BaseToolFlow
 from flowllm.service.base_service import BaseService
 
 
@@ -14,31 +14,33 @@ class MCPService(BaseService):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.mcp = FastMCP("FlowLLM")
+        self.mcp = FastMCP(name="FlowLLM")
 
-    def register_flow(self, flow_name: str):
-        flow_config = self.flow_config_dict[flow_name]
+    def integrate_tool_flow(self, tool_flow_name: str):
+        tool_flow: BaseToolFlow = C.get_tool_flow(tool_flow_name)
+        request_model = self._create_pydantic_model(tool_flow_name, tool_flow.tool_call.input_schema)
 
         async def execute_flow_async(**kwargs) -> str:
+            request: request_model = request_model(**kwargs)
             loop = asyncio.get_event_loop()
             response = await loop.run_in_executor(
                 executor=C.thread_pool,
-                func=partial(self.execute_flow, flow_name=flow_name, **kwargs))  # noqa
+                func=partial(tool_flow.__call__, **request.model_dump()))  # noqa
             return response.answer
 
-        tool = FunctionTool(name=flow_name,  # noqa
-                            description=flow_config.description,  # noqa
+        tool = FunctionTool(name=tool_flow.name,  # noqa
+                            description=tool_flow.tool_call.description,  # noqa
                             fn=execute_flow_async,
-                            parameters=flow_config.input_schema)
+                            parameters=tool_flow.tool_call.input_schema)
         self.mcp.add_tool(tool)
-        logger.info(f"register flow={flow_name}")
 
     def __call__(self):
-        for flow_name in self.flow_config_dict:
-            self.register_flow(flow_name)
+        self.integrate_tool_flows()
 
         if self.mcp_config.transport == "sse":
             self.mcp.run(transport="sse", host=self.mcp_config.host, port=self.mcp_config.port)
+        if self.mcp_config.transport == "http":
+            self.mcp.run(transport="http", host=self.mcp_config.host, port=self.mcp_config.port)
         elif self.mcp_config.transport == "stdio":
             self.mcp.run(transport="stdio")
         else:

flowllm/storage/cache/__init__.py

@@ -0,0 +1 @@
+from .data_cache import DataCache

flowllm/storage/cache/cache_data_handler.py

@@ -0,0 +1,104 @@
+import json
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, Any
+
+import pandas as pd
+
+
+class CacheDataHandler(ABC):
+    """Abstract base class for data type handlers"""
+
+    @abstractmethod
+    def save(self, data: Any, file_path: Path, **kwargs) -> Dict[str, Any]:
+        """
+        Save data to file and return metadata
+        
+        Args:
+            data: Data to save
+            file_path: File path to save to
+            **kwargs: Additional parameters
+            
+        Returns:
+            Dict containing metadata about the saved data
+        """
+        pass
+
+    @abstractmethod
+    def load(self, file_path: Path, **kwargs) -> Any:
+        """
+        Load data from file
+        
+        Args:
+            file_path: File path to load from
+            **kwargs: Additional parameters
+            
+        Returns:
+            Loaded data
+        """
+        pass
+
+    @abstractmethod
+    def get_file_extension(self) -> str:
+        """Get the file extension for this data type"""
+        pass
+
+
+class DataFrameHandler(CacheDataHandler):
+    """Handler for pandas DataFrame data type"""
+
+    def save(self, data: pd.DataFrame, file_path: Path, **kwargs) -> Dict[str, Any]:
+        """Save DataFrame as CSV"""
+        csv_params = {
+            "index": False,
+            "encoding": "utf-8"
+        }
+        csv_params.update(kwargs)
+
+        data.to_csv(file_path, **csv_params)
+
+        return {
+            'row_count': len(data),
+            'column_count': len(data.columns),
+            'file_size': file_path.stat().st_size
+        }
+
+    def load(self, file_path: Path, **kwargs) -> pd.DataFrame:
+        """Load DataFrame from CSV"""
+        csv_params = {
+            'encoding': 'utf-8'
+        }
+        csv_params.update(kwargs)
+
+        return pd.read_csv(file_path, **csv_params)
+
+    def get_file_extension(self) -> str:
+        return ".csv"
+
+
+class DictHandler(CacheDataHandler):
+    """Handler for dict data type"""
+
+    def save(self, data: dict, file_path: Path, **kwargs) -> Dict[str, Any]:
+        """Save dict as JSON"""
+        json_params = {
+            "ensure_ascii": False,
+            "indent": 2
+        }
+        json_params.update(kwargs)
+
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, **json_params)
+
+        return {
+            'key_count': len(data),
+            'file_size': file_path.stat().st_size
+        }
+
+    def load(self, file_path: Path, **kwargs) -> dict:
+        """Load dict from JSON"""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def get_file_extension(self) -> str:
+        return ".json"