Deploy Agentic RPA System v1

Dockerfile

@@ -1,44 +1,27 @@
 
-# Use NVIDIA CUDA image for GPU support
-FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04
+FROM python:3.10-slim
 
-# Set Environment Variables
-ENV DEBIAN_FRONTEND=noninteractive
-ENV PYTHONUNBUFFERED=1
-ENV PORT=7860
-
-# 1. Install System Dependencies
+# Install System Dependencies (PDF & Media)
 RUN apt-get update && apt-get install -y \
-    python3.10 \
-    python3-pip \
+    poppler-utils \
+    ffmpeg \
     git \
-    poppler-utils     ffmpeg \
-    libsm6 \
-    libxext6 \
     && rm -rf /var/lib/apt/lists/*
 
-# 2. Set Working Directory
 WORKDIR /app
 
-# 3. Create User (HF Requirement)
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+# Install Python Deps
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# 4. Install Python Requirements
-COPY --chown=user requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Copy Code
+COPY . .
 
-# 5. Copy Source Code
-COPY --chown=user src/ src/
-COPY --chown=user static/ static/
+# Create Directories for Data
+RUN mkdir -p src/data/docs src/data/blueprints my_workflows
 
-# 6. Setup Data Directory
-# Ensure the database can be written to
-RUN mkdir -p src/data/my_workflows && \
-    chmod -R 777 src/data
+# Set Permissions
+RUN chmod -R 777 src/data my_workflows
 
-# 7. Start the Server
-CMD ["uvicorn", "src.server:app", "--host", "0.0.0.0", "--port", "7860"]
+# Launch Server (HF Spaces use port 7860)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,8 @@
+
+import sys
+import os
+
+# Ensure src is in path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from src.server import app

requirements.txt

@@ -1,35 +1,21 @@
-# --- Core AI & LLM ---
-torch>=2.4.0
-transformers>=4.46.0
-accelerate>=1.0.0
-bitsandbytes>=0.44.1
-protobuf
-sentencepiece
 
-# --- Vision (Qwen2-VL) ---
-qwen-vl-utils
-timm
-einops
-pillow
-
-# --- RAG & Vector Database ---
-chromadb
-sentence-transformers
-
-# --- Server & Connectivity ---
+torch>=2.1.0
+transformers
+accelerate
+bitsandbytes
 fastapi
 uvicorn
 python-multipart
-pyngrok
-nest_asyncio
-
-# --- File Parsers ---
 pypdf
-python-docx
 pdf2image
-
-# --- Robustness & Tools ---
-json_repair
+python-docx
 duckduckgo-search
-lunardate
-pytz
+sqlalchemy
+psycopg2-binary
+qwen_vl_utils
+decord
+timm
+einops
+pillow
+json_repair
+pytz

src/agents/base.py

@@ -1,3 +1,4 @@
+
 from abc import ABC
 from src.core.engine import ModelEngine
 
@@ -10,7 +11,14 @@ class BaseAgent(ABC):
         asset = self.engine.load_model(self.role)
         model, tokenizer = asset['model'], asset['tokenizer']
         inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        
         gen_kwargs = self.engine.config.generation.copy()
         gen_kwargs.update(kwargs)
-        outputs = model.generate(**inputs, pad_token_id=tokenizer.eos_token_id, **gen_kwargs)
-        return tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True).strip()
+        
+        outputs = model.generate(
+            **inputs, 
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+            **gen_kwargs
+        )
+        return tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True).strip()

src/agents/coder.py

@@ -1,70 +1,27 @@
+
 from src.agents.base import BaseAgent
-from src.core.prompts import Prompts
-import json
-import os
+from src.core.agent_middleware import AgentMiddleware
 
 class CoderAgent(BaseAgent):
     def __init__(self, engine, memory):
         super().__init__(engine, "coder")
-        # Load Registry of Valid Modules
-        self.registry = {}
-        reg_path = "src/data/schemas/make_modules.json"
-        if os.path.exists(reg_path):
-            with open(reg_path, "r", encoding="utf-8") as f:
-                self.registry = json.load(f)
-
-    def get_relevant_schemas(self, task_description):
-        """
-        Simple RAG for Code: Finds module schemas mentioned in the task.
-        """
-        relevant_schemas = []
-        task_lower = task_description.lower()
-        
-        # Keyword mapping (Expand this list based on your registry)
-        keywords = {
-            "sheet": ["google-sheets:addRow", "google-sheets:updateRow"],
-            "mail": ["google-email:TriggerNewEmail", "google-email:CreateDraft"],
-            "webhook": ["gateway:CustomWebHook"],
-            "shopee": ["shopee:getOrder"],
-            "facebook": ["facebook:createPost"]
-        }
-        
-        for key, modules in keywords.items():
-            if key in task_lower:
-                for mod_name in modules:
-                    if mod_name in self.registry:
-                        # Format nicely for the prompt
-                        schema_snippet = json.dumps(self.registry[mod_name], indent=2)
-                        relevant_schemas.append(f"TEMPLATE FOR {mod_name}:\n{schema_snippet}")
-                        
-        return "\n\n".join(relevant_schemas)
+        self.middleware = AgentMiddleware()
 
     def write_code(self, task: str, plan: str, feedback: str = ""):
-        # 1. Retrieve Schemas
-        schemas = self.get_relevant_schemas(task + " " + plan)
-        
-        if not schemas:
-            schemas = "No specific templates found. Use standard Make.com JSON structure."
-
-        # 2. Build Prompt with Cheatsheet
-        prompt = f'''{Prompts.CODER_SYSTEM}
+        tools_def = self.middleware.get_workflow_tools()
+        db_schema = self.middleware.get_db_schema()
+        prompt = f'''<|im_start|>system
+You are the Lead Automation Engineer. Output VALID JSON Workflow definition.
+CONTEXT - SCHEMA:
+{db_schema}
+CONTEXT - PROTOCOL:
+{tools_def}
+RULES: Output ONLY JSON. No markdown.
+<|im_end|>
 <|im_start|>user
 TASK: {task}
-
-ARCHITECT PLAN:
-{plan}
-
---- CHEAT SHEET (USE THESE EXACT PARAMETERS) ---
-{schemas}
-------------------------------------------------
-
-INSTRUCTIONS:
-1. Generate the valid Make.com JSON blueprint.
-2. COPY the parameter names from the Cheat Sheet exactly.
-3. Map variables using double curly braces e.g. {{{{1.value}}}}.
-
-{f"FEEDBACK FROM PREVIOUS ERROR: {feedback}" if feedback else ""}
+PLAN: {plan}
 <|im_end|>
 <|im_start|>assistant
 '''
-        return self.generate(prompt, max_new_tokens=3000, temperature=0.1)
+        return self.generate(prompt, max_new_tokens=1024, temperature=0.1)

src/agents/manager.py

@@ -1,109 +1,56 @@
+
 import json
 import re
 from datetime import datetime
 import pytz
 from src.agents.base import BaseAgent
-from src.core.prompts import Prompts
+from src.core.agent_middleware import AgentMiddleware
 
 class ManagerAgent(BaseAgent):
-    def __init__(self, engine, memory):
+    def __init__(self, engine, memory, kb=None):
         super().__init__(engine, "manager")
         self.memory = memory
-        self.db_context = ""
-
-    def set_db_context(self, context_str):
-        self.db_context = context_str
-
-    def get_real_time(self):
-        tz = pytz.timezone('Asia/Ho_Chi_Minh')
-        return datetime.now(tz).strftime("%H:%M - %A, %d/%m/%Y")
-
-    def get_dynamic_context(self):
-        return f"{Prompts.SYSTEM_CONTEXT}\n\n[DATA]\n{self.db_context}"
-
-    def _extract_json(self, text):
-        try:
-            match = re.search(r"```json\n(.*?)\n```", text, re.DOTALL)
-            if match: return json.loads(match.group(1))
-            match = re.search(r"\{.*?\}", text, re.DOTALL)
-            if match: return json.loads(match.group(0))
-        except: pass
-        return None
-
-    # --- NEW: THE CRITIC LOGIC ---
-    def self_correct(self, user_input, initial_response):
-
-        # Asks the model to review its own answer for quality and hallucinations.
+        self.middleware = AgentMiddleware()
 
-        # 1. The Critique Prompt
-        critic_prompt = f'''<|im_start|>system
-You are a Senior Editor. Review the Assistant's response to the User.
-Check for:
-1. Vagueness (Does it actually answer the specific question?)
-2. Hallucinations (Did it invent features not in the store context?)
-3. Tone (Is it professional Vietnamese?)
-
-If the response is Good, output: "PASS"
-If Bad, output: "REWRITE: [Instructions on how to fix]"
-<|im_end|>
-<|im_start|>user
-User Question: "{user_input}"
-Store Context: "{self.db_context}"
-Assistant Draft: "{initial_response}"
-<|im_end|>
-<|im_start|>assistant
-'''
-        critique = self.generate(critic_prompt, max_new_tokens=128)
-
-        if "PASS" in critique:
-            return initial_response
+    def analyze_task(self, task: str, history_str: str = ""):
+        task_lower = task.lower().strip()
+        if any(x in task_lower for x in ["viết bài", "quảng cáo", "content"]): return {"category": "MARKETING"}
+        if any(x in task_lower for x in ["tạo", "build", "automation", "quy trình", "workflow"]): return {"category": "TECHNICAL"}
+        if any(x in task_lower for x in ["doanh thu", "tồn kho", "bán được", "sales"]): return {"category": "DATA_INTERNAL"}
+        return {"category": "GENERAL"}
 
-        # 2. The Refinement Prompt (If failed)
-        print(f"    [Critic] Refining response: {critique}")
-        fix_prompt = f'''<|im_start|>system
-You are the Retail Assistant. Rewrite your response based on this feedback: {critique}
-Keep it concise and helpful.
+    def plan(self, task: str, history_str: str = "", store_context: str = ""):
+        schema = self.middleware.get_db_schema()
+        prompt = f'''<|im_start|>system
+You are the Architect. Design a logical flow for this automation request.
+Available Data Schema:
+{schema}
+OUTPUT: A step-by-step logical plan.
 <|im_end|>
 <|im_start|>user
-Original Question: "{user_input}"
+REQUEST: {task}
 <|im_end|>
 <|im_start|>assistant
 '''
-        return self.generate(fix_prompt, max_new_tokens=1024)
-
-    def analyze_task(self, task: str, history_str: str = ""):
-        # (Keep your existing analysis logic here...)
-        # For brevity in this snippet, assuming the logic from Phase 22 serves well.
-        # ...
-        return {"category": "GENERAL"} # Placeholder for the snippet
+        return self.generate(prompt, max_new_tokens=512)
 
     def consult(self, task: str, context_data: str = "", history_str: str = "", store_context: str = ""):
-        sys_prompt = self.get_dynamic_context()
-
-        # 1. Draft
+        schema = self.middleware.get_db_schema()
         prompt = f'''<|im_start|>system
-{sys_prompt}
-CHAT HISTORY: {history_str}
+You are Project A, a Retail Assistant.
+DATABASE SCHEMA:
+{schema}
+HISTORY:
+{history_str}
 DATA: {context_data}
-INSTRUCTION: Answer helpfuly in Vietnamese.
+INSTRUCTION: Answer helpfully in Vietnamese.
 <|im_end|>
 <|im_start|>user
 {task}
 <|im_end|>
 <|im_start|>assistant
 '''
-        draft = self.generate(prompt, max_new_tokens=1024)
-
-        # 2. Critic Loop (The Upgrade)
-        final_response = self.self_correct(task, draft)
-        return final_response
-
-    # ... (Keep plan/review methods as they were)
-    def plan(self, task: str, history_str: str = "", store_context: str = ""):
-         return self.generate(f"<|im_start|>system\nArchitect.\n<|im_end|>\n<|im_start|>user\n{task}<|im_end|>\n<|im_start|>assistant\n", max_new_tokens=1500)
-
-    def review(self, task: str, code: str):
-         return {"status": "PASS"}
-
+        return self.generate(prompt, max_new_tokens=1024)
+    
     def write_marketing(self, task: str):
-         return self.generate(f"<|im_start|>system\nCopywriter.\n<|im_end|>\n<|im_start|>user\n{task}<|im_end|>\n<|im_start|>assistant\n", max_new_tokens=1024)
+        return self.generate(f"<|im_start|>system\nCopywriter.\n<|im_end|>\n<|im_start|>user\n{task}<|im_end|>\n<|im_start|>assistant\n", max_new_tokens=1024)

src/agents/researcher.py

@@ -1,32 +1,11 @@
+
 from src.agents.base import BaseAgent
-from duckduckgo_search import DDGS  # <--- FIXED IMPORT
+from duckduckgo_search import DDGS
 
 class ResearcherAgent(BaseAgent):
     def __init__(self, engine):
         super().__init__(engine, "researcher")
-
-    def search(self, query: str):
+    def search(self, query):
         try:
-            with DDGS() as ddgs:
-                # Max results 4 is usually enough for context
-                results = list(ddgs.text(query, max_results=4))
-                if not results: return "Search returned no results."
-                return str(results)
-        except Exception as e:
-            return f"Search failed: {e}"
-
-    def process(self, query: str):
-        raw_data = self.search(query)
-        
-        # Qwen prompt format
-        prompt = f'''<|im_start|>system
-You are a Research Assistant. Summarize the provided search data concisely in Vietnamese.
-Focus on facts relevant to Retail/Business.
-<|im_end|>
-<|im_start|>user
-QUERY: {query}
-RAW DATA: {raw_data}
-<|im_end|>
-<|im_start|>assistant
-'''
-        return self.generate(prompt, max_new_tokens=512)
+            with DDGS() as ddgs: return str(list(ddgs.text(query, max_results=4)))
+        except: return "Search failed."

src/agents/vision.py

@@ -1,84 +1,33 @@
+
 from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
 from qwen_vl_utils import process_vision_info
 import torch
 import os
-import logging
 
 class VisionAgent:
     def __init__(self):
-        print("👁️ [Vision] Initializing Qwen2-VL-2B (The Eye)...")
+        print("👁️ [Vision] Initializing Qwen2-VL-2B...")
         self.model_id = "Qwen/Qwen2-VL-2B-Instruct"
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
         try:
-            # Load with bfloat16 for efficiency on L4/A100, or float16 for T4
             dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
-            
-            # We use device_map="auto" to fit it in remaining VRAM
             self.model = Qwen2VLForConditionalGeneration.from_pretrained(
-                self.model_id, 
-                torch_dtype=dtype, 
-                device_map="auto"
+                self.model_id, torch_dtype=dtype, device_map="auto"
             )
-            
             self.processor = AutoProcessor.from_pretrained(self.model_id)
-            print("✅ Vision Agent Loaded (Unified Qwen Architecture).")
-        except Exception as e:
-            print(f"❌ Vision Load Failed: {e}")
-            self.model = None
-
-    def analyze_image(self, image_path, task_hint="OCR"):
-        """
-        Analyzes an image using Qwen2-VL.
-        """
-        if not self.model:
-            return "Vision model not loaded."
-
-        if not os.path.exists(image_path):
-            return f"Error: Image file not found at {image_path}"
+        except: self.model = None
 
-        # Determine Prompt based on intent
-        # Qwen2-VL understands natural language prompts better than Florence
-        if any(x in task_hint.lower() for x in ["marketing", "quảng cáo", "describe", "caption"]):
-            prompt_text = "Describe this image in detail for a marketing post."
-        elif "chart" in task_hint.lower() or "graph" in task_hint.lower():
-             prompt_text = "Analyze this chart. What are the key trends and numbers?"
-        else:
-            prompt_text = "Read all text in this image (OCR) and describe the layout."
-
-        # Prepare Inputs
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": image_path},
-                    {"type": "text", "text": prompt_text},
-                ],
-            }
-        ]
+    def analyze_media(self, file_path, task_hint="describe"):
+        if not self.model: return "Vision model not loaded."
+        media_content = {"type": "image", "image": file_path}
+        prompt_text = "Describe this image in detail."
+        if "ocr" in task_hint.lower(): prompt_text = "Read all text visible."
         
-        # Preprocessing
+        messages = [{"role": "user", "content": [media_content, {"type": "text", "text": prompt_text}]}]
         text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
         image_inputs, video_inputs = process_vision_info(messages)
+        inputs = self.processor(text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt").to(self.device)
         
-        inputs = self.processor(
-            text=[text],
-            images=image_inputs,
-            videos=video_inputs,
-            padding=True,
-            return_tensors="pt",
-        )
-        inputs = inputs.to(self.device)
-
-        # Generate
-        generated_ids = self.model.generate(**inputs, max_new_tokens=1024)
-        
-        # Decode
-        generated_ids_trimmed = [
-            out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
-        ]
-        output_text = self.processor.batch_decode(
-            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
-        )
-        
-        return f"[IMAGE ANALYSIS]\n{output_text[0]}"
+        gen_ids = self.model.generate(**inputs, max_new_tokens=1024)
+        gen_ids_trimmed = [out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, gen_ids)]
+        return self.processor.batch_decode(gen_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

src/core/agent_middleware.py

@@ -0,0 +1,46 @@
+
+from sqlalchemy import create_engine, text
+from src.core.config import Config
+
+class AgentMiddleware:
+    def __init__(self):
+        self.config = Config()
+        try:
+            self.engine = create_engine(self.config.DB_URL)
+        except:
+            self.engine = None
+
+    def get_db_schema(self):
+        if not self.engine: return "Database not connected."
+        schema_text = []
+        try:
+            with self.engine.connect() as conn:
+                if 'postgres' in self.config.DB_URL:
+                    sql = text("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'")
+                else:
+                    sql = text("SELECT name FROM sqlite_master WHERE type='table'")
+                
+                tables = conn.execute(sql).fetchall()
+                for t in tables:
+                    table_name = t[0]
+                    if table_name in ['sqlite_sequence', 'alembic_version']: continue
+                    try:
+                        cols = conn.execute(text(f"SELECT * FROM {table_name} LIMIT 0")).keys()
+                        schema_text.append(f"- TABLE {table_name.upper()}: {list(cols)}")
+                    except: pass
+            return "\n".join(schema_text)
+        except Exception as e:
+            return f"Error fetching schema: {e}"
+
+    def get_workflow_tools(self):
+        return """
+        [AVAILABLE WORKFLOW NODES]
+        1. 'google_sheet_read' { "sheetId": "...", "range": "A1:Z" }
+        2. 'google_sheet_write' { "sheetId": "...", "data": "{{parent.output}}", "mode": "append" }
+        3. 'gmail_send' { "to": "...", "subject": "...", "body": "..." }
+        4. 'filter' { "condition": "contains", "field": "status", "value": "active" }
+        5. 'database_query' { "query": "SELECT * FROM sales WHERE amount > 1000" }
+        
+        [OUTPUT FORMAT]
+        JSON with 'nodes' and 'edges'.
+        """

src/core/config.py

@@ -1,46 +1,39 @@
+
 import torch
 import os
 
 class Config:
     def __init__(self):
-        # Current file: src/core/config.py
-        # Go up 2 levels -> src/
-        self.SRC_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        
-        # Go up 3 levels -> Project Root (app/)
-        self.PROJECT_ROOT = os.path.dirname(self.SRC_ROOT)
-        
-        # FIX: Point Data to 'src/data' (Writable in Docker) instead of root 'data'
-        self.DATA_DIR = os.path.join(self.SRC_ROOT, 'data')
-        
-        # Database Path
-        self.DB_PATH = os.path.join(self.DATA_DIR, 'project_a.db')
-        
+        self.PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        self.DATA_DIR = os.path.join(self.PROJECT_ROOT, 'src', 'data')
+        
+        # Cloud DB Connection
+        raw_url = os.getenv("DATABASE_URL", "")
+        if raw_url.startswith("postgres://"):
+            self.DB_URL = raw_url.replace("postgres://", "postgresql+psycopg2://")
+        elif raw_url.startswith("postgresql://"):
+            self.DB_URL = raw_url.replace("postgresql://", "postgresql+psycopg2://")
+        else:
+            self.DB_URL = "sqlite:///:memory:" # Fallback if secret not set
+
         self.DOCS_DIR = os.path.join(self.DATA_DIR, 'docs') 
-        
-        # Ensure directories exist
         os.makedirs(self.DATA_DIR, exist_ok=True)
-        os.makedirs(self.DOCS_DIR, exist_ok=True)
         
-        self.SYSTEM_CONTEXT = "You are Project A, a Retail Assistant."
+        self.SYSTEM_CONTEXT = "You are Project A, a Retail Automation Architect."
 
-        # Model ID
+        # Model Config
         self.model_id = "sonthaiha/project-a-14b"
-
-        self.models = {
-            "manager": self.model_id,
-            "coder": self.model_id,
-            "researcher": self.model_id
-        }
+        self.models = { "manager": self.model_id, "coder": self.model_id, "researcher": self.model_id }
         
         self.quantization = {
             "load_in_4bit": True,
             "bnb_4bit_compute_dtype": torch.float16,
-            "bnb_4bit_quant_type": "nf4"
+            "bnb_4bit_quant_type": "nf4",
+            "bnb_4bit_use_double_quant": True,
         }
         
         self.generation = {
-            "max_new_tokens": 4096,
-            "temperature": 0.2,
+            "max_new_tokens": 2048,
+            "temperature": 0.1,
             "do_sample": True
-        }
+        }

src/core/context.py

@@ -1,38 +1,3 @@
-class ContextResolver:
-    def __init__(self, memory):
-        self.memory = memory
-        self.active_store = None
-    
-    def resolve_login(self, user_id):
-        """
-        Called when user logs in.
-        Returns:
-        - ('READY', context_string): If 1 store found.
-        - ('AMBIGUOUS', store_list): If multiple stores found.
-        - ('EMPTY', None): If no stores found.
-        """
-        stores = self.memory.get_user_stores(user_id)
-        
-        if not stores:
-            return "EMPTY", None
-            
-        if len(stores) == 1:
-            self.active_store = stores[0]
-            context = self._build_context_string(stores[0])
-            return "READY", context
-            
-        # If multiple stores, we need the user to pick one
-        return "AMBIGUOUS", stores
-
-    def set_active_store(self, store):
-        self.active_store = store
-        return self._build_context_string(store)
 
-    def _build_context_string(self, store):
-        return f'''
-        ACTIVE STORE CONTEXT (FROM DATABASE):
-        - Store Name: {store['name']}
-        - Industry: {store['industry']}
-        - Location: {store['location']}
-        - ID: {store['id']}
-        '''
+class ContextResolver:
+    def __init__(self, memory): self.memory = memory

src/core/engine.py

@@ -1,68 +1,42 @@
+
 import torch
 import gc
-import logging
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
 from src.core.config import Config
 
-logger = logging.getLogger("System")
-
 class ModelEngine:
     def __init__(self):
         self.config = Config()
         self.loaded_models = {}
-        # Clear VRAM before loading to prevent fragmentation
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
             gc.collect()
-            
         self._load_all_models()
 
     def _load_all_models(self):
         print("⚡ [Engine] Initializing Unified Architecture...")
-        
-        # 1. GROUP ROLES BY MODEL NAME
-        # This ensures we only load 'Qwen-14B' ONCE, even if used by 3 agents.
         unique_models = {}
         for role, model_name in self.config.models.items():
-            if model_name not in unique_models:
-                unique_models[model_name] = []
+            if model_name not in unique_models: unique_models[model_name] = []
             unique_models[model_name].append(role)
 
-        # 2. LOAD EACH UNIQUE MODEL ONCE
         for model_name, roles in unique_models.items():
-            role_list = ", ".join(roles).upper()
             print(f"   -> Loading Shared Model: {model_name}")
-            print(f"      (Assigned to: {role_list})...")
-            
             try:
                 tokenizer = AutoTokenizer.from_pretrained(model_name)
                 tokenizer.padding_side = "left"
                 if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token
 
-                # 4-bit Quantization is MANDATORY for 14B on L4 GPU
                 model = AutoModelForCausalLM.from_pretrained(
                     model_name,
                     quantization_config=BitsAndBytesConfig(**self.config.quantization),
                     device_map="auto",
                     trust_remote_code=True
                 )
-                
-                # Shared Asset
                 asset = {"model": model, "tokenizer": tokenizer}
-                
-                # Assign to all roles
-                for role in roles:
-                    self.loaded_models[role] = asset
-                    
+                for role in roles: self.loaded_models[role] = asset
             except Exception as e:
                 print(f"❌ Failed to load {model_name}: {e}")
-                raise e
-        
-        if torch.cuda.is_available():
-            free, total = torch.cuda.mem_get_info()
-            print(f"✅ VRAM Status: {(total-free)/1e9:.2f}GB / {total/1e9:.2f}GB Used.")
 
     def load_model(self, role: str):
-        if role not in self.loaded_models:
-            raise ValueError(f"Role {role} not loaded! Available: {list(self.loaded_models.keys())}")
-        return self.loaded_models[role]
+        return self.loaded_models[role]

src/core/integrations.py

@@ -1,60 +1,17 @@
+
 import json
-import time
-import os
-import re
 from json_repair import repair_json
 
 class IntegrationManager:
     def __init__(self, memory_manager):
         self.memory = memory_manager
-        
-        # FIX: Determine absolute path to writable directory
-        # src/core/integrations.py -> src/core/ -> src/ -> src/data/my_workflows
-        base_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        self.save_dir = os.path.join(base_path, "data", "my_workflows")
-        
-        # Ensure it exists (Should be writable now)
-        os.makedirs(self.save_dir, exist_ok=True)
-
-    def _sanitize_filename(self, name):
-        return re.sub(r'[^a-zA-Z0-9_-]', '_', name)
 
     def deploy_internal(self, store_id, blueprint_json, name="New Automation"):
-        print(f"    [Internal] Saving workflow '{name}'...")
-        
         try:
-            if isinstance(blueprint_json, str):
-                try:
-                    payload = json.loads(blueprint_json)
-                except:
-                    print("    [Warning] Malformed JSON. Repairing...")
-                    payload = repair_json(blueprint_json, return_objects=True)
-            else:
-                payload = blueprint_json
-                
-            if not payload: raise ValueError("Empty JSON")
-                
-        except Exception as e:
-            return {"status": "error", "message": f"Invalid JSON format: {e}"}
+            if isinstance(blueprint_json, str): payload = repair_json(blueprint_json, return_objects=True)
+            else: payload = blueprint_json
+            if 'nodes' not in payload: payload = {"nodes": payload, "edges": []}
+        except: return {"status": "error"}
 
-        # 1. SAVE TO DB
         wf_id = self.memory.save_workflow(store_id, name, payload)
-        
-        # 2. SAVE TO FILE
-        safe_name = self._sanitize_filename(name)
-        filename = os.path.join(self.save_dir, f"WF_{wf_id}_{safe_name}.json")
-        
-        with open(filename, "w", encoding="utf-8") as f:
-            json.dump(payload, f, indent=4, ensure_ascii=False)
-
-        # Return RELATIVE path for UI display if needed, or absolute
-        return {
-            "status": "success",
-            "workflow_id": wf_id,
-            "file_path": filename,
-            "message": "Workflow saved (Auto-Repaired)."
-        }
-
-    def post_to_social(self, platform, content):
-        time.sleep(1)
-        return {"status": "published", "link": "http://fb.com/post/123"}
+        return {"status": "success", "workflow_id": wf_id}

src/core/memory.py

@@ -1,102 +1,66 @@
-import sqlite3
+
 import json
-import os
-from datetime import datetime
+from sqlalchemy import create_engine, text
 from src.core.config import Config
+from datetime import datetime
 
 class MemoryManager:
     def __init__(self):
         self.config = Config()
-        os.makedirs(os.path.dirname(self.config.DB_PATH), exist_ok=True)
-        self.conn = sqlite3.connect(self.config.DB_PATH, check_same_thread=False)
-        self._init_db()
-        self._seed_saas_data()
-
-    def _init_db(self):
-        cursor = self.conn.cursor()
-        cursor.execute('''CREATE TABLE IF NOT EXISTS history
-                          (id INTEGER PRIMARY KEY, role TEXT, content TEXT, timestamp TEXT)''')
-        cursor.execute('''CREATE TABLE IF NOT EXISTS users
-                          (id INTEGER PRIMARY KEY, name TEXT, email TEXT)''')
-        cursor.execute('''CREATE TABLE IF NOT EXISTS stores
-                          (id INTEGER PRIMARY KEY, user_id INTEGER, name TEXT, 
-                           industry TEXT, location TEXT, platform_version TEXT)''')
-        cursor.execute('''CREATE TABLE IF NOT EXISTS sales
-                          (id INTEGER PRIMARY KEY, store_id INTEGER, date TEXT, amount REAL, category TEXT)''')
-        cursor.execute('''CREATE TABLE IF NOT EXISTS profile
-                          (key TEXT PRIMARY KEY, value TEXT)''')
-                          
-        # --- NEW: INTERNAL WORKFLOW STORAGE ---
-        # This simulates your Platform's Backend Database
-        cursor.execute('''CREATE TABLE IF NOT EXISTS workflows
-                          (id INTEGER PRIMARY KEY, 
-                           store_id INTEGER, 
-                           name TEXT, 
-                           status TEXT, 
-                           json_structure TEXT, 
-                           created_at TEXT)''')
-        self.conn.commit()
-
-    def _seed_saas_data(self):
-        cursor = self.conn.cursor()
-        cursor.execute("SELECT count(*) FROM users")
-        if cursor.fetchone()[0] == 0:
-            cursor.execute("INSERT INTO users (id, name, email) VALUES (1, 'Nguyen Van A', 'user@example.com')")
-            cursor.execute('''INSERT INTO stores (user_id, name, industry, location, platform_version) 
-                              VALUES (1, 'BabyWorld Cầu Giấy', 'Mom & Baby', 'Hanoi - Cau Giay', 'Pro_v2')''')
-            cursor.execute('''INSERT INTO stores (user_id, name, industry, location, platform_version) 
-                              VALUES (1, 'Cafe Sáng', 'F&B', 'Da Nang', 'Lite_v1')''')
-            # Seed Sales
-            today = datetime.now().strftime("%Y-%m-%d")
-            cursor.execute("INSERT INTO sales (store_id, date, amount, category) VALUES (1, ?, 2500000, 'Diapers')", (today,))
-            self.conn.commit()
+        try:
+            self.engine = create_engine(self.config.DB_URL)
+        except:
+            self.engine = None
 
-    def save_workflow(self, store_id, name, json_data):
-        """Saves the AI-generated design to your platform's DB."""
-        cursor = self.conn.cursor()
-        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        cursor.execute("INSERT INTO workflows (store_id, name, status, json_structure, created_at) VALUES (?, ?, ?, ?, ?)",
-                       (store_id, name, 'draft', json.dumps(json_data), now))
-        self.conn.commit()
-        return cursor.lastrowid
+    def get_conn(self): return self.engine.connect()
 
-    def get_user_stores(self, user_id):
-        cursor = self.conn.cursor()
-        cursor.execute("SELECT id, name, industry, location FROM stores WHERE user_id = ?", (user_id,))
-        return [{"id": r[0], "name": r[1], "industry": r[2], "location": r[3]} for r in cursor.fetchall()]
+    def get_user_workspaces(self, user_id):
+        if not self.engine: return [{"id": 1, "name": "Offline Store"}]
+        try:
+            with self.get_conn() as conn:
+                rows = conn.execute(text("SELECT id, name, type FROM workspaces WHERE user_id = :uid"), {"uid": str(user_id)}).fetchall()
+                if not rows: return [{"id": 1, "name": "Default Store"}]
+                return [{"id": r[0], "name": r[1]} for r in rows]
+        except: return [{"id": 1, "name": "Default Store"}]
 
-    def get_sales_data(self, store_id, metric="revenue_today"):
-        cursor = self.conn.cursor()
-        today = datetime.now().strftime("%Y-%m-%d")
-        if metric == "revenue_today":
-            cursor.execute("SELECT SUM(amount) FROM sales WHERE store_id = ? AND date = ?", (store_id, today))
-            res = cursor.fetchone()[0]
-            return f"{res:,.0f} VND" if res else "0 VND"
-        return "No Data"
+    def _get_or_create_session(self, conn, user_id, workspace_id):
+        row = conn.execute(text("SELECT id FROM chat_sessions WHERE user_id = :uid ORDER BY last_active DESC LIMIT 1"), {"uid": str(user_id)}).fetchone()
+        if row: return row[0]
+        res = conn.execute(text("INSERT INTO chat_sessions (user_id, workspace_id, title) VALUES (:uid, :wid, 'New Chat') RETURNING id"), {"uid": str(user_id), "wid": str(workspace_id)}).fetchone()
+        return res[0]
 
-    def update_profile(self, key, value):
-        cursor = self.conn.cursor()
-        cursor.execute("INSERT OR REPLACE INTO profile (key, value) VALUES (?, ?)", (key, value))
-        self.conn.commit()
+    def save_attachment(self, user_id, workspace_id, filename, filetype, analysis):
+        try:
+            with self.get_conn() as conn:
+                sid = self._get_or_create_session(conn, user_id, workspace_id)
+                conn.execute(text("INSERT INTO chat_attachments (session_id, file_name, file_type, analysis_summary) VALUES (:sid, :f, :t, :a)"), {"sid": sid, "f": filename, "t": filetype, "a": analysis})
+                conn.commit()
+        except: pass
 
-    def get_profile(self):
-        cursor = self.conn.cursor()
-        cursor.execute("SELECT key, value FROM profile")
-        return {row[0]: row[1] for row in cursor.fetchall()}
+    def add_message(self, user_id, workspace_id, role, content):
+        try:
+            with self.get_conn() as conn:
+                sid = self._get_or_create_session(conn, user_id, workspace_id)
+                conn.execute(text("INSERT INTO chat_messages (session_id, role, content) VALUES (:sid, :role, :content)"), {"sid": sid, "role": role, "content": str(content)})
+                conn.commit()
+        except: pass
 
-    def add_message(self, role, content):
-        cursor = self.conn.cursor()
-        cursor.execute("INSERT INTO history (role, content, timestamp) VALUES (?, ?, ?)",
-                       (role, str(content), datetime.now().isoformat()))
-        self.conn.commit()
+    def get_context_string(self, user_id, limit=6):
+        try:
+            with self.get_conn() as conn:
+                rows = conn.execute(text("SELECT m.role, m.content FROM chat_messages m JOIN chat_sessions s ON m.session_id = s.id WHERE s.user_id = :uid ORDER BY m.created_at DESC LIMIT :lim"), {"uid": str(user_id), "lim": limit}).fetchall()
+                history = "\n".join([f"{r[0]}: {r[1]}" for r in reversed(rows)])
+                
+                att_rows = conn.execute(text("SELECT a.file_name, a.analysis_summary FROM chat_attachments a JOIN chat_sessions s ON a.session_id = s.id WHERE s.user_id = :uid ORDER BY s.last_active DESC LIMIT 3"), {"uid": str(user_id)}).fetchall()
+                vision = ""
+                if att_rows:
+                    vision = "\n[VISUAL CONTEXT]:\n" + "\n".join([f"- {r[0]}: {r[1]}" for r in att_rows])
+                return vision + history
+        except: return ""
 
-    def get_context_string(self, limit=6):
-        cursor = self.conn.cursor()
-        cursor.execute("SELECT role, content FROM history ORDER BY id DESC LIMIT ?", (limit,))
-        rows = cursor.fetchall()
-        history = reversed(rows)
-        formatted = []
-        for role, content in history:
-            role_name = "User" if role == "user" else "Assistant"
-            formatted.append(f"{role_name}: {content}")
-        return "\n".join(formatted)
+    def save_workflow(self, workspace_id, name, json_data):
+        with self.get_conn() as conn:
+            conn.execute(text("INSERT INTO scenarios (workspace_id, name, description, steps, status, created_at) VALUES (:wid, :name, 'AI Generated', :steps, 'active', :time)"),
+            {"wid": workspace_id, "name": name, "steps": json.dumps(json_data), "time": datetime.now().isoformat()})
+            conn.commit()
+            return 1

src/core/saas_api.py

@@ -1,65 +1,15 @@
-import requests
-import sqlite3
-import os
+
+from sqlalchemy import create_engine, text
 from src.core.config import Config
 
 class SaasAPI:
     def __init__(self):
         self.config = Config()
-        
-        # CONFIGURATION
-        # Change this to False when you have a real backend URL
-        self.USE_MOCK = True 
-        
-        # Your Real Backend URL (DNS)
-        self.API_BASE_URL = "https://api.your-project-a.com/v1"
-        self.API_KEY = "YOUR_INTERNAL_API_KEY"
-
-    def _get_mock_conn(self):
-        return sqlite3.connect(self.config.DB_PATH, check_same_thread=False)
-
-    def get_sales_report(self, store_id, period="today"):
-        """Fetches sales data."""
-        
-        if self.USE_MOCK:
-            # --- MOCK LOGIC (Local DB) ---
-            conn = self._get_mock_conn()
-            cursor = conn.cursor()
-            date_str = "date('now', 'localtime')"
-            cursor.execute(f"SELECT SUM(amount), COUNT(*) FROM sales WHERE store_id = ? AND date = {date_str}", (store_id,))
-            res = cursor.fetchone()
-            conn.close()
-            if res and res[0]:
-                return {"revenue": res[0], "orders": res[1], "period": period}
-            return {"revenue": 0, "orders": 0, "period": period}
-        
-        else:
-            # --- REAL PRODUCTION LOGIC (HTTP) ---
-            try:
-                headers = {"Authorization": f"Bearer {self.API_KEY}"}
-                url = f"{self.API_BASE_URL}/stores/{store_id}/reports/sales"
-                response = requests.get(url, params={"period": period}, headers=headers, timeout=5)
-                
-                if response.status_code == 200:
-                    return response.json() # Expects { "revenue": 100, "orders": 5 }
-                else:
-                    return {"error": f"API Error: {response.status_code}"}
-            except Exception as e:
-                return {"error": f"Connection Failed: {e}"}
-
-    def check_inventory(self, product_name):
-        if self.USE_MOCK:
-            # Mock Data
-            if "bỉm" in product_name.lower(): return {"stock": 45, "name": "Bỉm Bobby"}
-            return {"error": "Not found"}
-        else:
-            # Real API Call
-            # requests.get(...)
-            pass
-
-    def get_customer_info(self, query):
-        if self.USE_MOCK:
-            return {"name": "Test Customer", "rank": "VIP"}
-        else:
-            # Real API Call
-            pass
+        try: self.engine = create_engine(self.config.DB_URL)
+        except: self.engine = None
+
+    def get_sales_report(self, workspace_id=1, period="today"):
+        if not self.engine: return {"revenue": "0", "orders": 0}
+        with self.engine.connect() as conn:
+            res = conn.execute(text("SELECT SUM(amount), COUNT(*) FROM sales WHERE workspace_id = :wid"), {"wid": workspace_id}).fetchone()
+            return {"revenue": f"{res[0] or 0:,.0f} VND", "orders": res[1] or 0}

src/server.py

@@ -1,61 +1,34 @@
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
+
 import sys
 import os
-import torch
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import json
+import uuid
+import shutil
 import re
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, UploadFile, File
 from pydantic import BaseModel
-
-# Setup Path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-project_root = os.path.dirname(current_dir)
-if project_root not in sys.path: sys.path.insert(0, project_root)
-
-# Imports
 from src.core.engine import ModelEngine
 from src.core.memory import MemoryManager
-from src.core.context import ContextResolver
 from src.core.saas_api import SaasAPI
 from src.core.integrations import IntegrationManager
 from src.agents.manager import ManagerAgent
 from src.agents.coder import CoderAgent
-from src.agents.researcher import ResearcherAgent
 from src.agents.vision import VisionAgent
 
-# Engine Lazy Load
 try:
-    if 'engine' not in globals():
-        engine = ModelEngine()
-except:
-    engine = None
+    if 'engine' not in globals(): engine = ModelEngine()
+except: engine = None
 
 memory = MemoryManager()
 saas = SaasAPI()
 integrations = IntegrationManager(memory)
-
 manager = ManagerAgent(engine, memory)
 coder = CoderAgent(engine, memory)
-researcher = ResearcherAgent(engine)
 vision = VisionAgent()
 
-app = FastAPI(title="Project A API")
-
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-@app.get("/")
-async def read_index():
-    return FileResponse('static/index.html')
-
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app = FastAPI()
 
 class ChatRequest(BaseModel):
     user_id: int
@@ -66,56 +39,46 @@ def clean_output(text):
     text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
     return text.replace("</think>", "").replace("<think>", "").strip()
 
-@app.post("/chat")
-async def chat_endpoint(req: ChatRequest):
-    print(f"📩 Message from Store {req.store_id}: {req.message}")
-    
-    # 1. Build Context String (Stateless)
-    stores = memory.get_user_stores(req.user_id)
-    active_store = next((s for s in stores if s['id'] == req.store_id), None)
+@app.post("/upload")
+async def upload_file(file: UploadFile = File(...)):
+    file_ext = file.filename.split(".")[-1].lower()
+    filename = f"{uuid.uuid4()}.{file_ext}"
+    save_path = f"src/data/{filename}"
+    os.makedirs("src/data", exist_ok=True)
+    with open(save_path, "wb") as buffer: shutil.copyfileobj(file.file, buffer)
     
-    store_context = ""
-    if active_store:
-        store_context = f"Store: {active_store['name']}, Industry: {active_store['industry']}"
+    analysis = f"File {file.filename}"
+    if file_ext in ['jpg', 'png']: analysis = vision.analyze_media(save_path)
     
-    # 2. History
-    memory.add_message("user", req.message)
-    history_str = memory.get_context_string(limit=6)
-    
-    # 3. Analyze
-    decision = manager.analyze_task(req.message, history_str)
-    category = decision.get("category", "GENERAL")
+    # Save to Memory (Hardcoded User 1 for now, should come from Form)
+    memory.save_attachment(1, 1, file.filename, file_ext, analysis)
+    return {"status": "success", "vision_analysis": analysis}
+
+@app.post("/chat")
+async def chat_endpoint(req: ChatRequest):
+    memory.add_message(req.user_id, req.store_id, "user", req.message)
+    history = memory.get_context_string(req.user_id)
     
-    response_text = ""
-    action = "chat"
-    meta = {}
+    decision = manager.analyze_task(req.message, history)
+    cat = decision.get("category", "GENERAL")
     
-    if category == "TECHNICAL":
-        action = "automation"
-        # PASS CONTEXT HERE
-        plan = manager.plan(req.message, history_str, store_context)
+    # Vision Override
+    if "ảnh" in req.message.lower(): cat = "GENERAL"
+
+    resp = ""
+    if cat == "TECHNICAL":
+        plan = manager.plan(req.message, history)
         code = coder.write_code(req.message, plan)
-        
         match = re.search(r"```json\n(.*?)\n```", code, re.DOTALL)
         if match:
-            json_payload = match.group(1)
-            meta = integrations.deploy_internal(req.store_id, json_payload, "API Flow")
-            
-        response_text = f"Đã thiết kế quy trình:\n\n{code}"
-        
-    elif category == "DATA_INTERNAL":
-        action = "data"
-        val = saas.get_sales_report(req.store_id, "today")
-        context_data = f"SALES DATA: {val}"
-        # PASS CONTEXT HERE
-        response_text = manager.consult(req.message, context_data, history_str, store_context)
-        
+            integrations.deploy_internal(req.store_id, match.group(1))
+        resp = f"Đã tạo quy trình:\n{code}"
+    elif cat == "DATA_INTERNAL":
+        data = saas.get_sales_report(req.store_id)
+        resp = manager.consult(req.message, str(data), history)
     else:
-        # General / Marketing
-        # PASS CONTEXT HERE
-        response_text = manager.consult(req.message, "", history_str, store_context)
+        resp = manager.consult(req.message, "", history)
 
-    clean_res = clean_output(response_text)
-    memory.add_message("assistant", clean_res)
-    
-    return {"response": clean_res, "action": action, "meta": meta}
+    final = clean_output(resp)
+    memory.add_message(req.user_id, req.store_id, "assistant", final)
+    return {"response": final}