Final Release: Fixed Vision Agent and Enabled n8n Automation

agents/visual_analyst.py

@@ -45,8 +45,18 @@ class VisualAnalyst:
             )
             
             # 4. Clean and Parse JSON
-            text_response = response.text.replace('```json', '').replace('```', '').strip()
-            return json.loads(text_response)
+            # 4. Clean and Parse JSON
+            # Robust extraction of JSON content
+            content = response.text
+            if "```" in content:
+                import re
+                # Find content between ```json (or just ```) and ```
+                match = re.search(r"```(?:json)?\s*(.*?)```", content, re.DOTALL)
+                if match:
+                    content = match.group(1)
+            
+            cleaned_text = content.strip()
+            return json.loads(cleaned_text)
         except Exception as e:
             print(f"❌ Vision Error: {e}")
             # Return a Safe Fallback (Simulation)

main.py → app.py

@@ -1,24 +1,38 @@
 import os
 import httpx
 import asyncio
-from fastapi import FastAPI, UploadFile, File
+import json
+import traceback
+from fastapi import FastAPI, UploadFile, File, HTTPException
 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()
+    
+    # Try seeding database, but don't crash if it fails (optional robustness)
+    try:
+        memory_agent.seed_database()
+    except Exception as e:
+        print(f"⚠️ Memory Agent Seed Warning: {e}")
+        
     print("✅ All Agents Online")
 except Exception as e:
-    print(f"⚠️ Agent Startup Warning: {e}")
+    print(f"❌ Agent Startup Failed: {e}")
+    # We continue, but endpoints might fail if agents aren't ready.
+
 @app.get("/", response_class=HTMLResponse)
 async def read_root():
     try:
@@ -26,20 +40,26 @@ async def read_root():
             return f.read()
     except FileNotFoundError:
         return "<h1>Error: dashboard.html not found</h1>"
+
 @app.post("/generate-catalog")
 async def generate_catalog(file: UploadFile = File(...)):
+    file_path = None
     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
+        
+        # 2. Run AI Pipeline (Sequential)
+        print("▶️ Starting Visual Analysis...")
         visual_data = await visual_agent.analyze_image(file_path)
         
+        print("▶️ Retrieving Keywords...")
         query = f"{visual_data.get('main_color', '')} {visual_data.get('product_type', 'product')}"
         seo_keywords = memory_agent.retrieve_keywords(query)
         
+        print("▶️ Writing Listing...")
         listing = writer_agent.write_listing(visual_data, seo_keywords)
         
         # 3. Construct Final Payload
@@ -48,28 +68,55 @@ async def generate_catalog(file: UploadFile = File(...)):
             "seo_keywords": seo_keywords,
             "listing": listing
         }
-        # 4. ⚡ N8N AUTOMATION TRIGGER ⚡
+        
+        # 4. Async N8n Trigger (Before Return)
+        # Constraint: "Must happen after agents finish but before returning"
         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)
+            print(f"🚀 Triggering N8N Webhook: {n8n_url}")
+            await trigger_n8n_webhook(n8n_url, final_data)
+        else:
+            print("ℹ️ N8N_WEBHOOK_URL not set, skipping webhook.")
             
         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}")
+        error_details = traceback.format_exc()
+        print(f"❌ Error in generate-catalog: {e}")
+        print(error_details)
+        return JSONResponse(
+            content={
+                "error": str(e),
+                "type": type(e).__name__,
+                "details": error_details
+            },
+            status_code=500
+        )
+        
+    finally:
+        # Cleanup
+        if file_path and os.path.exists(file_path):
+            try:
+                os.remove(file_path)
+            except Exception as cleanup_error:
+                print(f"⚠️ Cleanup Warning: {cleanup_error}")
+
+async def trigger_n8n_webhook(url: str, data: dict):
+    """
+    Sends data to n8n webhook asynchronously using httpx.
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            # We await the post to ensure it's sent before returning, 
+            # fulfilling the user constraint.
+            response = await client.post(url, json=data, timeout=10.0)
+            response.raise_for_status()
+            print(f"✅ N8N Webhook Success: {response.status_code}")
+        except httpx.HTTPStatusError as e:
+             print(f"❌ N8N Webhook HTTP Error: {e.response.status_code} - {e.response.text}")
+        except Exception as e:
+            print(f"❌ N8N Webhook Connection Failed: {e}")
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,15 +1,8 @@
 fastapi
 uvicorn
-python-multipart
-langchain
-langchain-community
-langchain-google-genai
-langchain-groq
-pinecone
-pydantic
 python-dotenv
 google-generativeai
-groq
-Pillow
-
 httpx
+Pillow
+pinecone-client
+groq

verify_webhook_test.py

@@ -0,0 +1,155 @@
+import os
+import subprocess
+import time
+import threading
+import json
+import http.server
+import socketserver
+import urllib.request
+import sys
+
+# Configuration
+MOCK_PORT = 9000
+BACKEND_PORT = 7860
+N8N_URL = f"http://localhost:{MOCK_PORT}/webhook"
+UPLOAD_ENDPOINT = f"http://localhost:{BACKEND_PORT}/generate-catalog"
+TEST_IMAGE = "test_image.jpg"
+
+# Global capture for webhook data
+received_webhooks = []
+
+class MockWebhookHandler(http.server.BaseHTTPRequestHandler):
+    def do_POST(self):
+        content_length = int(self.headers['Content-Length'])
+        post_data = self.rfile.read(content_length)
+        data = json.loads(post_data.decode('utf-8'))
+        received_webhooks.append(data)
+        
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"OK")
+    
+    def log_message(self, format, *args):
+        pass # Silence logs
+
+
+def start_mock_server():
+    print(f"Starting Mock N8n Server on port {MOCK_PORT}...")
+    with socketserver.TCPServer(("localhost", MOCK_PORT), MockWebhookHandler) as httpd:
+        httpd.serve_forever()
+
+def wait_for_server(url, timeout=30):
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            with urllib.request.urlopen(url) as response:
+                if response.status == 200:
+                    return True
+        except Exception:
+            time.sleep(1)
+    return False
+
+def run_test():
+    # 1. Start Mock Server in Thread
+    server_thread = threading.Thread(target=start_mock_server, daemon=True)
+    server_thread.start()
+    
+    # 2. Start Backend Server
+    print("Starting Backend Server...")
+    env = os.environ.copy()
+    env["N8N_WEBHOOK_URL"] = N8N_URL
+    env["PYTHONUNBUFFERED"] = "1"
+    
+    # Force UTF-8 for subprocess to handle emojis from main.py
+    # Use venv python
+    venv_python = os.path.join(os.getcwd(), "venv", "Scripts", "python.exe")
+    if not os.path.exists(venv_python):
+        print(f"Warning: venv python not found at {venv_python}, using sys.executable")
+        venv_python = sys.executable
+
+    process = subprocess.Popen(
+        [venv_python, "main.py"],
+        env=env,
+        cwd=os.getcwd(),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding='utf-8',
+        errors='replace'
+    )
+    
+    try:
+        # 3. Wait for Backend
+        print("Waiting for backend to be ready...")
+        if not wait_for_server(f"http://localhost:{BACKEND_PORT}/"):
+            print("Backend failed to start.")
+            # Print stdout/stderr
+            out, err = process.communicate(timeout=5)
+            print(f"STDOUT:\n{out}")
+            print(f"STDERR:\n{err}")
+            return
+            
+        print("Backend is Ready.")
+        
+        # 4. Send Request
+        print(f"Sending request to {UPLOAD_ENDPOINT} with {TEST_IMAGE}...")
+        
+        # Determine boundary
+        boundary = '----WebKitFormBoundary7MA4YWxkTrZu0gW'
+        
+        # Read image
+        with open(TEST_IMAGE, "rb") as f:
+            image_data = f.read()
+            
+        # Construct Multipart Body manually
+        body = (
+            f'--{boundary}\r\n'
+            f'Content-Disposition: form-data; name="file"; filename="{TEST_IMAGE}"\r\n'
+            'Content-Type: image/jpeg\r\n\r\n'
+        ).encode('utf-8') + image_data + (
+            f'\r\n--{boundary}--\r\n'
+        ).encode('utf-8')
+        
+        req = urllib.request.Request(UPLOAD_ENDPOINT, data=body)
+        req.add_header('Content-Type', f'multipart/form-data; boundary={boundary}')
+        
+        try:
+            with urllib.request.urlopen(req) as response:
+                response_data = json.load(response)
+                print("Received success response from Backend.")
+        except urllib.error.HTTPError as e:
+            print(f"Backend returned error: {e.code}")
+            print(e.read().decode())
+            return
+        except Exception as e:
+            print(f"Request failed: {e}")
+            return
+            
+        # 5. Verify Webhook
+        print("Verifying Webhook Receipt...")
+        time.sleep(2)
+        
+        if len(received_webhooks) > 0:
+            print("Mock Server Received Webhook!")
+            data = received_webhooks[0]
+            if "visual_data" in data and "listing" in data:
+                print("Webhook payload structure looks correct.")
+            else:
+                print("Webhook payload missing keys.")
+                # print(json.dumps(data, indent=2))
+        else:
+            print("No Webhook received by Mock Server.")
+            
+    finally:
+        print("Stopping Backend...")
+        process.terminate()
+        try:
+            out, err = process.communicate(timeout=5)
+            # print("--- Backend Logs ---")
+            # print(out)
+        except:
+            process.kill()
+
+
+if __name__ == "__main__":
+    run_test()