flowllm 0.1.1__tar.gz → 0.1.3__tar.gz

{flowllm-0.1.1 → flowllm-0.1.3}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: flowllm
-Version: 0.1.1
-Summary: build llm flow
+Version: 0.1.3
+Summary: A flexible framework for building LLM-powered flows and mcp services
+Author-email: FlowLLM Team <flowllm@example.com>
+Maintainer-email: FlowLLM Team <flowllm@example.com>
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -204,398 +206,49 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
         
-Classifier: Programming Language :: Python :: 3
+Keywords: llm,ai,flow,framework,openai,chatgpt,language-model,mcp,http
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dashscope>=1.19.1
-Requires-Dist: elasticsearch>=8.14.0
-Requires-Dist: fastapi>=0.115.13
-Requires-Dist: fastmcp>=2.10.6
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp>=1.9.4
-Requires-Dist: numpy>=2.3.0
-Requires-Dist: openai>=1.88.0
-Requires-Dist: pydantic>=2.11.7
-Requires-Dist: PyYAML>=6.0.2
-Requires-Dist: Requests>=2.32.4
-Requires-Dist: uvicorn>=0.34.3
-Requires-Dist: setuptools>=75.0
 Requires-Dist: akshare
+Requires-Dist: beautifulsoup4
+Requires-Dist: dashscope
+Requires-Dist: elasticsearch
+Requires-Dist: fastapi
+Requires-Dist: fastmcp
+Requires-Dist: httpx
+Requires-Dist: litellm
+Requires-Dist: loguru
+Requires-Dist: mcp
+Requires-Dist: numpy
+Requires-Dist: openai
+Requires-Dist: pandas
+Requires-Dist: pydantic
+Requires-Dist: PyYAML
+Requires-Dist: ray
+Requires-Dist: requests
+Requires-Dist: scikit-learn
+Requires-Dist: tavily-python
+Requires-Dist: tqdm
+Requires-Dist: urllib3
+Requires-Dist: uvicorn[standard]
+Requires-Dist: chromadb
+Requires-Dist: elasticsearch
+Requires-Dist: ray
+Provides-Extra: distributed
+Requires-Dist: ray; extra == "distributed"
+Provides-Extra: all
+Requires-Dist: flowllm[distributed]; extra == "all"
 Dynamic: license-file
-
-# flowllm
-
-[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
-
-flowllm is a flexible large language model workflow framework that provides a modular pipeline architecture for building complex AI applications. The framework supports multiple LLM providers, vector storage backends, and tool integrations, enabling you to easily build Retrieval-Augmented Generation (RAG), intelligent agents, and other AI-powered applications.
-
-## 🚀 Key Features
-
-### 🔧 Modular Architecture
-- **Pipeline System**: Flexible pipeline configuration supporting both serial and parallel operations
-- **Operation Registry**: Extensible operation registry with support for custom operations
-- **Configuration-Driven**: Manage entire applications through YAML configuration files
-
-### 🤖 LLM Support
-- **Multi-Provider Compatible**: Support for OpenAI-compatible APIs
-- **Streaming Responses**: Real-time streaming output support
-- **Tool Calling**: Built-in tool calling and parallel execution support
-- **Reasoning Mode**: Chain-of-thought reasoning support
-
-### 📚 Vector Storage
-- **Multi-Backend Support**: 
-  - Elasticsearch
-  - ChromaDB
-  - Local file storage
-- **Embedding Models**: Support for multiple embedding models
-- **Workspace Management**: Multi-tenant vector storage management
-
-### 🛠️ Rich Tool Ecosystem
-- **Code Execution**: Python code execution tool
-- **Web Search**: Integrated Tavily and DashScope search
-- **MCP Protocol**: Model Context Protocol support
-- **Termination Control**: Intelligent conversation termination management
-
-### 🌐 API Services
-- **RESTful API**: FastAPI-powered HTTP services
-- **MCP Server**: Model Context Protocol server support
-- **Multiple Endpoints**: Retriever, summarizer, vector store, agent APIs
-
-## 📦 Installation
-
-### Prerequisites
-- Python 3.12+
-- pip or poetry
-
-### Installation Steps
-
-```bash
-# Clone the repository
-git clone https://github.com/your-username/flowllm.git
-cd flowllm
-
-# Install dependencies
-pip install -e .
-
-# Or using poetry
-poetry install
-```
-
-### Environment Configuration
-
-Copy the environment template:
-```bash
-cp example.env .env
-```
-
-Edit the `.env` file to configure necessary API keys:
-
-```bash
-# LLM Configuration
-LLM_API_KEY=sk-your-llm-api-key
-LLM_BASE_URL=https://your-llm-endpoint/v1
-
-# Embedding Model Configuration
-EMBEDDING_API_KEY=sk-your-embedding-api-key
-EMBEDDING_BASE_URL=https://your-embedding-endpoint/v1
-
-# Elasticsearch (Optional)
-ES_HOSTS=http://localhost:9200
-
-# DashScope Search (Optional)
-DASHSCOPE_API_KEY=sk-your-dashscope-key
-```
-
-## 🏃 Quick Start
-
-### 1. Start HTTP Service
-
-```bash
-flowllm \
-  http_service.port=8001 \
-  llm.default.model_name=qwen3-32b \
-  embedding_model.default.model_name=text-embedding-v4 \
-  vector_store.default.backend=local_file
-```
-
-### 2. Start MCP Server
-
-```bash
-flowllm_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
-```
-
-### 3. API Usage Examples
-
-#### Retriever API
-```python
-import requests
-
-response = requests.post('http://localhost:8001/retriever', json={
-    "query": "What is artificial intelligence?",
-    "top_k": 5,
-    "workspace_id": "default",
-    "config": {}
-})
-print(response.json())
-```
-
-#### Agent API
-```python
-response = requests.post('http://localhost:8001/agent', json={
-    "query": "Help me search for the latest AI technology trends",
-    "workspace_id": "default",
-    "config": {}
-})
-print(response.json())
-```
-
-## ⚙️ Configuration Guide
-
-### Pipeline Configuration Syntax
-
-flowllm uses an intuitive string syntax to define operation pipelines:
-
-```yaml
-api:
-  # Serial execution: op1 -> op2 -> op3
-  retriever: recall_vector_store_op->summarizer_op
-  
-  # Parallel execution: [op1 | op2] runs in parallel
-  summarizer: mock1_op->[mock4_op->mock2_op|mock5_op]->mock3_op
-  
-  # Mixed mode: combination of serial and parallel
-  agent: react_v1_op
-```
-
-### Complete Configuration Example
-
-```yaml
-# HTTP Service Configuration
-http_service:
-  host: "0.0.0.0"
-  port: 8001
-  timeout_keep_alive: 600
-  limit_concurrency: 64
-
-# Thread Pool Configuration
-thread_pool:
-  max_workers: 10
-
-# API Pipeline Definitions
-api:
-  retriever: recall_vector_store_op
-  summarizer: update_vector_store_op
-  vector_store: vector_store_action_op
-  agent: react_v1_op
-
-# Operation Configuration
-op:
-  react_v1_op:
-    backend: react_v1_op
-    llm: default
-    params:
-      max_steps: 10
-      tool_names: "code_tool,tavily_search_tool,terminate_tool"
-
-# LLM Configuration
-llm:
-  default:
-    backend: openai_compatible
-    model_name: qwen3-32b
-    params:
-      temperature: 0.6
-      max_retries: 5
-
-# Embedding Model Configuration
-embedding_model:
-  default:
-    backend: openai_compatible
-    model_name: text-embedding-v4
-    params:
-      dimensions: 1024
-
-# Vector Store Configuration
-vector_store:
-  default:
-    backend: local_file  # or elasticsearch, chroma
-    embedding_model: default
-    params:
-      store_dir: "./vector_store_data"
-```
-
-## 🧩 Architecture Design
-
-### Core Components
-
-```
-┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
-│   FastAPI App   │    │   MCP Server    │    │  Configuration  │
-│                 │    │                 │    │     Parser      │
-└─────────────────┘    └─────────────────┘    └─────────────────┘
-         │                       │                       │
-         └───────────────────────┼───────────────────────┘
-                                 │
-                    ┌─────────────────┐
-                    │  flowllm Service │
-                    └─────────────────┘
-                             │
-                    ┌─────────────────┐
-                    │    Pipeline     │
-                    │    Context      │
-                    └─────────────────┘
-                             │
-         ┌───────────────────┼───────────────────┐
-         │                   │                   │
-┌─────────────┐    ┌─────────────┐    ┌─────────────┐
-│ Operations  │    │    Tools    │    │Vector Stores│
-│             │    │             │    │             │
-│ • ReAct     │    │ • Code      │    │ • File      │
-│ • Recall    │    │ • Search    │    │ • ES        │
-│ • Update    │    │ • MCP       │    │ • Chroma    │
-│ • Mock      │    │ • Terminate │    │             │
-└─────────────┘    └─────────────┘    └─────────────┘
-```
-
-### Data Flow
-
-```
-Request → Configuration → Pipeline → Operations → Tools/VectorStore → Response
-```
-
-## 🔧 Development Guide
-
-### Custom Operations
-
-```python
-from old.op import OP_REGISTRY
-from old.op.base_op import BaseOp
-
-
-@OP_REGISTRY.register()
-class CustomOp(BaseOp):
-    def execute(self):
-        # Implement your custom logic
-        request = self.context.request
-        response = self.context.response
-
-        # Process request
-        result = self.process_data(request.query)
-
-        # Update response
-        response.metadata["custom_result"] = result
-```
-
-### Custom Tools
-
-```python
-from old.tool import TOOL_REGISTRY
-from old.tool.base_tool import BaseTool
-
-
-@TOOL_REGISTRY.register()
-class CustomTool(BaseTool):
-    name: str = "custom_tool"
-    description: str = "Custom tool description"
-    parameters: dict = {
-        "type": "object",
-        "properties": {
-            "input": {"type": "string", "description": "Input parameter"}
-        },
-        "required": ["input"]
-    }
-
-    def _execute(self, input: str, **kwargs):
-        # Implement tool logic
-        return f"Processing result: {input}"
-```
-
-### Custom Vector Stores
-
-```python
-from old.vector_store import VECTOR_STORE_REGISTRY
-from old.vector_store.base_vector_store import BaseVectorStore
-
-
-@VECTOR_STORE_REGISTRY.register("custom_store")
-class CustomVectorStore(BaseVectorStore):
-    def search(self, query: str, top_k: int = 10, **kwargs):
-        # Implement search logic
-        pass
-
-    def insert(self, nodes: List[VectorNode], **kwargs):
-        # Implement insertion logic
-        pass
-```
-
-## 🧪 Testing
-
-```bash
-# Run tests
-pytest
-
-# Run specific tests
-pytest tests/test_pipeline.py
-
-# Generate coverage report
-pytest --cov=flowllm tests/
-```
-
-## 🤝 Contributing
-
-We welcome community contributions! Please follow these steps:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/AmazingFeature`)
-3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
-4. Push to the branch (`git push origin feature/AmazingFeature`)
-5. Open a Pull Request
-
-### Development Environment Setup
-
-```bash
-# Install development dependencies
-pip install -e ".[dev]"
-
-# Install pre-commit hooks
-pre-commit install
-
-# Run code formatting
-black flowllm/
-isort flowllm/
-
-# Run type checking
-mypy flowllm/
-```
-
-## 📚 Documentation
-
-- [API Documentation](docs/api.md)
-- [Configuration Guide](docs/configuration.md)
-- [Operations Development](docs/operations.md)
-- [Tools Development](docs/tools.md)
-- [Deployment Guide](docs/deployment.md)
-
-## 🐛 Bug Reports
-
-If you find bugs or have feature requests, please create an issue on [GitHub Issues](https://github.com/your-username/flowllm/issues).
-
-## 📄 License
-
-This project is licensed under the Apache License 2.0. See the [LICENSE](LICENSE) file for details.
-
-## 🙏 Acknowledgments
-
-Thanks to all developers and community members who have contributed to the flowllm project.
-
----
-
-**flowllm** - Making AI workflow development simple and powerful 🚀

flowllm-0.1.3/flowllm/__init__.py

@@ -0,0 +1,25 @@
+import os
+
+from flowllm.utils.logger_utils import init_logger
+
+init_logger()
+
+from flowllm.utils.common_utils import load_env
+
+load_env()
+
+from flowllm import embedding_model
+from flowllm import llm
+from flowllm import storage
+
+if not os.environ.get("FLOW_USE_FRAMEWORK", "").lower() == "true":
+    from flowllm import flow
+    from flowllm import op
+
+from flowllm import service
+
+from flowllm.context.service_context import C
+from flowllm.op import BaseOp, BaseRayOp, BaseLLMOp
+
+__version__ = "0.1.3"
+

flowllm-0.1.3/flowllm/app.py

@@ -0,0 +1,15 @@
+import sys
+
+from flowllm.service.base_service import BaseService
+
+
+def main():
+    with BaseService.get_service(*sys.argv[1:]) as service:
+        service()
+
+
+if __name__ == "__main__":
+    main()
+
+# python -m build
+# twine upload dist/*

flowllm-0.1.3/flowllm/client/__init__.py

@@ -0,0 +1,25 @@
+"""
+FlowLLM service clients module
+
+This module provides various client implementations for interacting with FlowLLM services:
+
+- HttpClient: Synchronous HTTP client for FlowLLM HTTP service
+- AsyncHttpClient: Asynchronous HTTP client for FlowLLM HTTP service  
+- MCPClient: Asynchronous client for FlowLLM MCP (Model Context Protocol) service
+- SyncMCPClient: Synchronous wrapper around MCPClient for easier synchronous usage
+
+Each client provides methods to execute tool flows, list available flows, and perform
+health checks on the respective services.
+"""
+
+from .async_http_client import AsyncHttpClient
+from .http_client import HttpClient
+from .mcp_client import MCPClient
+from .sync_mcp_client import SyncMCPClient
+
+__all__ = [
+    "HttpClient",
+    "AsyncHttpClient", 
+    "MCPClient",
+    "SyncMCPClient"
+]

flowllm-0.1.3/flowllm/client/async_http_client.py

@@ -0,0 +1,81 @@
+from typing import Dict
+
+import httpx
+
+from flowllm.schema.flow_response import FlowResponse
+
+
+class AsyncHttpClient:
+    """Async client for interacting with FlowLLM HTTP service"""
+
+    def __init__(self, base_url: str = "http://localhost:8001", timeout: float = 3600.0):
+        """
+        Initialize async HTTP client
+
+        Args:
+            base_url: Base URL of the FlowLLM HTTP service
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')  # Remove trailing slash for consistent URL formatting
+        self.timeout = timeout
+        self.client = httpx.AsyncClient(timeout=timeout)  # Create async HTTP client with timeout
+
+    async def __aenter__(self):
+        """Async context manager entry - returns self for 'async with' usage"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit - ensures proper cleanup of HTTP client"""
+        await self.client.aclose()
+
+    async def close(self):
+        """Explicitly close the HTTP client connection"""
+        await self.client.aclose()
+
+    async def health_check(self) -> Dict[str, str]:
+        """
+        Perform health check on the FlowLLM service
+        
+        Returns:
+            Dict containing health status information from the service
+            
+        Raises:
+            httpx.HTTPStatusError: If the service is not healthy or unreachable
+        """
+        response = await self.client.get(f"{self.base_url}/health")
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        return response.json()
+
+    async def execute_tool_flow(self, flow_name: str, **kwargs) -> FlowResponse:
+        """
+        Execute a specific tool flow on the FlowLLM service
+        
+        Args:
+            flow_name: Name of the tool flow to execute
+            **kwargs: Additional parameters to pass to the tool flow
+            
+        Returns:
+            FlowResponse object containing the execution results
+            
+        Raises:
+            httpx.HTTPStatusError: If the request fails or flow execution errors
+        """
+        endpoint = f"{self.base_url}/{flow_name}"
+        response = await self.client.post(endpoint, json=kwargs)  # Send flow parameters as JSON
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        result_data = response.json()
+        return FlowResponse(**result_data)  # Parse response into FlowResponse schema
+
+    async def list_tool_flows(self) -> list:
+        """
+        Get list of available tool flows from the FlowLLM service
+        
+        Returns:
+            List of available tool flow names and their metadata
+            
+        Raises:
+            httpx.HTTPStatusError: If the service is unreachable or returns an error
+        """
+        response = await self.client.get(f"{self.base_url}/list")
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        return response.json()

flowllm-0.1.3/flowllm/client/http_client.py

@@ -0,0 +1,81 @@
+from typing import Dict
+
+import httpx
+
+from flowllm.schema.flow_response import FlowResponse
+
+
+class HttpClient:
+    """Client for interacting with FlowLLM HTTP service"""
+
+    def __init__(self, base_url: str = "http://localhost:8001", timeout: float = 3600.0):
+        """
+        Initialize HTTP client
+        
+        Args:
+            base_url: Base URL of the FlowLLM HTTP service
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')  # Remove trailing slash for consistent URL formatting
+        self.timeout = timeout
+        self.client = httpx.Client(timeout=timeout)  # Create synchronous HTTP client with timeout
+
+    def __enter__(self):
+        """Context manager entry - returns self for 'with' usage"""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures proper cleanup of HTTP client"""
+        self.client.close()
+
+    def close(self):
+        """Explicitly close the HTTP client connection"""
+        self.client.close()
+
+    def health_check(self) -> Dict[str, str]:
+        """
+        Perform health check on the FlowLLM service
+        
+        Returns:
+            Dict containing health status information from the service
+            
+        Raises:
+            httpx.HTTPStatusError: If the service is not healthy or unreachable
+        """
+        response = self.client.get(f"{self.base_url}/health")
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        return response.json()
+
+    def execute_tool_flow(self, flow_name: str, **kwargs) -> FlowResponse:
+        """
+        Execute a specific tool flow on the FlowLLM service
+        
+        Args:
+            flow_name: Name of the tool flow to execute
+            **kwargs: Additional parameters to pass to the tool flow
+            
+        Returns:
+            FlowResponse object containing the execution results
+            
+        Raises:
+            httpx.HTTPStatusError: If the request fails or flow execution errors
+        """
+        endpoint = f"{self.base_url}/{flow_name}"
+        response = self.client.post(endpoint, json=kwargs)  # Send flow parameters as JSON
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        result_data = response.json()
+        return FlowResponse(**result_data)  # Parse response into FlowResponse schema
+
+    def list_tool_flows(self) -> list:
+        """
+        Get list of available tool flows from the FlowLLM service
+        
+        Returns:
+            List of available tool flow names and their metadata
+            
+        Raises:
+            httpx.HTTPStatusError: If the service is unreachable or returns an error
+        """
+        response = self.client.get(f"{self.base_url}/list")
+        response.raise_for_status()  # Raise exception for HTTP error status codes
+        return response.json()