1st

.gitignore

@@ -0,0 +1,6 @@
+.env
+.env.*
+__pycache__/
+*.pyc
+*.pyo
+*.pyd

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y curl python3-pip
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY backend ./backend
+COPY frontend ./frontend
+
+# Create startup script in a standard location
+RUN echo '#!/bin/bash\n\
+# Start backend server\n\
+uvicorn backend.main:app --host 0.0.0.0 --port 8002 &\n\
+\n\
+# Start frontend server\n\
+cd frontend && python -m http.server 8080 &\n\
+\n\
+# Wait for either process to exit\n\
+wait' > /usr/local/bin/start.sh && \
+    chmod +x /usr/local/bin/start.sh
+
+# Expose ports for both services
+EXPOSE 8002 8080
+
+# Start both servers
+CMD ["/usr/local/bin/start.sh"]

backend/category_config.py

@@ -0,0 +1,113 @@
+from typing import Dict, TypedDict
+
+class CategoryConfig(TypedDict):
+    name: str
+    description: str
+    style_guide: str
+    conventions: list[str]
+    common_elements: list[str]
+
+CATEGORY_CONFIGS: Dict[str, CategoryConfig] = {
+    "mechanical": {
+        "name": "Mechanical Engineering",
+        "description": "Focuses on machine components, mechanisms, and mechanical systems design",
+        "style_guide": "Use isometric views for 3D components. Include detailed cross-sections for complex parts.",
+        "conventions": [
+            "Center lines for symmetric parts",
+            "Hidden lines for internal features",
+            "Section views for internal details",
+            "Dimensioning with tolerances"
+        ],
+        "common_elements": [
+            "Gears and transmission systems",
+            "Bearings and shafts",
+            "Fasteners and joints",
+            "Hydraulic/pneumatic components"
+        ]
+    },
+    "structural": {
+        "name": "Structural Engineering",
+        "description": "Focuses on building structures, load-bearing elements, and structural analysis",
+        "style_guide": "Use clear section markers. Include detailed connection points.",
+        "conventions": [
+            "Grid lines and axes",
+            "Member sizing annotations",
+            "Connection details",
+            "Load indicators"
+        ],
+        "common_elements": [
+            "Beams and columns",
+            "Foundation details",
+            "Structural connections",
+            "Reinforcement details"
+        ]
+    },
+    "civil": {
+        "name": "Civil Engineering",
+        "description": "Focuses on infrastructure, site plans, and civil structures",
+        "style_guide": "Use plan views with clear elevation markers. Include site context.",
+        "conventions": [
+            "Site orientation",
+            "Elevation markers",
+            "Drainage indicators",
+            "Material specifications"
+        ],
+        "common_elements": [
+            "Road sections",
+            "Drainage systems",
+            "Site grading",
+            "Utilities layout"
+        ]
+    },
+    "architectural": {
+        "name": "Architectural Engineering",
+        "description": "Focuses on building designs, spatial layouts, and architectural elements",
+        "style_guide": "Use multiple views (plan, elevation, section). Include material patterns.",
+        "conventions": [
+            "Room labels",
+            "Door/window schedules",
+            "Material hatching",
+            "Dimensional guidelines"
+        ],
+        "common_elements": [
+            "Floor plans",
+            "Elevations",
+            "Building sections",
+            "Detail drawings"
+        ]
+    },
+    "electrical": {
+        "name": "Electrical Engineering",
+        "description": "Focuses on electrical systems, circuits, and power distribution",
+        "style_guide": "Use standard electrical symbols. Include system block diagrams.",
+        "conventions": [
+            "Circuit symbols",
+            "Wire numbering",
+            "Component labels",
+            "Power ratings"
+        ],
+        "common_elements": [
+            "Circuit diagrams",
+            "Wiring layouts",
+            "Panel schedules",
+            "Single-line diagrams"
+        ]
+    },
+    "aerospace": {
+        "name": "Aerospace Engineering",
+        "description": "Focuses on aircraft, spacecraft, and aerospace systems",
+        "style_guide": "Use multiple projection views. Include aerodynamic profiles.",
+        "conventions": [
+            "Station numbering",
+            "Flow indicators",
+            "System interfaces",
+            "Zoning diagrams"
+        ],
+        "common_elements": [
+            "Airframe structures",
+            "Propulsion systems",
+            "Control surfaces",
+            "System integration"
+        ]
+    }
+}

backend/category_instructions.py

@@ -0,0 +1,77 @@
+from typing import Dict, List
+
+ALLOWED_CATEGORIES = [
+    "mechanical",
+    "structural",
+    "civil",
+    "architectural",
+    "electrical",
+    "aerospace"
+]
+
+CATEGORY_INSTRUCTIONS: Dict[str, str] = {
+    "mechanical": """You are a mechanical engineering schematic generator specializing in machine components, 
+    mechanisms, and mechanical systems. Generate precise technical drawings with detailed views of moving parts, 
+    assembly sequences, and mechanical connections. For each schematic, provide:
+    1. Materials List: Specify required components, materials, and standard parts with specifications
+    2. Assembly Instructions: Step-by-step assembly procedure with critical tolerances and alignments
+    3. Operating Parameters: Working conditions, load limits, and maintenance requirements
+    4. Safety Considerations: Key safety measures and potential failure points to monitor""",
+    
+    "structural": """You are a structural engineering schematic generator focusing on building structures, 
+    load-bearing elements, and structural components. Generate detailed structural drawings emphasizing connections, 
+    member details, and load paths. For each schematic, provide:
+    1. Material Specifications: Required structural materials with grades and standards
+    2. Load Calculations: Design loads, safety factors, and critical stress points
+    3. Construction Sequence: Step-by-step construction methodology with critical checks
+    4. Testing Protocol: Required structural tests and inspection points""",
+    
+    "civil": """You are a civil engineering schematic generator specializing in infrastructure, site plans, 
+    and civil structures. Generate detailed drawings showing construction details, earthworks, and systems. 
+    For each schematic, provide:
+    1. Site Requirements: Ground conditions, drainage needs, and utilities requirements
+    2. Material Specifications: Required materials with grades and testing standards
+    3. Construction Sequence: Detailed construction steps with quality control points
+    4. Environmental Considerations: Impact mitigation and sustainability measures""",
+    
+    "architectural": """You are an architectural schematic generator focusing on building designs, spatial layouts, 
+    and architectural details. Generate drawings emphasizing building elements and spatial relationships. 
+    For each schematic, provide:
+    1. Space Program: Room dimensions, functional requirements, and circulation paths
+    2. Material Schedule: Finishing materials, fixtures, and architectural elements
+    3. Construction Details: Critical junctions, weatherproofing, and installation methods
+    4. Code Compliance: Relevant building codes and accessibility requirements""",
+    
+    "electrical": """You are an electrical engineering schematic generator specializing in electrical systems, 
+    circuits, and components. Generate clear circuit diagrams and system layouts. For each schematic, provide:
+    1. Component List: Required components with specifications and ratings
+    2. Installation Guide: Step-by-step wiring and assembly instructions
+    3. Testing Procedure: Circuit validation and troubleshooting steps
+    4. Safety Protocols: Required safety measures and regulatory compliance notes""",
+    
+    "aerospace": """You are an aerospace engineering schematic generator focusing on aircraft, spacecraft, 
+    and aerospace systems. Generate detailed technical drawings of aerospace components and systems. 
+    For each schematic, provide:
+    1. Materials List: Aerospace-grade materials with specifications and certifications
+    2. Assembly Sequence: Critical assembly steps with tolerance requirements
+    3. Testing Requirements: Required validation tests and quality control measures
+    4. Performance Parameters: Operating conditions, limits, and safety margins"""
+}
+
+DEFAULT_INSTRUCTION = """You are a versatile engineering schematic generator capable of creating technical drawings 
+across various engineering disciplines. Generate clear, precise technical representations following standard 
+engineering drawing conventions. For each schematic, provide:
+1. Overview: Brief description of the system or component purpose and function
+2. Materials and Components: Comprehensive list of required materials with specifications
+3. Implementation Guide: Step-by-step instructions for construction or assembly
+4. Testing and Validation: Required tests and quality control measures
+5. Safety Guidelines: Important safety considerations and regulatory requirements"""
+
+def get_instruction_for_category(category: str | None) -> str:
+    """Get the system instruction for a given category."""
+    if category is None:
+        return DEFAULT_INSTRUCTION
+    category = category.lower()
+    if category not in ALLOWED_CATEGORIES:
+        return DEFAULT_INSTRUCTION
+    return CATEGORY_INSTRUCTIONS[category]

backend/config.py

@@ -0,0 +1,8 @@
+SYSTEM_INSTRUCTION = """
+You're a useful assistant
+"""
+
+DEFAULT_TEXT = """
+A blueprint schematic of a [subject], drawn in the style of early 20th-century industrial patents. 
+Rendered in crisp blue ink with white technical lines, featuring exploded views, angular labels, and stamped diagram codes.
+"""

backend/logging_utils.py

@@ -0,0 +1,92 @@
+import logging
+from datetime import datetime
+import json
+from pathlib import Path
+import os
+from typing import Optional
+
+# Configure logging
+log_dir = Path(__file__).parent.parent / "logs"
+log_dir.mkdir(exist_ok=True)
+
+# Configure file handler for general logs
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(log_dir / "app.log"),
+        logging.StreamHandler()
+    ]
+)
+
+# Create a specific logger for category usage
+category_logger = logging.getLogger('category_usage')
+category_logger.setLevel(logging.INFO)
+
+# Stats file for category usage
+STATS_FILE = log_dir / "category_stats.json"
+
+def load_category_stats():
+    """Load existing category usage statistics."""
+    try:
+        if STATS_FILE.exists():
+            with open(STATS_FILE, 'r') as f:
+                return json.load(f)
+    except Exception as e:
+        logging.error(f"Error loading category stats: {e}")
+    return {}
+
+def save_category_stats(stats):
+    """Save category usage statistics."""
+    try:
+        with open(STATS_FILE, 'w') as f:
+            json.dump(stats, f, indent=2)
+    except Exception as e:
+        logging.error(f"Error saving category stats: {e}")
+
+def log_category_usage(category: Optional[str], endpoint: str, success: bool):
+    """Log category usage with detailed metrics."""
+    timestamp = datetime.now().isoformat()
+    
+    # Load existing stats
+    stats = load_category_stats()
+    
+    # Initialize category if not exists
+    category_key = category or "default"
+    if category_key not in stats:
+        stats[category_key] = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "endpoints": {},
+            "last_used": None
+        }
+    
+    # Update category stats
+    stats[category_key]["total_requests"] += 1
+    if success:
+        stats[category_key]["successful_requests"] += 1
+    else:
+        stats[category_key]["failed_requests"] += 1
+    
+    # Update endpoint stats
+    if endpoint not in stats[category_key]["endpoints"]:
+        stats[category_key]["endpoints"][endpoint] = 0
+    stats[category_key]["endpoints"][endpoint] += 1
+    
+    # Update timestamp
+    stats[category_key]["last_used"] = timestamp
+    
+    # Save updated stats
+    save_category_stats(stats)
+    
+    # Log the event
+    category_logger.info(
+        f"Category usage - Category: {category_key}, "
+        f"Endpoint: {endpoint}, "
+        f"Success: {success}"
+    )
+
+def get_category_statistics():
+    """Get category usage statistics."""
+    return load_category_stats()

backend/main.py

@@ -0,0 +1,88 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Literal, Optional, Dict, Any, Union
+from backend.utils import async_generate_text_and_image, async_generate_with_image_input
+from backend.category_config import CATEGORY_CONFIGS
+from backend.logging_utils import log_category_usage, get_category_statistics
+import backend.config as config  # keep for reference if needed
+import traceback
+
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class TextGenerateRequest(BaseModel):
+    prompt: str
+    category: Optional[str] = None
+
+class ImageTextGenerateRequest(BaseModel):
+    text: Optional[str] = None
+    image: str
+    category: Optional[str] = None
+
+class Part(BaseModel):
+    type: Literal["text", "image"]
+    data: Union[str, Dict[str, str]]  # Can be either a string (for image) or dict (for text)
+
+class GenerationResponse(BaseModel):
+    results: List[Part]
+
+@app.post("/generate", response_model=GenerationResponse)
+async def generate(request: TextGenerateRequest):
+    """
+    Generate text and image from a text prompt with optional category.
+    """
+    success = False
+    try:
+        results = []
+        async for part in async_generate_text_and_image(request.prompt, request.category):
+            results.append(part)
+        success = True
+        return GenerationResponse(results=results)
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Internal error: {e}")
+    finally:
+        log_category_usage(request.category, "/generate", success)
+
+@app.post("/generate_with_image", response_model=GenerationResponse)
+async def generate_with_image(request: ImageTextGenerateRequest):
+    """
+    Generate text and image given a text and base64 image with optional category.
+    """
+    success = False
+    try:
+        results = []
+        text = request.text if request.text else config.DEFAULT_TEXT
+        async for part in async_generate_with_image_input(text, request.image, request.category):
+            results.append(part)
+        success = True
+        return GenerationResponse(results=results)
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Internal error: {e}")
+    finally:
+        log_category_usage(request.category, "/generate_with_image", success)
+
+@app.get("/categories")
+async def get_categories():
+    """
+    Get all available engineering categories with their descriptions and configurations.
+    """
+    return CATEGORY_CONFIGS
+
+@app.get("/category-stats")
+async def get_usage_statistics():
+    """
+    Get usage statistics for all categories.
+    """
+    return get_category_statistics()
+
+@app.get("/")
+async def read_root():
+    return {"message": "Image generation API is up"}

backend/utils.py

@@ -0,0 +1,152 @@
+from google import genai
+from google.genai import types
+from typing import Union, List, Generator, Dict, Optional
+from PIL import Image
+from io import BytesIO
+import base64
+import requests
+import asyncio
+import os
+from dotenv import load_dotenv
+from .category_instructions import get_instruction_for_category
+from .category_config import CATEGORY_CONFIGS
+load_dotenv()
+
+client = genai.Client(
+    api_key=os.getenv("API_KEY")
+)
+
+def bytes_to_base64(data: bytes, with_prefix: bool = True) -> str:
+    encoded = base64.b64encode(data).decode("utf-8")
+    return f"data:image/png;base64,{encoded}" if with_prefix else encoded
+
+def decode_base64_image(base64_str: str) -> Image.Image:
+    # Remove the prefix if present (e.g., "data:image/png;base64,")
+    if base64_str.startswith("data:image"):
+        base64_str = base64_str.split(",")[1]
+    image_data = base64.b64decode(base64_str)
+    image = Image.open(BytesIO(image_data))
+    return image
+
+async def async_generate_text_and_image(prompt, category: Optional[str] = None):
+    # Get the appropriate instruction and configuration
+    instruction = get_instruction_for_category(category)
+    config = CATEGORY_CONFIGS.get(category.lower() if category else "", {})
+    
+    # Enhance the prompt with category-specific guidance if available
+    if config:
+        style_guide = config.get("style_guide", "")
+        conventions = config.get("conventions", [])
+        common_elements = config.get("common_elements", [])
+        
+        enhanced_prompt = (
+            f"{instruction}\n\n"
+            f"Style Guide: {style_guide}\n"
+            f"Drawing Conventions to Follow:\n- " + "\n- ".join(conventions) + "\n"
+            f"Consider Including These Elements:\n- " + "\n- ".join(common_elements) + "\n\n"
+            f"User Request: {prompt}"
+        )
+    else:
+        enhanced_prompt = f"{instruction}\n\nUser Request: {prompt}"
+    
+    response = await client.aio.models.generate_content(
+        model=os.getenv("MODEL"),
+        contents=enhanced_prompt,
+        config=types.GenerateContentConfig(
+            response_modalities=['TEXT', 'IMAGE']
+        )
+    )
+    for part in response.candidates[0].content.parts:
+        if hasattr(part, 'text') and part.text is not None:
+            # Try to parse the text into sections
+            try:
+                text_sections = {}
+                current_section = "overview"
+                lines = part.text.split('\n')
+                
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    
+                    # Check for section headers
+                    if any(line.lower().startswith(f"{i}.") for i in range(1, 6)):
+                        section_name = line.split('.', 1)[1].split(':', 1)[0].strip().lower()
+                        section_name = section_name.replace(' ', '_')
+                        current_section = section_name
+                        text_sections[current_section] = []
+                    else:
+                        if current_section not in text_sections:
+                            text_sections[current_section] = []
+                        text_sections[current_section].append(line)
+                
+                # Clean up the sections
+                for section in text_sections:
+                    text_sections[section] = '\n'.join(text_sections[section]).strip()
+                
+                yield {'type': 'text', 'data': text_sections}
+            except Exception as e:
+                # Fallback to raw text if parsing fails
+                yield {'type': 'text', 'data': {'raw_text': part.text}}
+        elif hasattr(part, 'inline_data') and part.inline_data is not None:
+            yield {'type': 'image', 'data': bytes_to_base64(part.inline_data.data)}
+
+async def async_generate_with_image_input(text: Optional[str], image_path: str, category: Optional[str] = None):
+    # Validate that the image input is a base64 data URI
+    if not isinstance(image_path, str) or not image_path.startswith("data:image/"):
+        raise ValueError("Invalid image input: expected a base64 Data URI starting with 'data:image/'")
+    # Decode the base64 string into a PIL Image
+    image = decode_base64_image(image_path)
+    
+    # Get the appropriate instruction for the category
+    instruction = get_instruction_for_category(category)
+    
+    contents = []
+    if text:
+        # Combine the instruction with the user's text input
+        combined_text = f"{instruction}\n\nUser Request: {text}"
+        contents.append(combined_text)
+    else:
+        contents.append(instruction)
+    contents.append(image)
+    response = await client.aio.models.generate_content(
+        model=os.getenv("MODEL"),
+        contents=contents,
+        config=types.GenerateContentConfig(
+            response_modalities=['TEXT', 'IMAGE']
+        )
+    )
+    for part in response.candidates[0].content.parts:
+        if hasattr(part, 'text') and part.text is not None:
+            # Try to parse the text into sections
+            try:
+                text_sections = {}
+                current_section = "overview"
+                lines = part.text.split('\n')
+                
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    
+                    # Check for section headers
+                    if any(line.lower().startswith(f"{i}.") for i in range(1, 6)):
+                        section_name = line.split('.', 1)[1].split(':', 1)[0].strip().lower()
+                        section_name = section_name.replace(' ', '_')
+                        current_section = section_name
+                        text_sections[current_section] = []
+                    else:
+                        if current_section not in text_sections:
+                            text_sections[current_section] = []
+                        text_sections[current_section].append(line)
+                
+                # Clean up the sections
+                for section in text_sections:
+                    text_sections[section] = '\n'.join(text_sections[section]).strip()
+                
+                yield {'type': 'text', 'data': text_sections}
+            except Exception as e:
+                # Fallback to raw text if parsing fails
+                yield {'type': 'text', 'data': {'raw_text': part.text}}
+        elif hasattr(part, 'inline_data') and part.inline_data is not None:
+            yield {'type': 'image', 'data': bytes_to_base64(part.inline_data.data)}

docker-compose.yml

@@ -0,0 +1,19 @@
+version: '3.8'
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8002:8002"  # Backend API
+      - "8080:8080"  # Frontend static server
+    environment:
+      - API_KEY=${API_KEY}
+      - MODEL=${MODEL}
+    volumes:
+      - .:/app
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8002"]
+      interval: 30s
+      timeout: 10s
+      retries: 3

frontend/index.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Schematic Generation AI</title>
+  <link rel="stylesheet" href="style.css">
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap">
+</head>
+<body>
+  <div class="app-container">
+    <!-- Side Navigation -->
+    <nav class="side-nav">
+      <div class="nav-header">
+        <h2>Generation Mode</h2>
+      </div>
+      <div class="nav-items">
+        <button class="nav-item active" data-mode="text2img">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M12 5v14M5 12h14"/>
+          </svg>
+          Text to Image
+        </button>
+        <button class="nav-item" data-mode="img2img">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/>
+            <path d="M3 15l6-6 9 9"/>
+            <path d="M13 9l3-3 5 5"/>
+          </svg>
+          Image with Text
+        </button>
+      </div>
+    </nav>
+
+    <!-- Main Content -->
+    <main class="main-content">
+      <div class="content-area">
+        <h1>Schematic Generation AI</h1>
+        
+        <!-- Text to Image Interface -->
+        <section id="text2img" class="interface active">
+          <div class="form-group">
+            <div class="category-wrapper">
+              <select id="category" class="category-select">
+                <option value="">Select Engineering Category (Optional)</option>
+              </select>
+              <div id="categoryInfo" class="category-info"></div>
+            </div>
+            <textarea 
+              id="prompt" 
+              placeholder="Describe the schematic you want to generate..."
+              rows="4"
+            ></textarea>
+            <button id="generate">Generate Schematic</button>
+          </div>
+          <div id="results"></div>
+        </section>
+
+        <!-- Image with Text Interface -->
+        <section id="img2img" class="interface">
+          <div class="form-group">
+            <div class="file-input-wrapper">
+              <input type="file" id="inputImage" accept="image/*">
+              <label for="inputImage">
+                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                  <polyline points="17 8 12 3 7 8"/>
+                  <line x1="12" y1="3" x2="12" y2="15"/>
+                </svg>
+                <span>Choose an image or drag & drop here</span>
+              </label>
+            </div>
+            <div class="category-wrapper">
+              <select id="imageCategory" class="category-select">
+                <option value="">Select Engineering Category (Optional)</option>
+              </select>
+              <div id="imageCategoryInfo" class="category-info"></div>
+            </div>
+            <textarea 
+              id="imagePrompt" 
+              placeholder="Optional: Describe any modifications or specific requirements..."
+              rows="3"
+            ></textarea>
+            <button id="generateWithImage">Generate Modified Schematic</button>
+          </div>
+          <div id="resultsImg"></div>
+        </section>
+      </div>
+
+      <!-- Results Panel -->
+      <div id="resultsPanel" class="results-panel"></div>
+    </main>
+  </div>
+  <script src="script.js"></script>
+</body>
+</html>

frontend/script.js

@@ -0,0 +1,361 @@
+// Get the current hostname (will work both locally and in Docker)
+const API_BASE = `${window.location.protocol}//${window.location.hostname}:8002`;
+
+// Interface switching
+function setupNavigation() {
+    const navItems = document.querySelectorAll('.nav-item');
+    
+    navItems.forEach(item => {
+        item.addEventListener('click', () => {
+            const mode = item.dataset.mode;
+            
+            // Update navigation state
+            navItems.forEach(nav => nav.classList.remove('active'));
+            item.classList.add('active');
+            
+            // Update interface visibility
+            document.querySelectorAll('.interface').forEach(interface => {
+                interface.classList.remove('active');
+            });
+            document.getElementById(mode).classList.add('active');
+        });
+    });
+}
+
+// Helper functions
+function setLoading(button, isLoading) {
+    if (isLoading) {
+        button.classList.add('loading');
+        button.disabled = true;
+    } else {
+        button.classList.remove('loading');
+        button.disabled = false;
+    }
+}
+
+function showError(container, message) {
+    const errorDiv = document.createElement('div');
+    errorDiv.className = 'error-message';
+    errorDiv.textContent = message || 'An error occurred. Please try again.';
+    container.innerHTML = '';
+    container.appendChild(errorDiv);
+    updateResultsPanel(null); // Clear the results panel
+}
+
+function updateResultsPanel(textData) {
+    const panel = document.getElementById('resultsPanel');
+    const mainContent = document.querySelector('.main-content');
+    
+    if (!textData) {
+        panel.classList.remove('visible');
+        mainContent.classList.remove('with-panel');
+        return;
+    }
+
+    panel.innerHTML = ''; // Clear previous content
+    
+    // Add title
+    const title = document.createElement('h2');
+    title.textContent = 'Generated Information';
+    title.style.marginBottom = '1.5rem';
+    panel.appendChild(title);
+
+    if (typeof textData === 'string') {
+        // Handle legacy string data
+        const p = document.createElement('p');
+        p.textContent = textData;
+        panel.appendChild(p);
+    } else {
+        // Handle structured data
+        Object.entries(textData).forEach(([section, content]) => {
+            const sectionDiv = document.createElement('div');
+            sectionDiv.className = 'text-section';
+            
+            const title = document.createElement('h3');
+            title.className = 'section-title';
+            title.textContent = section.split('_').map(word => 
+                word.charAt(0).toUpperCase() + word.slice(1)
+            ).join(' ');
+            
+            const content_p = document.createElement('p');
+            content_p.textContent = content;
+            
+            sectionDiv.appendChild(title);
+            sectionDiv.appendChild(content_p);
+            panel.appendChild(sectionDiv);
+        });
+    }
+
+    panel.classList.add('visible');
+    mainContent.classList.add('with-panel');
+}
+
+function createResultElement(item) {
+    if (item.type === 'text') {
+        // Update the panel with text data
+        updateResultsPanel(item.data);
+        return null; // Don't create an element in the main content area
+    } else if (item.type === 'image') {
+        const wrapper = document.createElement('div');
+        wrapper.className = 'image-wrapper';
+        
+        const img = document.createElement('img');
+        img.src = item.data;
+        img.addEventListener('load', () => wrapper.classList.add('loaded'));
+        
+        wrapper.appendChild(img);
+        return wrapper;
+    }
+    return null;
+}
+
+// File input handling
+function setupFileInput() {
+    const fileInput = document.getElementById('inputImage');
+    const dropZone = document.querySelector('.file-input-wrapper');
+    
+    ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+        dropZone.addEventListener(eventName, preventDefaults, false);
+    });
+    
+    function preventDefaults(e) {
+        e.preventDefault();
+        e.stopPropagation();
+    }
+    
+    ['dragenter', 'dragover'].forEach(eventName => {
+        dropZone.addEventListener(eventName, () => {
+            dropZone.classList.add('highlight');
+        });
+    });
+    
+    ['dragleave', 'drop'].forEach(eventName => {
+        dropZone.addEventListener(eventName, () => {
+            dropZone.classList.remove('highlight');
+        });
+    });
+    
+    dropZone.addEventListener('drop', (e) => {
+        const dt = e.dataTransfer;
+        const files = dt.files;
+        fileInput.files = files;
+        updateFileLabel(files[0]?.name);
+    });
+    
+    fileInput.addEventListener('change', (e) => {
+        updateFileLabel(e.target.files[0]?.name);
+    });
+}
+
+function updateFileLabel(filename) {
+    const label = document.querySelector('label[for="inputImage"] span');
+    label.textContent = filename || 'Choose an image or drag & drop here';
+}
+
+// Text to Image Generation
+document.getElementById('generate').addEventListener('click', async () => {
+    const prompt = document.getElementById('prompt').value.trim();
+    const category = document.getElementById('category').value;
+    const generateButton = document.getElementById('generate');
+    const resultsDiv = document.getElementById('results');
+    
+    if (!prompt) {
+        showError(resultsDiv, 'Please enter a description for the schematic.');
+        return;
+    }
+    
+    resultsDiv.innerHTML = '';
+    setLoading(generateButton, true);
+    
+    try {
+        const res = await fetch(`${API_BASE}/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ prompt, category })
+        });
+        
+        if (!res.ok) {
+            throw new Error(`Server responded with ${res.status}`);
+        }
+        
+        const data = await res.json();
+        const resultElements = data.results
+            .map(createResultElement)
+            .filter(element => element !== null);
+            
+        if (resultElements.length === 0) {
+            showError(resultsDiv, 'No results generated. Please try again.');
+            return;
+        }
+        
+        resultElements.forEach(element => resultsDiv.appendChild(element));
+        
+    } catch (err) {
+        console.error(err);
+        showError(resultsDiv, 'Error generating schematic. Please try again.');
+    } finally {
+        setLoading(generateButton, false);
+    }
+});
+
+// Image with Text Generation
+document.getElementById('generateWithImage').addEventListener('click', async () => {
+    const fileInput = document.getElementById('inputImage');
+    const prompt = document.getElementById('imagePrompt').value.trim();
+    const generateButton = document.getElementById('generateWithImage');
+    const resultsDiv = document.getElementById('resultsImg');
+    
+    if (!fileInput.files.length) {
+        showError(resultsDiv, 'Please select an image file.');
+        return;
+    }
+    
+    const file = fileInput.files[0];
+    if (!file.type.startsWith('image/')) {
+        showError(resultsDiv, 'Please select a valid image file.');
+        return;
+    }
+    
+    resultsDiv.innerHTML = '';
+    setLoading(generateButton, true);
+    
+    try {
+        const base64 = await new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = e => resolve(e.target.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(file);
+        });
+        
+        const category = document.getElementById('imageCategory').value;
+        
+        const res = await fetch(`${API_BASE}/generate_with_image`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ 
+                text: prompt || '',  // Send empty string if no prompt provided
+                image: base64,
+                category
+            })
+        });
+        
+        if (!res.ok) {
+            throw new Error(`Server responded with ${res.status}`);
+        }
+        
+        const data = await res.json();
+        const resultElements = data.results
+            .map(createResultElement)
+            .filter(element => element !== null);
+            
+        if (resultElements.length === 0) {
+            showError(resultsDiv, 'No results generated. Please try again.');
+            return;
+        }
+        
+        resultElements.forEach(element => resultsDiv.appendChild(element));
+        
+    } catch (err) {
+        console.error(err);
+        showError(resultsDiv, 'Error generating modified schematic. Please try again.');
+    } finally {
+        setLoading(generateButton, false);
+    }
+});
+
+// Category handling
+async function fetchCategories() {
+    try {
+        const res = await fetch(`${API_BASE}/categories`);
+        if (!res.ok) throw new Error('Failed to fetch categories');
+        return await res.json();
+    } catch (error) {
+        console.error('Error fetching categories:', error);
+        return null;
+    }
+}
+
+function updateCategoryInfo(categoryData, infoDiv) {
+    if (!infoDiv) {
+        console.error('Category info div not found');
+        return;
+    }
+
+    if (!categoryData) {
+        infoDiv.innerHTML = '';
+        infoDiv.classList.remove('visible');
+        return;
+    }
+
+    const html = `
+        <h4>${categoryData.name}</h4>
+        <p>${categoryData.description}</p>
+        <p><strong>Style Guide:</strong> ${categoryData.style_guide}</p>
+        
+        <h4>Drawing Conventions:</h4>
+        <div class="conventions-list">
+            ${categoryData.conventions.map(conv => `
+                <span class="convention-tag">${conv}</span>
+            `).join('')}
+        </div>
+        
+        <h4>Common Elements:</h4>
+        <div class="elements-list">
+            ${categoryData.common_elements.map(elem => `
+                <span class="element-tag">${elem}</span>
+            `).join('')}
+        </div>
+    `;
+    
+    infoDiv.innerHTML = html;
+    infoDiv.classList.add('visible');
+}
+
+async function setupCategories() {
+    try {
+        const categories = await fetchCategories();
+        if (!categories) return;
+        
+        // Setup for both category selects
+        [
+            { selectId: 'category', infoId: 'categoryInfo' },
+            { selectId: 'imageCategory', infoId: 'imageCategoryInfo' }
+        ].forEach(({ selectId, infoId }) => {
+            const select = document.getElementById(selectId);
+            if (!select) {
+                console.error(`Select element with id ${selectId} not found`);
+                return;
+            }
+            
+            // Clear existing options
+            select.innerHTML = '<option value="">Select Engineering Category (Optional)</option>';
+            
+            // Add category options
+            Object.entries(categories).forEach(([key, data]) => {
+                const option = document.createElement('option');
+                option.value = key;
+                option.textContent = data.name;
+                select.appendChild(option);
+            });
+            
+            // Add change event listener
+            select.addEventListener('change', (e) => {
+                const selectedCategory = e.target.value;
+                const infoElement = document.getElementById(infoId);
+                
+                if (selectedCategory && categories[selectedCategory]) {
+                    updateCategoryInfo(categories[selectedCategory], infoElement);
+                } else {
+                    updateCategoryInfo(null, infoElement);
+                }
+            });
+        });
+    } catch (error) {
+        console.error('Error setting up categories:', error);
+    }
+}
+
+// Initialize functionality
+setupNavigation();
+setupFileInput();
+setupCategories();

frontend/style.css

@@ -0,0 +1,545 @@
+:root {
+  --primary-color: #6366f1;
+  --primary-hover: #4f46e5;
+  --bg-color: #f8fafc;
+  --card-bg: #ffffff;
+  --text-color: #1e293b;
+  --border-color: #e2e8f0;
+  --radius: 12px;
+  --divider-color: #e2e8f0;
+  --icon-color: #64748b;
+  --nav-width: 240px;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: var(--bg-color);
+  color: var(--text-color);
+  line-height: 1.5;
+  min-height: 100vh;
+}
+
+.app-container {
+  display: flex;
+  min-height: 100vh;
+}
+
+h1 {
+  text-align: center;
+  font-size: 2.5rem;
+  margin-bottom: 2rem;
+  background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+h2 {
+  text-align: center;
+  font-size: 1.5rem;
+  margin-bottom: 1.5rem;
+  color: var(--text-color);
+}
+
+section {
+  background: var(--card-bg);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  padding: 2rem;
+  margin-bottom: 2rem;
+  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1);
+  transition: transform 0.2s ease;
+}
+
+section:hover {
+  transform: translateY(-2px);
+}
+
+textarea, input[type="text"], .category-select {
+  width: 100%;
+  padding: 1rem;
+  margin-bottom: 1rem;
+  border: 2px solid var(--border-color);
+  border-radius: var(--radius);
+  font-size: 1rem;
+  transition: border-color 0.2s ease;
+  background: var(--bg-color);
+  resize: vertical;
+  min-height: 100px;
+}
+
+.category-wrapper {
+  margin-bottom: 1.5rem;
+}
+
+.category-select {
+  min-height: auto;
+  cursor: pointer;
+  appearance: none;
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3e%3cpolyline points='6 9 12 15 18 9'%3e%3c/polyline%3e%3c/svg%3e");
+  background-repeat: no-repeat;
+  background-position: right 1rem center;
+  background-size: 1em;
+  padding-right: 2.5rem;
+}
+
+.category-select:focus {
+  outline: none;
+  border-color: var(--primary-color);
+}
+
+.category-info {
+  margin-top: 0.5rem;
+  padding: 1rem;
+  background: var(--bg-color);
+  border-radius: var(--radius);
+  font-size: 0.9rem;
+  color: var(--text-color);
+  opacity: 0;
+  transform: translateY(-10px);
+  transition: all 0.3s ease;
+}
+
+.category-info.visible {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+.category-info h4 {
+  margin: 0 0 0.5rem;
+  color: var(--primary-color);
+}
+
+.category-info ul {
+  margin: 0.5rem 0;
+  padding-left: 1.5rem;
+}
+
+.category-info li {
+  margin-bottom: 0.25rem;
+}
+
+.conventions-list, .elements-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin-top: 0.5rem;
+}
+
+.convention-tag, .element-tag {
+  background: var(--primary-color);
+  color: white;
+  padding: 0.25rem 0.75rem;
+  border-radius: 1rem;
+  font-size: 0.8rem;
+}
+
+input[type="text"] {
+  min-height: auto;
+}
+
+textarea:focus, input[type="text"]:focus {
+  outline: none;
+  border-color: var(--primary-color);
+}
+
+input[type="file"] {
+  width: 100%;
+  padding: 0.5rem;
+  margin-bottom: 1rem;
+  cursor: pointer;
+}
+
+button {
+  width: 100%;
+  padding: 1rem;
+  background: var(--primary-color);
+  color: white;
+  border: none;
+  border-radius: var(--radius);
+  cursor: pointer;
+  font-size: 1rem;
+  font-weight: 600;
+  transition: all 0.2s ease;
+  margin-top: 1rem;
+}
+
+button:hover {
+  background: var(--primary-hover);
+  transform: translateY(-1px);
+}
+
+button:active {
+  transform: translateY(0);
+}
+
+button.loading {
+  opacity: 0.7;
+  cursor: not-allowed;
+  position: relative;
+}
+
+button.loading::after {
+  content: "";
+  position: absolute;
+  width: 20px;
+  height: 20px;
+  top: 50%;
+  left: 50%;
+  margin: -10px 0 0 -10px;
+  border: 3px solid rgba(255, 255, 255, 0.3);
+  border-top-color: white;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+.input-section {
+  position: relative;
+  margin: 2rem 0;
+}
+
+.divider {
+  position: relative;
+  text-align: center;
+  margin: 1.5rem 0;
+}
+
+.divider::before {
+  content: "";
+  position: absolute;
+  top: 50%;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background: var(--divider-color);
+}
+
+.divider span {
+  position: relative;
+  background: var(--card-bg);
+  padding: 0 1rem;
+  color: var(--icon-color);
+  font-size: 0.9rem;
+}
+
+.file-input-wrapper {
+  position: relative;
+  width: 100%;
+  min-height: 150px;
+  border: 2px dashed var(--border-color);
+  border-radius: var(--radius);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all 0.2s ease;
+  cursor: pointer;
+  background: var(--bg-color);
+}
+
+.file-input-wrapper:hover,
+.file-input-wrapper.highlight {
+  border-color: var(--primary-color);
+  background: rgba(99, 102, 241, 0.05);
+}
+
+.file-input-wrapper input[type="file"] {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  cursor: pointer;
+}
+
+.file-input-wrapper label {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 1rem;
+  color: var(--icon-color);
+  font-size: 0.95rem;
+  text-align: center;
+  padding: 2rem;
+  pointer-events: none;
+}
+
+.file-input-wrapper svg {
+  stroke: var(--icon-color);
+  transition: stroke 0.2s ease;
+}
+
+.file-input-wrapper:hover svg {
+  stroke: var(--primary-color);
+}
+
+textarea {
+  min-height: 120px;
+  line-height: 1.6;
+}
+
+.error-message {
+  color: #dc2626;
+  background: #fef2f2;
+  padding: 1rem;
+  border-radius: var(--radius);
+  margin-bottom: 1rem;
+  border: 1px solid #fecaca;
+}
+
+.result-text {
+  background: var(--bg-color);
+  padding: 1rem;
+  border-radius: var(--radius);
+  margin-bottom: 1rem;
+}
+
+.text-section {
+  margin-bottom: 1.5rem;
+  padding: 1rem;
+  background: var(--card-bg);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+}
+
+.text-section:last-child {
+  margin-bottom: 0;
+}
+
+.section-title {
+  color: var(--primary-color);
+  font-size: 1.1rem;
+  margin: 0 0 0.5rem 0;
+  font-weight: 600;
+}
+
+.text-section p {
+  margin: 0;
+  line-height: 1.6;
+  white-space: pre-wrap;
+}
+
+.image-wrapper {
+  position: relative;
+  opacity: 0;
+  transform: translateY(10px);
+  transition: all 0.3s ease;
+}
+
+.image-wrapper.loaded {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+#results, #resultsImg {
+  margin-top: 1.5rem;
+  display: grid;
+  gap: 1rem;
+}
+
+#results img, #resultsImg img {
+  width: 100%;
+  height: auto;
+  border-radius: var(--radius);
+  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+  transition: transform 0.2s ease;
+}
+
+#results img:hover, #resultsImg img:hover {
+  transform: scale(1.02);
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.side-nav {
+  width: var(--nav-width);
+  background: var(--card-bg);
+  border-right: 1px solid var(--border-color);
+  padding: 2rem 1rem;
+  flex-shrink: 0;
+}
+
+.nav-header {
+  padding: 0 1rem 1rem;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.nav-header h2 {
+  font-size: 1.1rem;
+  margin: 0;
+  text-align: left;
+  color: var(--text-color);
+}
+
+.nav-items {
+  padding-top: 1rem;
+}
+
+.nav-item {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  width: 100%;
+  padding: 0.75rem 1rem;
+  background: transparent;
+  border: none;
+  border-radius: var(--radius);
+  color: var(--text-color);
+  font-size: 0.95rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.nav-item svg {
+  stroke: var(--icon-color);
+  transition: stroke 0.2s ease;
+}
+
+.nav-item:hover {
+  background: var(--bg-color);
+  transform: translateX(4px);
+}
+
+.nav-item.active {
+  background: var(--primary-color);
+  color: white;
+}
+
+.nav-item.active svg {
+  stroke: white;
+}
+
+.main-content {
+  flex-grow: 1;
+  position: relative;
+  display: flex;
+}
+
+.content-area {
+  flex-grow: 1;
+  padding: 2rem;
+  max-width: calc(100% - var(--nav-width));
+  transition: max-width 0.3s ease;
+}
+
+.results-panel {
+  position: fixed;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  width: 400px;
+  background: var(--card-bg);
+  border-left: 1px solid var(--border-color);
+  padding: 2rem;
+  overflow-y: auto;
+  transform: translateX(100%);
+  transition: transform 0.3s ease;
+  box-shadow: -4px 0 16px rgba(0, 0, 0, 0.1);
+}
+
+.results-panel.visible {
+  transform: translateX(0);
+}
+
+.main-content.with-panel .content-area {
+  max-width: calc(100% - var(--nav-width) - 400px);
+}
+
+.interface {
+  display: none;
+}
+
+.interface.active {
+  display: block;
+}
+
+@media (max-width: 600px) {
+  body {
+    padding: 1rem;
+  }
+
+  section {
+    padding: 1.5rem;
+  }
+
+  h1 {
+    font-size: 2rem;
+  }
+  
+  .file-input-wrapper {
+    min-height: 100px;
+  }
+}
+
+@media (max-width: 1200px) {
+  .results-panel {
+    width: 350px;
+  }
+  
+  .main-content.with-panel {
+    max-width: calc(100% - var(--nav-width) - 350px);
+  }
+}
+
+@media (max-width: 768px) {
+  .app-container {
+    flex-direction: column;
+  }
+
+  .side-nav {
+    width: 100%;
+    border-right: none;
+    border-bottom: 1px solid var(--border-color);
+    padding: 1rem;
+  }
+
+  .nav-items {
+    display: flex;
+    gap: 1rem;
+  }
+
+  .nav-item {
+    flex: 1;
+    justify-content: center;
+  }
+
+  .nav-item svg {
+    display: none;
+  }
+
+  .main-content {
+    max-width: 100%;
+    padding: 1rem;
+  }
+
+  .results-panel {
+    position: fixed;
+    width: 100%;
+    height: 50%;
+    top: auto;
+    bottom: 0;
+    transform: translateY(100%);
+  }
+
+  .results-panel.visible {
+    transform: translateY(0);
+  }
+
+  .main-content.with-panel .content-area {
+    max-width: 100%;
+    padding-bottom: calc(50vh + 2rem);
+  }
+}

logs/app.log

@@ -0,0 +1,28 @@
+2025-05-28 07:25:24,649 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:25:31,893 - category_usage - INFO - Category usage - Category: architectural, Endpoint: /generate, Success: True
+2025-05-28 07:25:42,787 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:25:48,667 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True
+2025-05-28 07:30:42,593 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:30:49,823 - category_usage - INFO - Category usage - Category: default, Endpoint: /generate, Success: True
+2025-05-28 07:31:01,466 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:31:06,847 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True
+2025-05-28 07:36:55,689 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:37:03,976 - category_usage - INFO - Category usage - Category: mechanical, Endpoint: /generate, Success: True
+2025-05-28 07:45:33,489 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 07:45:39,003 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True
+2025-05-28 08:02:06,281 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:02:16,462 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True
+2025-05-28 08:05:30,940 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:05:40,735 - category_usage - INFO - Category usage - Category: architectural, Endpoint: /generate_with_image, Success: True
+2025-05-28 08:06:37,294 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:06:44,399 - category_usage - INFO - Category usage - Category: architectural, Endpoint: /generate_with_image, Success: True
+2025-05-28 08:07:11,815 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:07:20,047 - category_usage - INFO - Category usage - Category: architectural, Endpoint: /generate_with_image, Success: True
+2025-05-28 08:11:49,088 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:11:56,770 - category_usage - INFO - Category usage - Category: default, Endpoint: /generate_with_image, Success: True
+2025-05-28 08:12:18,972 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:12:29,866 - category_usage - INFO - Category usage - Category: architectural, Endpoint: /generate_with_image, Success: True
+2025-05-28 08:17:01,735 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:17:07,524 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True
+2025-05-28 08:40:29,100 - root - INFO - AFC is enabled with max remote calls: 10.
+2025-05-28 08:40:35,726 - category_usage - INFO - Category usage - Category: aerospace, Endpoint: /generate, Success: True

logs/category_stats.json

@@ -0,0 +1,40 @@
+{
+  "architectural": {
+    "total_requests": 5,
+    "successful_requests": 5,
+    "failed_requests": 0,
+    "endpoints": {
+      "/generate": 1,
+      "/generate_with_image": 4
+    },
+    "last_used": "2025-05-28T08:12:29.863971"
+  },
+  "aerospace": {
+    "total_requests": 6,
+    "successful_requests": 6,
+    "failed_requests": 0,
+    "endpoints": {
+      "/generate": 6
+    },
+    "last_used": "2025-05-28T08:40:35.722978"
+  },
+  "default": {
+    "total_requests": 2,
+    "successful_requests": 2,
+    "failed_requests": 0,
+    "endpoints": {
+      "/generate": 1,
+      "/generate_with_image": 1
+    },
+    "last_used": "2025-05-28T08:11:56.766848"
+  },
+  "mechanical": {
+    "total_requests": 1,
+    "successful_requests": 1,
+    "failed_requests": 0,
+    "endpoints": {
+      "/generate": 1
+    },
+    "last_used": "2025-05-28T07:37:03.972773"
+  }
+}

plan.md

@@ -0,0 +1,48 @@
+# Backend Development Plan
+
+## 1. Category-Based System Instructions
+
+- **Goal:** Support system instructions tailored to specific engineering categories (e.g., mechanical, structural, civil, architectural, electrical, aerospace).
+- **Approach:**
+  - Define a set of system instructions for each category.
+  - **Allowed Categories:** 
+    - mechanical
+    - structural
+    - civil
+    - architectural
+    - electrical
+    - aerospace
+  - Store these instructions in a configuration file (e.g., JSON or YAML) or a database.
+  - Update API endpoints to accept a `category` parameter.
+  - Use the selected category in the generation logic to apply corresponding instructions.
+  - Provide a fallback to default instructions if the category isn't recognized.
+
+## 2. API Changes
+
+- **Add `category` field** to relevant request models (e.g., `TextGenerateRequest`, `ImageTextGenerateRequest`).
+- **Validate the category** against the allowed values.
+- **Pass category** to generation utilities to select appropriate instructions.
+- **Logging and Error Handling:**
+  - Log usage statistics for different categories.
+  - Return clear error messages if an invalid category is provided.
+
+## 3. Future Ideas and Enhancements
+
+- Allow users to define custom categories or instructions.
+- Add endpoints to list available categories along with their descriptions.
+- Implement advanced logging and analytics to observe category usage.
+- Support multi-category or hybrid instructions.
+- **Extend the configuration:**
+  - Provide detailed parameters per category (e.g., style, tone, structural guidelines).
+  - Create a configuration file to manage these parameters centrally.
+- Explore caching mechanisms for repeated generation requests per category.
+
+---
+
+## Next Steps
+
+1. Define allowed categories and specify instructions per category.
+2. Refactor request models and endpoints to include a `category` parameter.
+3. Update generation logic to utilize category-specific instructions.
+4. Develop a configuration file for system instructions per category.
+5. Enhance error handling and logging for better maintainability.

requirements.txt

@@ -0,0 +1,22 @@
+google-genai
+aioredis
+redis==5.2.1
+python-docx
+fastapi==0.115.11
+uvicorn==0.34.0
+pydantic==2.10.6
+aiocache
+openai==1.67.0
+httpx
+python-dotenv
+psycopg2-binary==2.9.9
+python-jose[cryptography] 
+passlib[bcrypt] 
+python-multipart 
+python-jose[cryptography] 
+passlib[bcrypt] 
+python-multipart
+pytest==7.4.4
+pytest-asyncio==0.23.3
+httpx==0.26.0  # Required for TestClient
+pillow