Architecture Technique

Vue d'ensemble

Schéma de Flux

┌─────────────────────────────────────────────────────────────────────┐
│                    MAD LORDS STUDIO IA - ARCHITECTURE               │
└─────────────────────────────────────────────────────────────────────┘

      ┌──────────────┐
      │  Client iOS  │
      │  React Native│
      └──────┬───────┘
             │ HTTPS/REST
             ▼
      ┌──────────────┐       ┌─────────────────────┐
      │   API        │◄─────►│  Auth Service       │
      │   Gateway    │       │  (JWT + OAuth2)     │
      └──────┬───────┘       └─────────────────────┘
             │
    ┌────────┴────────┬────────────────┬────────────────┐
    ▼                 ▼                ▼                ▼
┌─────────┐    ┌───────────┐   ┌────────────┐   ┌─────────────┐
│ Prompt  │    │ IA 2D     │   │ Pipeline   │   │ Printer     │
│ Engine  │    │ Stable-   │   │ 2D → 3D    │   │ Integration │
│ (Brief) │    │ Diffusion │   │ Tripo AI   │   │ SDK         │
└────┬────┘    └─────┬─────┘   └─────┬──────┘   └──────┬──────┘
     │               │               │                 │
     │               ▼               ▼                 ▼
     │        ┌────────────────────────────────────────────┐
     └───────►│              PostgreSQL + Redis            │
              │     (Users, Projects, Assets, Queue)       │
              └─────────────────────┬──────────────────────┘
                                    │
                                    ▼
              ┌────────────────────────────────────────────┐
              │           Object Storage (S3)              │
              │  (Images 2D, Modèles 3D, Fichiers STL)     │
              └────────────────────────────────────────────┘

Technologies

Stack Technologique

Frontend Mobile

React Native — Application iOS native
Expo SDK 51 — Build & distribution
Three.js — Rendu 3D interactif
React Navigation 6 — Navigation fluide
Reanimated 3 — Animations performantes
AsyncStorage — Persistance locale

Backend API

Python 3.11+ — Langage principal
FastAPI — Framework API REST
Celery — Tâches asynchrones
SQLAlchemy — ORM base de données
Pydantic — Validation des données
Uvicorn — Serveur ASGI

Bases de Données

PostgreSQL 15 — Données relationnelles
Redis 7 — Cache & queue
S3 — Stockage objets (assets)
AWS Secrets Manager — Secrets sécurisés

Services IA

Stable Diffusion XL — Génération 2D fine-tunée
Tripo AI — Conversion 2D → 3D
RunPod/Replicate — Inférence GPU
ComfyUI — Pipeline IA orchestré
Fine-tuning LoRA — Style Mad Lords

Intégration 3D

Blender 4.x — Scripts automatisés mesh
OpenMesh — Validation géométrique
Formlabs SDK — Imprimante Form 4
PreForm API — Préparation impression
STL Validator — Check fabricabilité

Infrastructure

AWS ECS — Containers managés
AWS RDS — PostgreSQL managé
AWS ElastiCache — Redis managé
CloudFlare — CDN & WAF
GitHub Actions — CI/CD

IA Générative

Pipeline de Génération 2D

De l'Intention au Prompt Optimisé

Le moteur de prompt guidé transforme les choix utilisateur en prompt technique optimisé pour Stable Diffusion.

class GuidedPromptEngine:
    """Convertit les choix utilisateur en prompt IA optimisé"""
    
    def build_prompt(self, brief: JewelryBrief) -> str:
        components = []
        
        # Type de bijou
        components.append(f"{brief.jewelry_type} jewelry piece")
        
        # Vocabulaire Mad Lords selon l'univers
        style_mapping = {
            "desert_sun": "desert sun aesthetic, warm golden tones, sand textures",
            "moon_stars": "celestial motifs, moon phase, silver luminance",
            "serpents": "snake coils, reptilian scales, mystical serpent",
            "sacred": "sacred geometry, ancient symbols, spiritual sigils",
        }
        components.append(style_mapping.get(brief.universe))
        
        # Matériaux et finitions
        components.append(f"{brief.metal} metal, {brief.finish} finish")
        
        # Paramètres techniques LoRA
        lora_trigger = "<lora:madlords_style_v1:0.8>"
        
        return self._assemble(components, lora_trigger)

Stable Diffusion XL Fine-Tuné

Modèle SDXL enrichi par entraînement LoRA sur le catalogue Mad Lords :

Dataset : 500+ images bijoux Mad Lords existants
Epochs : 20 passes d'entraînement
Triggers : Vocabulaire spécifique (madlords_ring, madlords_pendant...)
Résolution : 1024×1024 natif, upscale 2K pour détails

Conversion 3D

Pipeline 2D → 3D

De l'Image au Modèle Imprimable

# Étape 1: Conversion via Tripo AI
POST /api/tripo/generate
{
    "image_url": "s3://madlords/renders/ring_001.png",
    "mode": "jewelry_detailed",
    "output_format": "glb"
}

# Étape 2: Post-traitement Blender (script Python)
bpy.ops.wm.open_mainfile(filepath="raw_model.glb")
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.remove_doubles(threshold=0.0001)      # Fusion vertices
bpy.ops.mesh.fill_holes(sides=64)                  # Fermeture trous
bpy.ops.object.modifier_add(type='SOLIDIFY')       # Épaisseur minimale
bpy.ops.export_mesh.stl(filepath="output.stl")

# Étape 3: Validation STL pour joaillerie
class STLValidator:
    MIN_WALL_THICKNESS = 0.8   # mm - minimum pour fonte or
    MAX_OVERHANGS = 45         # degrés - supportable sans structures
    
    def validate(self, stl_path: str) -> ValidationResult:
        mesh = trimesh.load(stl_path)
        
        checks = {
            "manifold": mesh.is_watertight,
            "wall_thickness": self._check_thickness(mesh),
            "overhangs": self._check_overhangs(mesh),
            "volume": mesh.volume > 10,  # mm³ minimum
        }
        
        return ValidationResult(
            valid=all(checks.values()),
            details=checks
        )

Fabrication

Intégration Imprimante 3D

Imprimantes Compatibles

Modèle	Technologie	Précision
Formlabs Form 4	MSLA	25 μm
Asiga MAX X	DLP	27 μm
Envision One cDLM	cDLM	25 μm

Résine de Production

Formlabs Castable Wax 40 — Résine spéciale pour fonte à cire perdue, brûlage propre, détails fins jusqu'à 50μm.

SDK Formlabs

class FormlabsPrinterSDK:
    
    async def prepare_print(
        self, 
        stl_path: str,
        resin: str = "castable_wax_40"
    ) -> PrintJob:
        # Upload vers PreForm
        job = await self.preform.upload(
            stl_path,
            orientation="auto",
            supports="auto_light"
        )
        
        # Estimation temps et résine
        estimate = await job.estimate()
        
        return PrintJob(
            id=job.id,
            duration=estimate.time,
            resin_ml=estimate.resin,
            layer_height=0.025  # 25μm
        )
    
    async def start_print(self, job_id: str):
        return await self.printer.start(job_id)
    
    async def get_status(self, job_id: str):
        return await self.printer.status(job_id)

Base de données

Modèle de Données

┌─────────────────┐       ┌─────────────────┐       ┌─────────────────┐
│      USERS      │       │    PROJECTS     │       │     ASSETS      │
├─────────────────┤       ├─────────────────┤       ├─────────────────┤
│ id (PK)         │──────<│ user_id (FK)    │──────<│ project_id (FK) │
│ email           │       │ id (PK)         │       │ id (PK)         │
│ invitation_code │       │ jewelry_type    │       │ type (2d/3d/stl)│
│ created_at      │       │ universe        │       │ s3_path         │
│ profile_data    │       │ budget          │       │ version         │
└─────────────────┘       │ metal           │       │ validation      │
                          │ stones          │       │ created_at      │
                          │ status          │       └─────────────────┘
                          │ brief_json      │
                          │ prompt          │       ┌─────────────────┐
                          │ created_at      │       │    PAYMENTS     │
                          └────────┬────────┘       ├─────────────────┤
                                   │────────────────>│ project_id (FK) │
                                                     │ id (PK)         │
                                                     │ type (20/30/50) │
                                                     │ amount          │
                                                     │ stripe_id       │
                                                     │ status          │
                                                     │ paid_at         │
                                                     └─────────────────┘

DevOps

Pipeline CI/CD

GitHub Actions Workflow

name: Deploy Mad Lords Backend

on:
  push:
    branches: [main, staging]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Tests
        run: |
          pytest tests/ --cov=app
          
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - name: Build Docker Image
        run: docker build -t madlords-api .
      - name: Push to ECR
        run: aws ecr push madlords-api:${{ github.sha }}
        
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to ECS
        run: |
          aws ecs update-service \
            --cluster madlords-prod \
            --service api \
            --force-new-deployment

Environnements

Environnement	Branche	URL
Production	main	api.madlords.studio
Staging	staging	staging-api.madlords.studio
Dev	develop	dev-api.madlords.studio