Add N8N Integration

.gitignore

@@ -19,3 +19,5 @@ Thumbs.db
 # Editor Directories
 .vscode/
 .idea/
+
+*.jpg

add_license.py

@@ -0,0 +1,64 @@
+import os
+import subprocess
+
+def run_command(command):
+    try:
+        # shell=True is often required on Windows for some commands/environments
+        print(f"Running: {command}")
+        result = subprocess.run(command, check=True, shell=True, capture_output=True, text=True)
+        print(result.stdout)
+    except subprocess.CalledProcessError as e:
+        print(f"Error running: {command}")
+        print(e.stderr)
+        # We don't exit here to allow attempting subsequent commands or user debugging if one fails,
+        # though for git flow it usually makes sense to stop. 
+        # Given the instruction is a sequence, we should probably stop if add/commit fails.
+        exit(1)
+
+def main():
+    license_text = """MIT License
+
+Copyright (c) 2025 Bhishaj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+    file_path = "LICENSE"
+    
+    print(f"Creating {file_path}...")
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(license_text)
+    print(f"{file_path} created successfully.")
+
+    print("Running git commands...")
+    
+    # 1. git add LICENSE
+    run_command("git add LICENSE")
+    
+    # 2. git commit -m 'Add MIT License'
+    run_command("git commit -m \"Add MIT License\"")
+    
+    # 3. git push space clean_deploy:main
+    print("Pushing to Hugging Face Space (this might take a few seconds)...")
+    run_command("git push space clean_deploy:main")
+    
+    print("Done! License added and pushed to Hugging Face Space.")
+
+if __name__ == "__main__":
+    main()

connect_n8n.py

@@ -0,0 +1,126 @@
+import os
+import subprocess
+
+def update_requirements():
+    req_file = "requirements.txt"
+    if not os.path.exists(req_file):
+        with open(req_file, "w") as f:
+            f.write("httpx\n")
+        print(f"Created {req_file} with httpx.")
+        return
+
+    with open(req_file, "r") as f:
+        content = f.read()
+    
+    if "httpx" not in content:
+        with open(req_file, "a") as f:
+            f.write("\nhttpx\n")
+        print("Appended httpx to requirements.txt.")
+    else:
+        print("httpx already in requirements.txt.")
+
+def update_main():
+    main_content = r'''import os
+import httpx
+import asyncio
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import HTMLResponse, JSONResponse
+from dotenv import load_dotenv
+# Import Agents
+from agents.visual_analyst import VisualAnalyst
+from agents.memory_agent import MemoryAgent
+from agents.writer_agent import WriterAgent
+load_dotenv()
+app = FastAPI()
+# Initialize Agents
+try:
+    visual_agent = VisualAnalyst()
+    memory_agent = MemoryAgent()
+    writer_agent = WriterAgent()
+    memory_agent.seed_database()
+    print("✅ All Agents Online")
+except Exception as e:
+    print(f"⚠️ Agent Startup Warning: {e}")
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    try:
+        with open("dashboard.html", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "<h1>Error: dashboard.html not found</h1>"
+@app.post("/generate-catalog")
+async def generate_catalog(file: UploadFile = File(...)):
+    try:
+        # 1. Save Temp File
+        os.makedirs("uploads", exist_ok=True)
+        file_path = f"uploads/{file.filename}"
+        with open(file_path, "wb") as f:
+            f.write(await file.read())
+        # 2. Run AI Pipeline
+        visual_data = await visual_agent.analyze_image(file_path)
+        
+        query = f"{visual_data.get('main_color', '')} {visual_data.get('product_type', 'product')}"
+        seo_keywords = memory_agent.retrieve_keywords(query)
+        
+        listing = writer_agent.write_listing(visual_data, seo_keywords)
+        
+        # 3. Construct Final Payload
+        final_data = {
+            "visual_data": visual_data,
+            "seo_keywords": seo_keywords,
+            "listing": listing
+        }
+        # 4. ⚡ N8N AUTOMATION TRIGGER ⚡
+        n8n_url = os.getenv("N8N_WEBHOOK_URL")
+        if n8n_url:
+            print(f"🚀 Sending data to N8N: {n8n_url}")
+            # Fire and forget (don't make the user wait for n8n)
+            asyncio.create_task(send_to_n8n(n8n_url, final_data))
+        
+        # Cleanup
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            
+        return JSONResponse(content=final_data)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+# Async Helper to send data without blocking
+async def send_to_n8n(url, data):
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.post(url, json=data, timeout=5.0)
+            print("✅ N8N Webhook Sent Successfully")
+    except Exception as e:
+        print(f"❌ N8N Webhook Failed: {e}")
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+'''
+    with open("main.py", "w", encoding="utf-8") as f:
+        f.write(main_content)
+    print("Updated main.py with N8N integration logic.")
+
+def deploy():
+    try:
+        subprocess.run(["git", "add", "."], check=True)
+        # Check if there are changes to commit
+        status = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True)
+        if status.stdout.strip():
+            subprocess.run(["git", "commit", "-m", "Add N8N Integration"], check=True)
+            print("Git commit successful.")
+        else:
+            print("No changes to commit.")
+        
+        print("Pushing to space...")
+        subprocess.run(["git", "push", "space", "clean_deploy:main"], check=True)
+        print("✅ Successfully deployed to Hugging Face Space.")
+        
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Deployment failed: {e}")
+
+if __name__ == "__main__":
+    print("Starting N8N Integration Setup...")
+    update_requirements()
+    update_main()
+    deploy()
+    print("✅ connect_n8n.py completed.")

create_dockerfile.py

@@ -0,0 +1,50 @@
+import subprocess
+import sys
+
+def run_command(command):
+    print(f"Running: {command}")
+    try:
+        # shell=True allows us to run the command string exactly as provided
+        subprocess.run(command, shell=True, check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing command '{command}': {e}")
+        sys.exit(1)
+
+def main():
+    # 1. Create Dockerfile
+    dockerfile_content = """FROM python:3.9
+WORKDIR /code
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+COPY . /code
+# Fix permissions for libraries that write to home
+RUN mkdir -p /tmp/home
+ENV HOME=/tmp/home
+# Start the FastAPI server on port 7860 (required by Hugging Face)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+"""
+    
+    print("Creating Dockerfile...")
+    try:
+        with open("Dockerfile", "w", newline='\n') as f:
+            f.write(dockerfile_content)
+        print("Dockerfile created successfully.")
+    except Exception as e:
+        print(f"Failed to create Dockerfile: {e}")
+        sys.exit(1)
+
+    # 2. Push to Space
+    print("Executing Git commands...")
+    commands = [
+        'git add Dockerfile',
+        'git commit -m "Add Dockerfile for Hugging Face deployment"',
+        'git push -f space clean_deploy:main'
+    ]
+
+    for cmd in commands:
+        run_command(cmd)
+
+    print("\ncreate_dockerfile.py execution completed.")
+
+if __name__ == "__main__":
+    main()

final_deploy_push.py

@@ -0,0 +1,20 @@
+import subprocess
+import sys
+
+# Force UTF-8 output for Windows terminals
+sys.stdout.reconfigure(encoding='utf-8')
+
+def deploy():
+    print("⚠️  Ensure you are inside the D:\\Projects\\MerchFlow AI directory before running this!")
+    
+    command = "git push --force space clean_deploy:main"
+    print(f"\nRunning: {command} ...")
+    
+    try:
+        subprocess.run(command, check=True, shell=True)
+        print("\n✅ Successfully pushed to Space!")
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Push failed: {e}")
+
+if __name__ == "__main__":
+    deploy()

fix_dashboard_routing.py

@@ -0,0 +1,87 @@
+import os
+import subprocess
+
+def main():
+    # Define the content for main.py
+    main_py_content = """import os
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from agents.visual_analyst import VisualAnalyst
+from dotenv import load_dotenv
+# Load environment variables
+load_dotenv()
+app = FastAPI()
+# Initialize Agent
+visual_agent = VisualAnalyst()
+# 1. READ THE DASHBOARD HTML FILE INTO MEMORY
+try:
+    with open("dashboard.html", "r") as f:
+        dashboard_html = f.read()
+except FileNotFoundError:
+    dashboard_html = "<h1>Error: dashboard.html not found. Please ensure the file exists.</h1>"
+# 2. SERVE DASHBOARD AT ROOT (Home Page)
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    return dashboard_html
+# 3. KEEP /dashboard ROUTE AS BACKUP
+@app.get("/dashboard", response_class=HTMLResponse)
+async def read_dashboard():
+    return dashboard_html
+@app.post("/analyze")
+async def analyze_merch(file: UploadFile = File(...)):
+    try:
+        os.makedirs("uploads", exist_ok=True)
+        file_path = f"uploads/{file.filename}"
+        with open(file_path, "wb") as f:
+            f.write(await file.read())
+        result = await visual_agent.analyze_image(file_path)
+        
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            
+        return JSONResponse(content=result)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+"""
+
+    # Overwrite main.py
+    print("Overwriting main.py...")
+    try:
+        with open("main.py", "w", encoding="utf-8") as f:
+            f.write(main_py_content)
+        print("Successfully updated main.py")
+    except Exception as e:
+        print(f"Error writing main.py: {e}")
+        return
+
+    # Define git commands
+    git_commands = [
+        ["git", "add", "main.py"],
+        ["git", "commit", "-m", "Fix dashboard 404 by serving HTML at root"],
+        ["git", "push", "space", "clean_deploy:main"]
+    ]
+
+    # Run git commands
+    print("\nRunning git commands...")
+    for cmd in git_commands:
+        print(f"Executing: {' '.join(cmd)}")
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Command failed: {e}")
+            # If commit fails (e.g. nothing to commit), we might want to continue or stop.
+            # But push should definitely happen if commit works.
+            # If commit fails because "nothing to commit, working tree clean", push might still be relevant if previous commit wasn't pushed?
+            # But the user logic implies we just made a change to main.py, so commit should succeed unless main.py was ALREADY this content.
+            # We will continue to try push even if commit fails, just in case.
+            # But wait, if commit fails, push might proceed.
+            pass
+
+    print("\nfix_dashboard_routing.py completed.")
+
+if __name__ == "__main__":
+    main()

fix_google_key.py

@@ -0,0 +1,48 @@
+import os
+import sys
+
+# Force UTF-8 output for Windows terminals
+sys.stdout.reconfigure(encoding='utf-8')
+
+# 1. Update .env
+env_path = ".env"
+key = "GOOGLE_API_KEY"
+value = "AIzaSyDgIkagGBciWNZDTn07OlfY9tVPvo6KJ1on"
+
+print(f"Updating {key} in .env...")
+
+lines = []
+if os.path.exists(env_path):
+    with open(env_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+found = False
+new_lines = []
+for line in lines:
+    if line.startswith(f"{key}="):
+        new_lines.append(f"{key}={value}\n")
+        found = True
+    else:
+        new_lines.append(line)
+
+if not found:
+    if new_lines and not new_lines[-1].endswith('\n'):
+        new_lines.append('\n')
+    new_lines.append(f"{key}={value}\n")
+
+with open(env_path, "w", encoding="utf-8") as f:
+    f.writelines(new_lines)
+
+print(f"✅ Updated {key} in .env")
+
+# 2. Upload to Cloud
+print("Syncing secrets to Hugging Face Space...")
+try:
+    # Build path to ensure we can import upload_secrets
+    sys.path.append(os.getcwd())
+    from upload_secrets import upload_secrets
+    
+    upload_secrets()
+    print("✅ Google Key saved locally and uploaded to Hugging Face!")
+except Exception as e:
+    print(f"❌ Failed to sync: {e}")

fix_readme.py

@@ -0,0 +1,42 @@
+import os
+import sys
+import subprocess
+
+# Force UTF-8 output for Windows terminals
+sys.stdout.reconfigure(encoding='utf-8')
+
+readme_content = """---
+title: MerchFlow AI
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+# MerchFlow AI
+An AI-powered merchandising agent.
+"""
+
+def run_command(command):
+    print(f"Running: {command}")
+    try:
+        subprocess.run(command, check=True, shell=True)
+        print("✅ Success")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error: {e}")
+        # Don't exit, try to continue or let user see error
+
+def fix_readme():
+    print("Writing README.md...")
+    with open("README.md", "w", encoding="utf-8") as f:
+        f.write(readme_content)
+    print("✅ Created README.md")
+
+    print("Deploying changes...")
+    run_command("git add README.md")
+    run_command('git commit -m "Add Hugging Face configuration"')
+    run_command("git push space clean_deploy:main")
+    print("✅ Configuration fixed and pushed!")
+
+if __name__ == "__main__":
+    fix_readme()

fix_vision_core.py

@@ -0,0 +1,90 @@
+import os
+import subprocess
+
+def fix_vision_core():
+    # Content for agents/visual_analyst.py
+    content = """import os
+import json
+import asyncio
+import google.generativeai as genai
+from PIL import Image
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class VisualAnalyst:
+    def __init__(self):
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            print("⚠️ GEMINI_API_KEY missing")
+
+        genai.configure(api_key=api_key)
+        # Use the modern, faster Flash model
+        self.model = genai.GenerativeModel('gemini-1.5-flash')
+
+    async def analyze_image(self, image_path: str):
+        print(f"👁️ Analyzing image: {image_path}")
+        
+        try:
+            # 1. Load image properly with Pillow (Fixes format issues)
+            img = Image.open(image_path)
+            
+            # 2. Define the prompt
+            prompt = \"\"\"
+            Analyze this product image for an e-commerce listing.
+            Return ONLY a raw JSON object (no markdown formatting) with this structure:
+            {
+                "main_color": "string",
+                "product_type": "string",
+                "design_style": "string (minimalist, streetwear, vintage, etc)",
+                "visual_features": ["list", "of", "visible", "features"],
+                "suggested_title": "creative product title",
+                "condition_guess": "new/used"
+            }
+            \"\"\"
+            
+            # 3. Run in a thread to prevent blocking (Sync to Async wrapper)
+            response = await asyncio.to_thread(
+                self.model.generate_content,
+                [prompt, img]
+            )
+            
+            # 4. Clean and Parse JSON
+            text_response = response.text.replace('```json', '').replace('```', '').strip()
+            return json.loads(text_response)
+        except Exception as e:
+            print(f"❌ Vision Error: {e}")
+            # Return a Safe Fallback (Simulation)
+            return {
+                "main_color": "Unknown",
+                "product_type": "Unidentified Item",
+                "design_style": "Standard",
+                "visual_features": ["Error analyzing image"],
+                "suggested_title": "Manual Review Needed",
+                "condition_guess": "New"
+            }
+"""
+    # Write the file
+    os.makedirs("agents", exist_ok=True)
+    with open("agents/visual_analyst.py", "w", encoding="utf-8") as f:
+        f.write(content)
+    print("✅ agents/visual_analyst.py updated.")
+
+    # Git operations
+    print("🚀 Pushing to HuggingFace...")
+    commands = [
+        ["git", "add", "agents/visual_analyst.py"],
+        ["git", "commit", "-m", "Fix vision core and error handling"],
+        ["git", "push", "space", "clean_deploy:main"]
+    ]
+    
+    for cmd in commands:
+        try:
+            print(f"Running: {' '.join(cmd)}")
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"⚠️ Command failed: {e}")
+            # Continue even if commit fails (e.g. prompt already applied)
+            
+if __name__ == "__main__":
+    fix_vision_core()

main.py

@@ -1,72 +1,75 @@
 import os
+import httpx
+import asyncio
 from fastapi import FastAPI, UploadFile, File
 from fastapi.responses import HTMLResponse, JSONResponse
 from dotenv import load_dotenv
-
 # Import Agents
 from agents.visual_analyst import VisualAnalyst
 from agents.memory_agent import MemoryAgent
 from agents.writer_agent import WriterAgent
-
 load_dotenv()
 app = FastAPI()
-
-# Initialize All Agents
+# Initialize Agents
 try:
     visual_agent = VisualAnalyst()
     memory_agent = MemoryAgent()
     writer_agent = WriterAgent()
-    
-    # Seed memory on startup
     memory_agent.seed_database()
     print("✅ All Agents Online")
 except Exception as e:
-    print(f"⚠️ Warning: Some agents failed to load: {e}")
-
-# 1. SERVE DASHBOARD AT ROOT
+    print(f"⚠️ Agent Startup Warning: {e}")
 @app.get("/", response_class=HTMLResponse)
 async def read_root():
     try:
         with open("dashboard.html", "r") as f:
             return f.read()
     except FileNotFoundError:
-        return "Error: dashboard.html not found"
-
-# 2. THE MAIN ORCHESTRATOR ENDPOINT
+        return "<h1>Error: dashboard.html not found</h1>"
 @app.post("/generate-catalog")
 async def generate_catalog(file: UploadFile = File(...)):
     try:
-        # A. Save Temp File
+        # 1. Save Temp File
         os.makedirs("uploads", exist_ok=True)
         file_path = f"uploads/{file.filename}"
         with open(file_path, "wb") as f:
             f.write(await file.read())
-
-        # B. Visual Analysis (The Eyes)
+        # 2. Run AI Pipeline
         visual_data = await visual_agent.analyze_image(file_path)
         
-        # C. Memory Search (The Context)
-        # Create a search query from visual data
         query = f"{visual_data.get('main_color', '')} {visual_data.get('product_type', 'product')}"
         seo_keywords = memory_agent.retrieve_keywords(query)
         
-        # D. Write Copy (The Brain)
         listing = writer_agent.write_listing(visual_data, seo_keywords)
         
+        # 3. Construct Final Payload
+        final_data = {
+            "visual_data": visual_data,
+            "seo_keywords": seo_keywords,
+            "listing": listing
+        }
+        # 4. ⚡ N8N AUTOMATION TRIGGER ⚡
+        n8n_url = os.getenv("N8N_WEBHOOK_URL")
+        if n8n_url:
+            print(f"🚀 Sending data to N8N: {n8n_url}")
+            # Fire and forget (don't make the user wait for n8n)
+            asyncio.create_task(send_to_n8n(n8n_url, final_data))
+        
         # Cleanup
         if os.path.exists(file_path):
             os.remove(file_path)
             
-        # Return Full Data Structure
-        return JSONResponse(content={
-            "visual_data": visual_data,
-            "seo_keywords": seo_keywords,
-            "listing": listing
-        })
+        return JSONResponse(content=final_data)
     except Exception as e:
-        print(f"Error: {e}")
         return JSONResponse(content={"error": str(e)}, status_code=500)
-
+# Async Helper to send data without blocking
+async def send_to_n8n(url, data):
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.post(url, json=data, timeout=5.0)
+            print("✅ N8N Webhook Sent Successfully")
+    except Exception as e:
+        print(f"❌ N8N Webhook Failed: {e}")
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -11,3 +11,5 @@ python-dotenv
 google-generativeai
 groq
 Pillow
+
+httpx

restore_full_brain.py

@@ -0,0 +1,122 @@
+import os
+import subprocess
+
+def restore_main():
+    content = """import os
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import HTMLResponse, JSONResponse
+from dotenv import load_dotenv
+
+# Import Agents
+from agents.visual_analyst import VisualAnalyst
+from agents.memory_agent import MemoryAgent
+from agents.writer_agent import WriterAgent
+
+load_dotenv()
+app = FastAPI()
+
+# Initialize All Agents
+try:
+    visual_agent = VisualAnalyst()
+    memory_agent = MemoryAgent()
+    writer_agent = WriterAgent()
+    
+    # Seed memory on startup
+    memory_agent.seed_database()
+    print("✅ All Agents Online")
+except Exception as e:
+    print(f"⚠️ Warning: Some agents failed to load: {e}")
+
+# 1. SERVE DASHBOARD AT ROOT
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    try:
+        with open("dashboard.html", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "Error: dashboard.html not found"
+
+# 2. THE MAIN ORCHESTRATOR ENDPOINT
+@app.post("/generate-catalog")
+async def generate_catalog(file: UploadFile = File(...)):
+    try:
+        # A. Save Temp File
+        os.makedirs("uploads", exist_ok=True)
+        file_path = f"uploads/{file.filename}"
+        with open(file_path, "wb") as f:
+            f.write(await file.read())
+
+        # B. Visual Analysis (The Eyes)
+        visual_data = await visual_agent.analyze_image(file_path)
+        
+        # C. Memory Search (The Context)
+        # Create a search query from visual data
+        query = f"{visual_data.get('main_color', '')} {visual_data.get('product_type', 'product')}"
+        seo_keywords = memory_agent.retrieve_keywords(query)
+        
+        # D. Write Copy (The Brain)
+        listing = writer_agent.write_listing(visual_data, seo_keywords)
+        
+        # Cleanup
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            
+        # Return Full Data Structure
+        return JSONResponse(content={
+            "visual_data": visual_data,
+            "seo_keywords": seo_keywords,
+            "listing": listing
+        })
+    except Exception as e:
+        print(f"Error: {e}")
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+"""
+    with open("main.py", "w", encoding="utf-8") as f:
+        f.write(content)
+    print("✅ main.py restored with full agent logic.")
+
+def update_dashboard():
+    try:
+        with open("dashboard.html", "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        # Replace localhost URL with relative path
+        new_content = content.replace("http://localhost:8000/generate-catalog", "/generate-catalog")
+        
+        with open("dashboard.html", "w", encoding="utf-8") as f:
+            f.write(new_content)
+        print("✅ dashboard.html updated for cloud deployment.")
+    except Exception as e:
+        print(f"❌ Error updating dashboard.html: {e}")
+
+def deploy():
+    print("🚀 Starting Deployment...")
+    commands = [
+        ["git", "add", "main.py", "dashboard.html"],
+        ["git", "commit", "-m", "Restore full brain logic and fix dashboard URL"],
+        ["git", "push", "space", "clean_deploy:main"]
+    ]
+    
+    for cmd in commands:
+        try:
+            print(f"Running: {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+            print(result.stdout)
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Error running command: {' '.join(cmd)}")
+            print(e.stderr)
+            # Don't break on commit error as it might be empty
+            if "nothing to commit" in e.stderr:
+                continue
+            # For other errors we might want to continue or stop, but let's try to proceed
+    print("✅ Deployment script finished.")
+
+if __name__ == "__main__":
+    print("🔧 Restoring Full Brain...")
+    restore_main()
+    update_dashboard()
+    deploy()

train_memory_agent.py

@@ -0,0 +1,88 @@
+import os
+import time
+from agents.memory_agent import MemoryAgent
+
+def main():
+    print("Initializing MemoryAgent...")
+    # Initialize MemoryAgent (handles Pinecone and Gemini setup)
+    agent = MemoryAgent()
+
+    # 1. Define Training Data
+    # 5-10 high-quality 'sample listings'
+    samples = [
+        {
+            "id": "sample_summer_tee_001",
+            "text": "The ultimate summer essential. This heavyweight cotton t-shirt features a boxy fit and dropped shoulders for a relaxed, contemporary silhouette. Finished with a garment dye process for a soft, broken-in feel and vintage aesthetic.",
+            "metadata": {"category": "Streetwear", "best_for": "Summer", "price_point": "Premium"}
+        },
+        {
+             "id": "sample_hoodie_002",
+             "text": "Engineered for comfort and durability. This fleece hoodie minimizes shrinkage and maintains its shape over time. Features double-needle stitching, a generous kangaroo pocket, and rib-knit cuffs. The style is versatile enough for gym sessions or casual weekends.",
+             "metadata": {"category": "Casual", "best_for": "Autumn/Winter", "price_point": "Mid-range"}
+        },
+        {
+            "id": "sample_joggers_003",
+            "text": "Performance meets style. These tapered joggers are crafted from moisture-wicking tech fabric with four-way stretch. Designed with articulated knees for maximum mobility and zippered ankle cuffs for easy on/off. Perfect for high-intensity training or athleisure wear.",
+            "metadata": {"category": "Activewear", "best_for": "All Season", "price_point": "Performance"}
+        },
+        {
+            "id": "sample_oversized_shirt_004",
+            "text": "A statement piece for the modern wardrobe. This oversized button-down is cut from crisp poplin with a dramatic high-low hem. The minimalist design is accented by hidden placket buttons and a sharp collar, offering a clean, architectural look.",
+             "metadata": {"category": "Avant-Garde", "best_for": "Spring/Summer", "price_point": "Luxury"}
+        },
+        {
+            "id": "sample_cargo_shorts_005",
+            "text": "Rugged utility for the urban explorer. These cargo shorts are built from ripstop cotton canvas. Featuring multiple bellowed pockets with snap closures, reinforced belt loops, and a gusseted crotch. Functional, durable, and ready for adventure.",
+            "metadata": {"category": "Streetwear", "best_for": "Summer", "price_point": "Standard"}
+        }
+    ]
+
+    print(f"Preparing to upload {len(samples)} samples to Pinecone...")
+
+    # 2. Batch Upload
+    vectors = []
+    for item in samples:
+        # Generate embedding using the agent's internal method
+        # This ensures we use the exact same model and parameters as the agent
+        embedding = agent._get_embedding(item['text'])
+        
+        # Prepare metadata
+        # We include the 'text' in metadata so we can retrieve the full description later
+        meta = item['metadata'].copy()
+        meta['text'] = item['text'] 
+        
+        vectors.append({
+            "id": item['id'],
+            "values": embedding,
+            "metadata": meta
+        })
+
+    # Upsert to Pinecone
+    # Using the agent's underlying index object
+    agent.index.upsert(vectors=vectors)
+    print("Upload complete. vectors upserted successfully.")
+
+    # 3. Verify
+    print("\n--- Verifying Data ---")
+    query = "summer t-shirt"
+    print(f"Running test search for: '{query}'")
+    
+    # Generate embedding for the query
+    query_embedding = agent._get_embedding(query)
+    
+    # Query the index
+    results = agent.index.query(
+        vector=query_embedding,
+        top_k=3,
+        include_metadata=True
+    )
+    
+    print(f"Found {len(results.matches)} matches:")
+    for match in results.matches:
+        print(f"\nID: {match.id}")
+        print(f"Score: {match.score:.4f}")
+        print(f"Category: {match.metadata.get('category', 'N/A')}")
+        print(f"Snippet: {match.metadata.get('text', '')[:100]}...")
+
+if __name__ == "__main__":
+    main()

upload_secrets.py

@@ -0,0 +1,30 @@
+import os
+import sys
+from dotenv import load_dotenv
+from huggingface_hub import add_space_secret
+
+# Force UTF-8 output for Windows terminals
+sys.stdout.reconfigure(encoding='utf-8')
+
+def upload_secrets():
+    # Load environment variables from .env file
+    load_dotenv()
+    
+    space_id = "Bhishaj/MerchFlow-AI"
+    keys_to_upload = ["GROQ_API_KEY", "PINECONE_API_KEY", "GOOGLE_API_KEY"]
+    
+    print(f"Configuring secrets for Space: {space_id}")
+    
+    for key in keys_to_upload:
+        value = os.getenv(key)
+        if value:
+            try:
+                add_space_secret(repo_id=space_id, key=key, value=value)
+                print(f"✅ Uploaded {key}")
+            except Exception as e:
+                print(f"❌ Failed to upload {key}: {e}")
+        else:
+            print(f"⚠️  Skipping {key} (Not found in .env)")
+
+if __name__ == "__main__":
+    upload_secrets()

verify_search.py

@@ -0,0 +1,15 @@
+from agents.memory_agent import MemoryAgent
+
+def check_search():
+    agent = MemoryAgent()
+    query = "urban explorer cargo"
+    print(f"Searching for '{query}'...")
+    
+    embedding = agent._get_embedding(query)
+    results = agent.index.query(vector=embedding, top_k=5, include_metadata=True)
+    
+    for match in results.matches:
+        print(f"ID: {match.id} | Score: {match.score:.4f} | Text snippet: {match.metadata.get('text', '')[:50]}")
+
+if __name__ == "__main__":
+    check_search()

verify_upload.py

@@ -0,0 +1,10 @@
+from agents.memory_agent import MemoryAgent
+
+def check():
+    agent = MemoryAgent()
+    print("Checking for sample_summer_tee_001...")
+    fetch_response = agent.index.fetch(ids=["sample_summer_tee_001", "item2"])
+    print(fetch_response)
+
+if __name__ == "__main__":
+    check()