init

Dockerfile

@@ -1,17 +1,68 @@
-# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
+# backend/Dockerfile.pip
+# === BUILD STAGE ===
+FROM python:3.10-slim AS build
 
-FROM python:3.9
+ENV PIP_NO_CACHE_DIR=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/home/user/.local/bin:$PATH"
 
+# Install system dependencies for building
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libjpeg-dev \
+    zlib1g-dev \
+    libpng-dev \
+    libffi-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create user
+RUN useradd -m -u 1000 user
+
+USER user
+WORKDIR /app
+
+# Copy requirements file
+COPY --chown=user requirements.txt ./
+
+# Install dependencies using PIP
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# === FINAL STAGE ===
+FROM python:3.10-slim
+
+# Install runtime dependencies only
+RUN apt-get update && apt-get install -y \
+    libjpeg-dev \
+    zlib1g-dev \
+    libpng-dev \
+    libffi-dev \
+    curl \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create user
 RUN useradd -m -u 1000 user
+
 USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+
+ENV PATH="/home/user/.local/bin:$PATH" \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
 
 WORKDIR /app
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+# Copy installed packages from builder
+COPY --from=build /home/user/.local /home/user/.local
+
+# Copy application code
+COPY --chown=user . .
+
+EXPOSE 7860
 
-COPY --chown=user . /app
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/healthcheck || exit 1
 
+# Production command
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,8 +0,0 @@
-from fastapi import FastAPI
-
-app = FastAPI()
-
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
-

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "server"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi[standard]==0.116.1",
+    "google-genai==1.27.0",
+    "loguru==0.7.3",
+    "openai==1.97.0",
+    "pillow==11.3.0",
+    "psutil>=7.0.0",
+    "pydantic-settings==2.10.1",
+    "python-dotenv>=1.1.1",
+]

requirements.txt

@@ -1,3 +1,7 @@
-fastapi
-uvicorn[standard]
-
+fastapi[standard]==0.116.1
+google-genai==1.27.0
+loguru==0.7.3
+openai==1.97.0
+pillow==11.3.0
+pydantic-settings==2.10.1
+python-dotenv>=1.1.1

src/api/v1/ad_routers.py

@@ -0,0 +1,94 @@
+import json
+from loguru import logger
+from typing import Annotated
+from fastapi import (
+    APIRouter, 
+    HTTPException, 
+    Depends
+)
+from fastapi.responses import StreamingResponse
+
+from src.models import AdGenerationRequest, AdGenerationResponse
+from src.service.ad_service import get_ad_service, AdService
+from src.utils.helpers import generate_request_id
+from src.config import settings
+
+
+router = APIRouter(prefix=settings.API_V1_PREFIX, tags=["Advertisement Generation"])
+
+@router.post(
+    "/generate",
+    response_model=AdGenerationResponse,
+    summary="Generate Advertisement",
+    description="Generate advertisement with optional image processing"
+)
+async def generate_ad(
+    request: AdGenerationRequest,
+    ad_service: Annotated[AdService, Depends(get_ad_service)],
+):
+    """
+    Generate advertisement content based on the provided request.
+    
+    Parameters:
+    - request: AdGenerationRequest containing product details and ad settings.
+    
+    Returns:
+    - AdGenerationResponse with generated ad content and metadata.
+    """
+    try:
+        response = await ad_service.generate_ad(request)
+        return response
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "generation_failed",
+                "message": str(e),
+                "request_id": generate_request_id()
+            }
+        )
+
+@router.post(
+    "/generate-stream",
+    summary="Generate Advertisement (Streaming)",
+    description="Generate advertisement with streaming response"
+)
+async def generate_ad_streaming(
+    request: AdGenerationRequest,
+    ad_service: Annotated[AdService, Depends(get_ad_service)],
+):
+    """
+    Generate advertisement content with streaming response.
+    
+    Parameters:
+    - request: AdGenerationRequest containing product details and ad settings.
+    
+    Returns:
+    - StreamingResponse with chunks of generated ad content.
+    """
+    async def stream_response():
+        try:
+            async for chunk in ad_service.generate_ad_streaming(request):
+                yield json.dumps(chunk, default=str) + "\n"
+        except Exception as e:
+            logger.info(e)
+            error_response = {
+                "status": "error",
+                "error_code": "generation_failed",
+                "message": str(e),
+                "request_id": generate_request_id()
+            }
+            yield json.dumps(error_response) + "\n"
+
+    return StreamingResponse(
+        stream_response(),
+        media_type="text/plain",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no"  # Disable nginx buffering
+        }
+    )

src/api/v1/imagen_router.py

@@ -0,0 +1,99 @@
+from loguru import logger
+from pathlib import Path
+from typing import Annotated
+from fastapi import (
+    APIRouter, 
+    HTTPException, 
+    Depends
+)
+
+from fastapi.responses import FileResponse
+
+from src.models.requests import ImageGenerationRequest
+from src.models.response import ImageResult
+from src.service.imagen_service import get_imagen_service, ImageService
+from src.config import settings
+from src.utils.helpers import generate_request_id
+
+
+router = APIRouter(prefix=settings.API_V1_PREFIX, tags=["Image Generation"])
+
+@router.post(
+    "/generate-image",
+    response_model=ImageResult,
+    summary="Generate Image",
+    description="Generate an image based on product details"
+)
+async def generate_image(
+    request: ImageGenerationRequest,
+    imagen_service: Annotated[ImageService, Depends(get_imagen_service)],
+):
+    """
+    Generate an image based on the provided product details.
+    
+    Parameters:
+    - request: ImageGenerationRequest containing product details.
+    
+    Returns:
+    - ImageResult with generated image URL and metadata.
+    """
+    try:
+        result = imagen_service.generate_image(request)
+        if result is None:
+            raise HTTPException(status_code=500, detail="Image generation failed")
+        return result
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "image_generation_failed",
+                "message": str(e),
+                "request_id": generate_request_id()
+            }
+        )
+
+from pathlib import Path
+
+@router.get(
+    "/images/{file_name}",
+    summary="Get Image",
+    description="Retrieve an image by its file name"
+)
+async def get_image(file_name: str):
+    """
+    Retrieve an image by its file name.
+    
+    Parameters:
+    - file_name: Name of the image file to retrieve.
+    
+    Returns:
+    - Image file if found, otherwise raises HTTP 404 error.
+    """
+    logger.info(f"Retrieving image: {file_name}")
+    try:
+        upload_dir = Path(settings.UPLOAD_DIR)
+        file_path = upload_dir / file_name
+
+        if not file_path.exists():
+            logger.warning(f"Image not found: {file_name}")
+            raise HTTPException(status_code=404, detail="Image not found")
+        
+        logger.info(f"Image retrieved successfully: {file_name}")
+        return FileResponse(
+            path=file_path,
+            media_type="image/png",
+            filename=file_name
+        )
+    except Exception as e:
+        logger.critical(f"Critical error during image retrieval: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "image_retrieval_failed",
+                "message": str(e),
+                "request_id": generate_request_id()
+            }
+        )

src/config/__init__.py

@@ -0,0 +1,3 @@
+from .settings import settings
+
+__all__ = ["settings"]

src/config/settings.py

@@ -0,0 +1,80 @@
+from typing import Optional
+from pathlib import Path
+from functools import lru_cache
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv, find_dotenv
+
+_ = load_dotenv(find_dotenv())
+
+
+class Settings(BaseSettings):
+    # App Configuration
+    APP_NAME: str = "Ad Generator MVP"
+    APP_VERSION: str = "1.0.0"
+    APP_DESCRIPTION: str = "A minimal viable product for ad generation using LLMs."
+    DEBUG: bool = False
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+    
+    # API Configuration
+    API_V1_PREFIX: str = "/api/v1"
+    CORS_ORIGINS: list[str] = ["*"]
+    
+    # File Upload Configuration
+    UPLOAD_DIR: str = "uploads"
+    MAX_FILE_SIZE: int = 5 * 1024 * 1024  # 5MB
+    ALLOWED_FILE_EXTENSIONS: set[str] = {".jpg", ".jpeg", ".png", ".webp"}
+    ALLOWED_IMAGE_TYPES: set[str] = {"image/jpeg", "image/png", "image/webp"}
+    
+
+    # LLM settings 
+    LUNOS_API_KEY: str 
+    LUNOS_BASE_URL: str = "https://api.lunos.tech/v1"
+    DEFAULT_MODEL_NAME: str = "google/gemma-3-12b-it"
+
+    # Gemini Image Generation settings
+    GEMINI_API_KEY: str 
+    GEMINI_IMAGE_MODEL_NAME: str = "gemini-2.0-flash-preview-image-generation"
+
+    #  add safety settings
+    SAFETY_SETTINGS: list[dict] = [
+        {
+            "category": "HARM_CATEGORY_HARASSMENT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_HATE_SPEECH",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        }
+    ]
+    # Rate Limiting
+    RATE_LIMIT_REQUESTS: int = 100
+    RATE_LIMIT_WINDOW: int = 3600  # 1 hour in seconds
+    
+    # Storage Configuration
+    STORAGE_TYPE: str = "local"  # local, s3, cloudinary
+    
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = True
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Create upload directory if it doesn't exist
+        Path(self.UPLOAD_DIR).mkdir(exist_ok=True)
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()
+
+settings = get_settings()

src/core/ad_generator.py

@@ -0,0 +1,149 @@
+from time import time
+from typing import Any, Dict, AsyncIterator
+from src.core.base import BaseAdGenerator
+from src.models import (
+    AdGenerationRequest,
+    AdGenerationResponse,
+    ProductInfo,
+    AdSettings
+)
+from src.llm.openai_client import OpenAIClient 
+from src.prompts.templates import FlexibleAdPromptGenerator
+from src.utils.helpers import generate_request_id
+     
+
+class AIAdGenerator(BaseAdGenerator):
+    """
+    AIAdGenerator is responsible for generating advertisements using an LLM client.
+    It utilizes a flexible prompt generator to create prompts based on the ad type and tone specified in the request.
+    The generator can handle both standard and streaming responses, providing detailed ad content along with product information and settings.
+    """
+
+    def __init__(self) -> None:
+        """ 
+        Initializes the AIAdGenerator with an OpenAI client and a flexible prompt generator.
+        """
+        self.llm = OpenAIClient()
+        self.prompt = FlexibleAdPromptGenerator()
+
+    async def generate(self, request: AdGenerationRequest, **kwargs) -> AdGenerationResponse:
+        """
+        Generates an advertisement based on the provided request.
+        Parameters:
+            - request: AdGenerationRequest containing product details and ad settings.
+        Returns:
+            - AdGenerationResponse with generated ad content and metadata.
+        """
+        start = time()
+        identifier = generate_request_id()
+
+        try:
+            system_prompt = self.prompt.generate_prompt(
+                ad_type=request.ad_type,
+                ad_tone=request.ad_tone,
+            )
+            product_data = request.model_dump(exclude={"ad_type", "ad_tone"})
+            product_str = "\n".join(f"{k}: {v}" for k, v in product_data.items() if v is not None)
+
+
+            ad_content = await self.llm.generate_text(
+                system=system_prompt,
+                data_product=product_str,
+                max_tokens=1000,
+                temperature=1.0,
+                **kwargs
+            )
+
+            generation_time = time() - start
+
+            return AdGenerationResponse(
+                ad_content=ad_content,
+                product_info=ProductInfo(
+                    product_name=request.product_name,
+                    brand=request.brand_name,
+                    category=request.category,
+                    description=request.description,
+                    price=request.price,
+                    discounted_price=request.discounted_price,
+                    store_link=request.product_url,
+                ),
+                ad_settings=AdSettings(
+                    ad_type=request.ad_type,
+                    ad_tone=request.ad_tone,
+                ),
+                generation_time=generation_time,
+                model_used=self.llm.model_name,
+                request_id=identifier
+            )
+        except Exception as e:
+            raise Exception(f"Ad generation failed: {str(e)}")
+    
+    async def generate_streaming(self, request: AdGenerationRequest, **kwargs) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Generates an advertisement with streaming response based on the provided request.
+        Parameters:
+            - request: AdGenerationRequest containing product details and ad settings.
+        Returns:
+            - AsyncIterator yielding chunks of generated ad content and metadata.
+        """
+        start = time()
+        identifier = generate_request_id()
+
+        try:
+            yield {
+                "status": "processing",
+                "message": "Generating your advertisement...",
+                "request_id": identifier
+            }
+
+            accumulate_content = ""
+            product_data = request.model_dump(exclude={"ad_type", "ad_tone"})
+            product_str = "\n".join(f"{k}: {v}" for k, v in product_data.items() if v is not None)
+
+            system_prompt = self.prompt.generate_prompt(
+                ad_type=request.ad_type,
+                ad_tone=request.ad_tone,
+            )
+
+            async for chunk in self.llm.generate_text_streaming(
+                system=system_prompt,
+                data_product=product_str,
+                max_tokens=1000,
+                temperature=1.0,
+                stream=True,
+                **kwargs
+            ):
+                accumulate_content += chunk
+                yield {
+                    "status": "streaming",
+                    "content": chunk,
+                    "progress": min(len(accumulate_content) / 500 * 100, 95)  # Rough progress estimate
+                } 
+            # Final response after streaming is complete
+            yield {
+                "status": "completed",
+                "ad_content": accumulate_content,
+                "product_info": {
+                    "product_name": request.product_name,
+                    "brand": request.brand_name,
+                    "category": request.category,
+                    "description": request.description,
+                    "price": request.price,
+                    "discounted_price": request.discounted_price,
+                    "store_link": request.product_url,
+                },
+                "ad_settings": {
+                    "ad_type": request.ad_type,
+                    "ad_tone": request.ad_tone,
+                },
+                "generation_time": time() - start,
+                "model_used": self.llm.model_name,
+                "request_id": identifier
+            }
+        except Exception as e:
+            yield {
+                "status": "error",
+                "message": str(e),
+                "error_code": "generation_failed",
+                "request_id": identifier
+            }

src/core/base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import AsyncIterator, Dict, Any
+from src.models.requests import AdGenerationRequest
+
+
+class BaseAdGenerator(ABC):
+    """Abstract base class for ad generators"""
+    
+    @abstractmethod
+    async def generate(self, request: AdGenerationRequest, **kwargs):
+        """Generate advertisement"""
+        pass
+    
+    @abstractmethod
+    async def generate_streaming(self, request: AdGenerationRequest, **kwargs) -> AsyncIterator[Dict[str, Any]]:
+        """Generate advertisement with streaming response"""
+        pass

src/core/image_generator.py

@@ -0,0 +1,64 @@
+from PIL import Image
+from io import BytesIO
+from pathlib import Path
+from typing import Optional
+from loguru import logger
+
+from src.llm.gemini_client import GeminiImageGeneration
+from src.prompts.imagen_prompt import IMAGEN_PROMPT_TEMPLATE
+from src.config import settings
+
+
+class ImageGenerator:
+    """
+    Class to handle image generation using Gemini Image Generation API.
+    This class provides methods to generate image prompts based on product details
+    and save the generated images to a specified directory.
+    """
+    def __init__(self) -> None:
+        self.imagen = GeminiImageGeneration()
+        self.prompt_template = IMAGEN_PROMPT_TEMPLATE
+        self.save_dir = Path(settings.UPLOAD_DIR)
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_image_prompt(
+        self,
+        product_name: str,
+        brand_name: str,
+        product_description: str
+    ) -> Optional[str]:
+        """
+        Generate image prompt for the given product details.
+        
+        Args:
+            product_name: Name of the product
+            brand_name: Brand name of the product
+            product_description: Description of the product
+            
+        Returns:
+            Generated image prompt string
+        """
+        try:
+            file_name = f"{product_name.replace(' ', '_')}_{brand_name.replace(' ', '_')}.png"
+            file_path = self.save_dir / file_name
+            prompt = self.prompt_template.format(
+                product_name=product_name,
+                brand_name=brand_name,
+                product_description=product_description
+            )
+
+            response = self.imagen.generate_image(prompt=prompt)
+
+            for part in response.candidates[0].content.parts:
+                if part.text is not None:
+                    logger.info(f"Generated text: {part.text}")
+                elif part.inline_data is not None:
+                    image_data = part.inline_data.data
+                    image = Image.open(BytesIO(image_data))
+                    image.save(file_path)
+                    logger.info(f"Image saved to: {file_path}")
+                    return str(file_path)         
+        except Exception as e:
+            logger.error(f"Error generating image prompt: {e}")
+            raise RuntimeError(f"Failed to generate image prompt: {e}")
+            

src/llm/base.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import AsyncIterator
+
+class BaseLLMClient(ABC):
+    """Abstract base class for LLM clients"""
+    
+    @abstractmethod
+    async def generate_text(
+        self, 
+        prompt: str, 
+        max_tokens: int = 1000, 
+        temperature: float = 1,
+        **kwargs
+    ) -> str:
+        """Generate text response"""
+        pass
+    
+    @abstractmethod
+    async def generate_text_streaming(
+        self, 
+        prompt: str, 
+        max_tokens: int = 1000, 
+        temperature: float = 1,
+        stream: bool = True,
+        **kwargs
+    ) -> AsyncIterator[str]:
+        """Generate text with streaming response"""
+        pass
+
+    @abstractmethod
+    async def health_check(self) -> bool:
+        """Check if the LLM service is healthy"""
+        pass
+
+    @abstractmethod
+    async def generate_image(
+        self, 
+        prompt: str, 
+        max_tokens: int = 1000, 
+        temperature: float = 1,
+        **kwargs
+    ) -> str:
+        """Generate image based on the prompt"""
+        pass

src/llm/gemini_client.py

@@ -0,0 +1,69 @@
+from PIL import Image
+from loguru import logger
+from typing import Optional, Tuple, Union
+from google import genai
+from google.genai import types as genai_types
+
+from src.llm.base import BaseLLMClient
+from src.config import settings
+
+
+class GeminiImageGeneration(BaseLLMClient):
+    """
+    GeminiImageGeneration is a client for interacting with the Gemini 2.0 Flash Preview Image Generation
+    It supports generating images based on text prompts.
+    It requires an API key and a model name to be initialized.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, model_name: Optional[str] = None) -> None:
+        
+        self.api_key = api_key or settings.GEMINI_API_KEY
+        self.model_name = model_name or settings.GEMINI_IMAGE_MODEL_NAME
+
+        if not self.api_key:
+            raise ValueError("Gemini API key is required")
+        
+        self.client = genai.Client(api_key=self.api_key)
+
+    def generate_image(
+        self, 
+        prompt: str,
+    ) -> Optional[Union[Image.Image, Tuple[Image.Image, str]]]:
+        """
+        Generate image using Gemini 2.0 Flash Preview Image Generation
+        
+        Args:
+            prompt: Text prompt for image generation
+            save_path: Optional path to save the image
+            
+        Returns:
+            PIL Image object or tuple of (Image, saved_path) if save_path provided
+        """
+        try:
+            logger.info(f"Generating image with prompt: {prompt[:100]}...")
+            
+            # Generate content with Gemini
+            response = self.client.models.generate_content(
+                model=self.model_name,
+                contents=prompt,
+                config=genai_types.GenerateContentConfig(
+                    response_modalities=['TEXT', 'IMAGE'],
+                    temperature=1.0,
+                    top_p=1,
+                    top_k=32,
+                    max_output_tokens=1024,
+                )
+            )
+            return response
+        except Exception as e:
+            logger.error(f"Error generating image with Gemini: {e}")
+            return None
+    
+    def generate_text(self):
+        pass
+
+    def generate_text_streaming(self):
+        pass
+
+    def health_check(self):
+        return super().health_check()

src/llm/openai_client.py

@@ -0,0 +1,104 @@
+import openai
+from openai import AsyncOpenAI
+from typing import Optional, AsyncIterator
+from src.config import settings
+from src.llm.base import BaseLLMClient
+
+
+class OpenAIClient(BaseLLMClient):
+    """
+    OpenAIClient is a client for interacting with the OpenAI API.
+    It supports both synchronous and asynchronous operations for generating text and streaming responses.
+    It requires an API key and a model name to be initialized.
+    """
+    
+    def __init__(self, api_key: Optional[str] = None, model_name: Optional[str] = None) -> None:
+        """
+        Initialize the OpenAIClient with an API key and model name.
+        If no API key is provided, it will use the one from settings.
+        If no model name is provided, it defaults to "google/gemma-3-12b-it".
+        """
+        self.api_key = api_key or settings.LUNOS_API_KEY
+        self.model_name = model_name or settings.DEFAULT_MODEL_NAME
+
+        if not self.api_key:
+            raise ValueError("Lunos API key is required")
+        
+        self.client = AsyncOpenAI(
+            api_key=self.api_key,
+            base_url=settings.LUNOS_BASE_URL
+        )
+    async def generate_text(
+        self, 
+        system: str,
+        data_product: str, 
+        max_tokens: int = 1000, 
+        temperature: float = 1.0,
+        **kwargs
+    ) -> str:
+        """Generate text using the OpenAI API"""
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": data_product}
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+                **kwargs
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except openai.APIError as e:
+            raise Exception(f"Lunor API error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Text generation failed: {str(e)}")
+    
+
+    async def generate_text_streaming(
+            self, 
+            system: str, 
+            data_product: str,
+            max_tokens: int = 1000, 
+            temperature: float = 1.0,
+            stream: bool = True,
+            **kwargs
+        ) -> AsyncIterator[str]:
+        """Generate text with streaming response"""
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": data_product}
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+                stream=stream,
+                **kwargs
+            )
+            async for chunk in response:
+                if chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+        except openai.APIError as e:
+            raise Exception(f"Lunor API error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Text generation streaming failed: {str(e)}")
+        
+    async def health_check(self) -> bool:
+        """Check if OpenAI API is accessible"""
+        try:
+            # Simple test request
+            await self.client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=1
+            )
+            return True
+        except Exception:
+            return False
+        
+    def generate_image(self):
+        pass

src/main.py

@@ -0,0 +1,40 @@
+from loguru import logger
+from datetime import datetime
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from src.api.v1.ad_routers import router as ad_router
+from src.api.v1.imagen_router import router as imagen_router
+from src.config import settings
+
+
+logger.add("logger.log", rotation="10 MB", retention="10 days", level="DEBUG")
+
+app = FastAPI(
+    title=settings.APP_NAME,
+    version=settings.APP_VERSION,
+    debug=settings.DEBUG,
+    description=settings.APP_DESCRIPTION,
+)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# add router healthcheck
+@app.get("/healthcheck")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "version": settings.APP_VERSION,
+        "service": settings.APP_NAME
+    }
+
+
+# Register API router
+app.include_router(ad_router)
+app.include_router(imagen_router)

src/models/__init__.py

@@ -0,0 +1,9 @@
+from .requests import AdGenerationRequest
+from .response import AdGenerationResponse, ProductInfo, AdSettings
+
+__all__ = [
+    "AdGenerationRequest",
+    "AdGenerationResponse",
+    "ProductInfo",
+    "AdSettings"
+]

src/models/requests.py

@@ -0,0 +1,44 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class AdGenerationRequest(BaseModel):
+    """Product input from user form"""
+    # product information
+    product_name: str = Field(..., min_length=1, max_length=200)
+    brand_name: str = Field(None, max_length=100)
+    category: List[str] = Field(..., min_length=1, max_length=100)
+    description: str = Field(None)
+    product_url: Optional[str] = Field(None, max_length=1000)
+
+    # price
+    price: Optional[float] = Field(None, gt=0)
+    discounted_price: Optional[float] = Field(None, gt=0)
+    
+    # type and tone
+    ad_type: Optional[str] = Field(None, max_length=50)
+    ad_tone: Optional[str] = Field(None, max_length=50)
+
+
+class ImageGenerationRequest(BaseModel):
+    """Request model for standalone image generation"""
+    product_name: str = Field(..., min_length=1, max_length=200)
+    brand_name: str = Field(None, max_length=100)
+    description: str = Field(None)
+    
+
+class AdType(str, Enum):
+    SOCIAL_MEDIA = "social_media"
+    EMAIL = "email"
+    PRODUCT_DESCRIPTION = "product_description"
+
+class AdTone(str, Enum):
+    FRIENDLY = "friendly"
+    PROFESSIONAL = "professional" 
+    URGENT = "urgent"
+    PLAYFUL = "playful"
+    LUXURIOUS = "luxurious"
+    MINIMALIST = "minimalist"
+    BOLD = "bold"
+    CONVERSATIONAL = "conversational"

src/models/response.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Optional, Literal, List
+from decimal import Decimal
+
+class ProductInfo(BaseModel):
+    """Product information"""
+    product_name: str
+    brand: Optional[str]
+    category: List[str]
+    description: str
+    price: Optional[Decimal]
+    discounted_price: Optional[Decimal]
+    store_link: str
+
+class AdSettings(BaseModel):
+    """Settings for ad generation"""
+    ad_type: str = Field(..., description="Type of advertisement")
+    ad_tone: str = Field(..., description="Tone of the advertisement")
+
+class ImageResult(BaseModel):
+    """Internal model for image processing results"""
+    image_path: Optional[str] = None  # Local file path (for uploaded/generated)
+    image_url: Optional[str] = None  # URL for accessing the image
+    source: str  # "uploaded", "url", "generated"
+    generated: bool = False  # True if AI generated
+
+class AdGenerationResponse(BaseModel):
+    """Complete response for ad generation"""
+    
+    # Main content
+    ad_content: str = Field(description="Generated advertisement content")
+    
+    # Metadata
+    product_info: ProductInfo
+    ad_settings: AdSettings
+    # image_info: ImageInfo
+    
+    # Generation metadata
+    generation_time: float = Field(description="Total generation time in seconds")
+    model_used: str = Field(description="AI model used for generation")
+    request_id: str = Field(description="Unique request identifier")
+    timestamp: datetime = Field(default_factory=datetime.now)