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

llmflow/app.py

@@ -1,53 +0,0 @@
-import sys
-
-import uvicorn
-from dotenv import load_dotenv
-from fastapi import FastAPI
-
-from llmflow.schema.request import RetrieverRequest, SummarizerRequest, VectorStoreRequest, AgentRequest
-from llmflow.schema.response import RetrieverResponse, SummarizerResponse, VectorStoreResponse, AgentResponse
-from llmflow.service.llmflow_service import LLMFlowService
-
-load_dotenv()
-
-app = FastAPI()
-service = LLMFlowService(sys.argv[1:])
-
-
-@app.post('/retriever', response_model=RetrieverResponse)
-def call_retriever(request: RetrieverRequest):
-    return service(api="retriever", request=request)
-
-
-@app.post('/summarizer', response_model=SummarizerResponse)
-def call_summarizer(request: SummarizerRequest):
-    return service(api="summarizer", request=request)
-
-
-@app.post('/vector_store', response_model=VectorStoreResponse)
-def call_vector_store(request: VectorStoreRequest):
-    return service(api="vector_store", request=request)
-
-
-@app.post('/agent', response_model=AgentResponse)
-def call_agent(request: AgentRequest):
-    return service(api="agent", request=request)
-
-
-def main():
-    uvicorn.run(app=app,
-                host=service.http_service_config.host,
-                port=service.http_service_config.port,
-                timeout_keep_alive=service.http_service_config.timeout_keep_alive,
-                limit_concurrency=service.http_service_config.limit_concurrency)
-
-
-if __name__ == "__main__":
-    main()
-
-# start with:
-# llmflow \
-#   http_service.port=8001 \
-#   llm.default.model_name=qwen3-32b \
-#   embedding_model.default.model_name=text-embedding-v4 \
-#   vector_store.default.backend=local_file

llmflow/config/config_parser.py

@@ -1,80 +0,0 @@
-import json
-from pathlib import Path
-
-from loguru import logger
-from omegaconf import OmegaConf, DictConfig
-
-from llmflow.schema.app_config import AppConfig
-
-
-class ConfigParser:
-    """
-    Configuration parser that handles loading and merging configurations from multiple sources.
-    
-    The configuration loading priority (from lowest to highest):
-    1. Default configuration from AppConfig schema
-    2. YAML configuration file
-    3. Command line arguments
-    4. Runtime keyword arguments
-    """
-
-    def __init__(self, args: list):
-        """
-        Initialize the configuration parser with command line arguments.
-        
-        Args:
-            args: List of command line arguments in dotlist format (e.g., ['key=value'])
-        """
-        # Step 1: Initialize with default configuration from AppConfig schema
-        self.app_config: DictConfig = OmegaConf.structured(AppConfig)
-
-        # Step 2: Load configuration from YAML file
-        # First, parse CLI arguments to check if custom config path is specified
-        cli_config: DictConfig = OmegaConf.from_dotlist(args)
-        temp_config: AppConfig = OmegaConf.to_object(OmegaConf.merge(self.app_config, cli_config))
-
-        # Determine config file path: either from CLI args or use predefined config
-        if temp_config.config_path:
-            # Use custom config path if provided
-            config_path = Path(temp_config.config_path)
-        else:
-            # Use predefined config name from the config directory
-            pre_defined_config = temp_config.pre_defined_config
-            if not pre_defined_config.endswith(".yaml"):
-                pre_defined_config += ".yaml"
-            config_path = Path(__file__).parent / pre_defined_config
-
-        logger.info(f"load config from path={config_path}")
-        yaml_config = OmegaConf.load(config_path)
-        # Merge YAML config with default config
-        self.app_config = OmegaConf.merge(self.app_config, yaml_config)
-
-        # Step 3: Merge CLI arguments (highest priority)
-        self.app_config = OmegaConf.merge(self.app_config, cli_config)
-
-        # Log the final merged configuration
-        app_config_dict = OmegaConf.to_container(self.app_config, resolve=True)
-        logger.info(f"app_config=\n{json.dumps(app_config_dict, indent=2, ensure_ascii=False)}")
-
-    def get_app_config(self, **kwargs) -> AppConfig:
-        """
-        Get the application configuration with optional runtime overrides.
-        
-        Args:
-            **kwargs: Additional configuration parameters to override at runtime
-            
-        Returns:
-            AppConfig: The final application configuration object
-        """
-        # Create a copy of the current configuration
-        app_config = self.app_config.copy()
-
-        # Apply runtime overrides if provided
-        if kwargs:
-            # Convert kwargs to dotlist format for OmegaConf
-            kwargs_list = [f"{k}={v}" for k, v in kwargs.items()]
-            update_config = OmegaConf.from_dotlist(kwargs_list)
-            app_config = OmegaConf.merge(app_config, update_config)
-
-        # Convert OmegaConf DictConfig to structured AppConfig object
-        return OmegaConf.to_object(app_config)

llmflow/config/mock_config.yaml

@@ -1,58 +0,0 @@
-# demo config.yaml
-
-http_service:
-  host: "0.0.0.0"
-  port: 8001
-  timeout_keep_alive: 600
-  limit_concurrency: 64
-
-thread_pool:
-  max_workers: 10
-
-api:
-  retriever: mock1_op->[mock4_op->mock2_op|mock5_op]->[mock3_op|mock6_op]
-  summarizer: mock1_op->[mock4_op->mock2_op|mock5_op]->mock3_op
-  vector_store: mock6_op
-
-op:
-  mock1_op:
-    backend: mock1_op
-    llm: default
-    vector_store: default
-    params:
-      a: 1
-      b: 2
-  mock2_op:
-    backend: mock2_op
-    params:
-      a: 1
-  mock3_op:
-    backend: mock3_op
-  mock4_op:
-    backend: mock4_op
-  mock5_op:
-    backend: mock5_op
-  mock6_op:
-    backend: mock6_op
-
-llm:
-  default:
-    backend: openai_compatible
-    model_name: qwen3-32b
-    params:
-      temperature: 0.6
-
-embedding_model:
-  default:
-    backend: openai_compatible
-    model_name: text-embedding-v4
-    params:
-      dimensions: 1024
-
-vector_store:
-  default:
-    backend: elasticsearch
-    embedding_model: default
-    params:
-      hosts: "http://localhost:9200"
-

llmflow/embedding_model/__init__.py

@@ -1,5 +0,0 @@
-from llmflow.utils.registry import Registry
-
-EMBEDDING_MODEL_REGISTRY = Registry()
-
-from llmflow.embedding_model.openai_compatible_embedding_model import OpenAICompatibleEmbeddingModel

llmflow/enumeration/agent_state.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class AgentState(str, Enum):
-    IDLE = "idle"
-    RUNNING = "running"
-    COMPLETE = "complete"
-    FAILED = "failed"

llmflow/llm/__init__.py

@@ -1,5 +0,0 @@
-from llmflow.utils.registry import Registry
-
-LLM_REGISTRY = Registry()
-
-from llmflow.llm.openai_compatible_llm import OpenAICompatibleBaseLLM

llmflow/llm/openai_compatible_llm.py

@@ -1,283 +0,0 @@
-import os
-from typing import List
-
-from dotenv import load_dotenv
-from loguru import logger
-from openai import OpenAI
-from openai.types import CompletionUsage
-from pydantic import Field, PrivateAttr, model_validator
-
-from llmflow.enumeration.chunk_enum import ChunkEnum
-from llmflow.enumeration.role import Role
-from llmflow.llm import LLM_REGISTRY
-from llmflow.llm.base_llm import BaseLLM
-from llmflow.schema.message import Message, ToolCall
-from llmflow.tool.base_tool import BaseTool
-
-
-@LLM_REGISTRY.register("openai_compatible")
-class OpenAICompatibleBaseLLM(BaseLLM):
-    """
-    OpenAI-compatible LLM implementation supporting streaming and tool calls.
-    
-    This class implements the BaseLLM interface for OpenAI-compatible APIs,
-    including support for:
-    - Streaming responses with different chunk types (thinking, answer, tools)
-    - Tool calling with parallel execution
-    - Reasoning/thinking content from supported models
-    - Robust error handling and retries
-    """
-
-    # API configuration
-    api_key: str = Field(default_factory=lambda: os.getenv("LLM_API_KEY"), description="API key for authentication")
-    base_url: str = Field(default_factory=lambda: os.getenv("LLM_BASE_URL"),
-                          description="Base URL for the API endpoint")
-    _client: OpenAI = PrivateAttr()
-
-    @model_validator(mode="after")
-    def init_client(self):
-        """
-        Initialize the OpenAI client after model validation.
-        
-        This validator runs after all field validation is complete,
-        ensuring we have valid API credentials before creating the client.
-        
-        Returns:
-            Self for method chaining
-        """
-        self._client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-        return self
-
-    def stream_chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
-        """
-        Stream chat completions from OpenAI-compatible API.
-        
-        This method handles streaming responses and categorizes chunks into different types:
-        - THINK: Reasoning/thinking content from the model
-        - ANSWER: Regular response content
-        - TOOL: Tool calls that need to be executed
-        - USAGE: Token usage statistics
-        - ERROR: Error information
-        
-        Args:
-            messages: List of conversation messages
-            tools: Optional list of tools available to the model
-            **kwargs: Additional parameters
-            
-        Yields:
-            Tuple of (chunk_content, ChunkEnum) for each streaming piece
-        """
-        for i in range(self.max_retries):
-            try:
-                # Create streaming completion request
-                completion = self._client.chat.completions.create(
-                    model=self.model_name,
-                    messages=[x.simple_dump() for x in messages],
-                    seed=self.seed,
-                    top_p=self.top_p,
-                    stream=True,
-                    stream_options=self.stream_options,
-                    temperature=self.temperature,
-                    extra_body={"enable_thinking": self.enable_thinking},  # Enable reasoning mode
-                    tools=[x.simple_dump() for x in tools] if tools else None,
-                    tool_choice=self.tool_choice,
-                    parallel_tool_calls=self.parallel_tool_calls)
-
-                # Initialize tool call tracking
-                ret_tools = []  # Accumulate tool calls across chunks
-                is_answering = False  # Track when model starts answering
-
-                # Process each chunk in the streaming response
-                for chunk in completion:
-                    # Handle chunks without choices (usually usage info)
-                    if not chunk.choices:
-                        yield chunk.usage, ChunkEnum.USAGE
-
-                    else:
-                        delta = chunk.choices[0].delta
-
-                        # Handle reasoning/thinking content (model's internal thoughts)
-                        if hasattr(delta, 'reasoning_content') and delta.reasoning_content is not None:
-                            yield delta.reasoning_content, ChunkEnum.THINK
-
-                        else:
-                            # Mark transition from thinking to answering
-                            if not is_answering:
-                                is_answering = True
-
-                            # Handle regular response content
-                            if delta.content is not None:
-                                yield delta.content, ChunkEnum.ANSWER
-
-                            # Handle tool calls (function calling)
-                            if delta.tool_calls is not None:
-                                for tool_call in delta.tool_calls:
-                                    index = tool_call.index
-
-                                    # Ensure we have enough tool call slots
-                                    while len(ret_tools) <= index:
-                                        ret_tools.append(ToolCall(index=index))
-
-                                    # Accumulate tool call information across chunks
-                                    if tool_call.id:
-                                        ret_tools[index].id += tool_call.id
-
-                                    if tool_call.function and tool_call.function.name:
-                                        ret_tools[index].name += tool_call.function.name
-
-                                    if tool_call.function and tool_call.function.arguments:
-                                        ret_tools[index].arguments += tool_call.function.arguments
-
-                # Yield completed tool calls after streaming finishes
-                if ret_tools:
-                    tool_dict = {x.name: x for x in tools} if tools else {}
-                    for tool in ret_tools:
-                        # Only yield tool calls that correspond to available tools
-                        if tool.name not in tool_dict:
-                            continue
-
-                        yield tool, ChunkEnum.TOOL
-
-                return  # Success - exit retry loop
-
-            except Exception as e:
-                logger.exception(f"stream chat with model={self.model_name} encounter error with e={e.args}")
-
-                # Handle retry logic
-                if i == self.max_retries - 1 and self.raise_exception:
-                    raise e
-                else:
-                    yield e.args, ChunkEnum.ERROR
-
-    def _chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs) -> Message:
-        """
-        Perform a complete chat completion by aggregating streaming chunks.
-        
-        This method consumes the entire streaming response and combines all
-        chunks into a single Message object. It separates reasoning content,
-        regular answer content, and tool calls.
-        
-        Args:
-            messages: List of conversation messages
-            tools: Optional list of tools available to the model
-            **kwargs: Additional parameters
-            
-        Returns:
-            Complete Message with all content aggregated
-        """
-        # Initialize content accumulators
-        reasoning_content = ""  # Model's internal reasoning
-        answer_content = ""  # Final response content
-        tool_calls = []  # List of tool calls to execute
-
-        # Consume streaming response and aggregate chunks by type
-        for chunk, chunk_enum in self.stream_chat(messages, tools, **kwargs):
-            if chunk_enum is ChunkEnum.THINK:
-                reasoning_content += chunk
-
-            elif chunk_enum is ChunkEnum.ANSWER:
-                answer_content += chunk
-
-            elif chunk_enum is ChunkEnum.TOOL:
-                tool_calls.append(chunk)
-
-            # Note: USAGE and ERROR chunks are ignored in non-streaming mode
-
-        # Construct complete response message
-        return Message(role=Role.ASSISTANT,
-                       reasoning_content=reasoning_content,
-                       content=answer_content,
-                       tool_calls=tool_calls)
-
-    def stream_print(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
-        """
-        Stream chat completions with formatted console output.
-        
-        This method provides a real-time view of the model's response,
-        with different formatting for different types of content:
-        - Thinking content is wrapped in <think></think> tags
-        - Answer content is printed directly
-        - Tool calls are formatted as JSON
-        - Usage statistics and errors are clearly marked
-        
-        Args:
-            messages: List of conversation messages
-            tools: Optional list of tools available to the model
-            **kwargs: Additional parameters
-        """
-        # Track which sections we've entered for proper formatting
-        enter_think = False  # Whether we've started printing thinking content
-        enter_answer = False  # Whether we've started printing answer content
-
-        # Process each streaming chunk with appropriate formatting
-        for chunk, chunk_enum in self.stream_chat(messages, tools, **kwargs):
-            if chunk_enum is ChunkEnum.USAGE:
-                # Display token usage statistics
-                if isinstance(chunk, CompletionUsage):
-                    print(f"\n<usage>{chunk.model_dump_json(indent=2)}</usage>")
-                else:
-                    print(f"\n<usage>{chunk}</usage>")
-
-            elif chunk_enum is ChunkEnum.THINK:
-                # Format thinking/reasoning content
-                if not enter_think:
-                    enter_think = True
-                    print("<think>\n", end="")
-                print(chunk, end="")
-
-            elif chunk_enum is ChunkEnum.ANSWER:
-                # Format regular answer content
-                if not enter_answer:
-                    enter_answer = True
-                    # Close thinking section if we were in it
-                    if enter_think:
-                        print("\n</think>")
-                print(chunk, end="")
-
-            elif chunk_enum is ChunkEnum.TOOL:
-                # Format tool calls as structured JSON
-                assert isinstance(chunk, ToolCall)
-                print(f"\n<tool>{chunk.model_dump_json(indent=2)}</tool>", end="")
-
-            elif chunk_enum is ChunkEnum.ERROR:
-                # Display error information
-                print(f"\n<error>{chunk}</error>", end="")
-
-
-def main():
-    """
-    Demo function to test the OpenAI-compatible LLM implementation.
-    
-    This function demonstrates:
-    1. Basic chat without tools
-    2. Chat with tool usage (search and code tools)
-    3. Real-time streaming output formatting
-    """
-    from llmflow.tool.dashscope_search_tool import DashscopeSearchTool
-    from llmflow.tool.code_tool import CodeTool
-    from llmflow.enumeration.role import Role
-
-    # Load environment variables for API credentials
-    load_dotenv()
-
-    # Initialize the LLM with a specific model
-    model_name = "qwen-max-2025-01-25"
-    llm = OpenAICompatibleBaseLLM(model_name=model_name)
-
-    # Set up available tools
-    tools: List[BaseTool] = [DashscopeSearchTool(), CodeTool()]
-
-    # Test 1: Simple greeting without tools
-    print("=== Test 1: Simple Chat ===")
-    llm.stream_print([Message(role=Role.USER, content="hello")], [])
-
-    print("\n" + "=" * 20)
-
-    # Test 2: Complex query that might use tools
-    print("\n=== Test 2: Chat with Tools ===")
-    llm.stream_print([Message(role=Role.USER, content="What's the weather like in Beijing today?")], tools)
-
-
-if __name__ == "__main__":
-    main()
-    # Launch with: python -m llmflow.llm.openai_compatible_llm

llmflow/mcp_server.py

@@ -1,110 +0,0 @@
-import sys
-from typing import List
-
-from dotenv import load_dotenv
-from fastmcp import FastMCP
-
-from llmflow.service.llmflow_service import LLMFlowService
-
-load_dotenv()
-
-mcp = FastMCP("llmflow")
-service = LLMFlowService(sys.argv[1:])
-
-
-@mcp.tool
-def retriever(query: str,
-              messages: List[dict] = None,
-              top_k: int = 1,
-              workspace_id: str = "default",
-              config: dict = None) -> dict:
-    """
-    Retrieve experiences from the workspace based on a query.
-
-    Args:
-        query: Query string
-        messages: List of messages
-        top_k: Number of top experiences to retrieve
-        workspace_id: Workspace identifier
-        config: Additional configuration parameters
-
-    Returns:
-        Dictionary containing retrieved experiences
-    """
-    return service(api="retriever", request={
-        "query": query,
-        "messages": messages if messages else [],
-        "top_k": top_k,
-        "workspace_id": workspace_id,
-        "config": config if config else {},
-    }).model_dump()
-
-
-@mcp.tool
-def summarizer(traj_list: List[dict], workspace_id: str = "default", config: dict = None) -> dict:
-    """
-    Summarize trajectories into experiences.
-
-    Args:
-        traj_list: List of trajectories
-        workspace_id: Workspace identifier
-        config: Additional configuration parameters
-
-    Returns:
-        experiences
-    """
-    return service(api="summarizer", request={
-        "traj_list": traj_list,
-        "workspace_id": workspace_id,
-        "config": config if config else {},
-    }).model_dump()
-
-
-@mcp.tool
-def vector_store(action: str,
-                 src_workspace_id: str = "",
-                 workspace_id: str = "",
-                 path: str = "./",
-                 config: dict = None) -> dict:
-    """
-    Perform vector store operations.
-
-    Args:
-        action: Action to perform (e.g., "copy", "delete", "dump", "load")
-        src_workspace_id: Source workspace identifier
-        workspace_id: Workspace identifier
-        path: Path to the vector store
-        config: Additional configuration parameters
-
-    Returns:
-        Dictionary containing the result of the vector store operation
-    """
-    return service(api="vector_store", request={
-        "action": action,
-        "src_workspace_id": src_workspace_id,
-        "workspace_id": workspace_id,
-        "path": path,
-        "config": config if config else {},
-    }).model_dump()
-
-
-def main():
-    mcp_transport: str = service.init_app_config.mcp_transport
-    if mcp_transport == "sse":
-        mcp.run(transport="sse", host=service.http_service_config.host, port=service.http_service_config.port)
-    elif mcp_transport == "stdio":
-        mcp.run(transport="stdio")
-    else:
-        raise ValueError(f"Unsupported mcp transport: {mcp_transport}")
-
-
-if __name__ == "__main__":
-    main()
-
-# start with:
-# llmflow_mcp \
-#   mcp_transport=stdio \
-#   http_service.port=8001 \
-#   llm.default.model_name=qwen3-32b \
-#   embedding_model.default.model_name=text-embedding-v4 \
-#   vector_store.default.backend=local_file

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