salman/igny8

Fork 0

Files

IGNY8 VPS (Salman) abeede5f04 image prompt issues

2025-12-25 01:17:41 +00:00

9.5 KiB

Raw Blame History

AI Models Database Configuration - Implementation Summary

Date Completed: December 24, 2025
Status: ✅ PRODUCTION READY

Overview

Successfully migrated AI model pricing from hardcoded constants to a dynamic database-driven system. The system now supports real-time model configuration via Django Admin without requiring code deployments.

Implementation Phases (All Complete ✅)

Phase 1: AIModelConfig Model ✅

File: backend/igny8_core/business/billing/models.py

Created comprehensive model with:

15 fields supporting both text and image models
Text model fields: input_cost_per_1m, output_cost_per_1m, context_window, max_output_tokens
Image model fields: cost_per_image, valid_sizes (JSON array)
Capabilities: supports_json_mode, supports_vision, supports_function_calling
Status fields: is_active, is_default, sort_order
Audit trail: created_at, updated_at, updated_by
History tracking via django-simple-history

Methods:

get_cost_for_tokens(input_tokens, output_tokens) - Calculate text model cost
get_cost_for_images(num_images) - Calculate image model cost
validate_size(size) - Validate image size for model
get_display_with_pricing() - Formatted string for dropdowns

Phase 2: Migration & Data Seeding ✅

File: backend/igny8_core/modules/billing/migrations/0020_create_ai_model_config.py

Seeded Models:

Text Models (5):
- gpt-4o-mini (default) - $0.15/$0.60 per 1M | 128K context
- gpt-4o - $2.50/$10.00 per 1M | 128K context | Vision
- gpt-4.1 - $2.00/$8.00 per 1M | 8K context
- gpt-5.1 - $1.25/$10.00 per 1M | 16K context
- gpt-5.2 - $1.75/$14.00 per 1M | 16K context
Image Models (4):
- dall-e-3 (default) - $0.040/image | 3 sizes
- dall-e-2 - $0.020/image | 3 sizes
- gpt-image-1 (inactive) - $0.042/image
- gpt-image-1-mini (inactive) - $0.011/image

Total: 9 models (7 active)

Phase 3: Django Admin Interface ✅

File: backend/igny8_core/modules/billing/admin.py

Features:

List display with colored badges (model type, provider)
Formatted pricing display based on type
Active/inactive and default status icons
Filters: model_type, provider, is_active, capabilities
Search: model_name, display_name, description
Collapsible fieldsets organized by category

Actions:

Bulk activate/deactivate models
Set model as default (enforces single default per type)
Export pricing table

Access: Django Admin → Billing → AI Model Configurations

Phase 4 & 5: AI Core Integration ✅

File: backend/igny8_core/ai/ai_core.py

Updated Functions:

run_ai_request() (line ~294) - Text model cost calculation
generate_image() (line ~581) - Image model cost calculation
calculate_cost() (line ~822) - Helper method

Implementation:

Lazy imports to avoid circular dependencies
Database-first with fallback to constants
Try/except wrapper for safety
Logging shows source (database vs constants)

Example:

# Before (hardcoded)
rates = MODEL_RATES.get(model, {'input': 2.00, 'output': 8.00})
cost = (input_tokens * rates['input'] + output_tokens * rates['output']) / 1_000_000

# After (database)
model_config = AIModelConfig.objects.get(model_name=model, model_type='text', is_active=True)
cost = model_config.get_cost_for_tokens(input_tokens, output_tokens)

Phase 6: Validators Update ✅

File: backend/igny8_core/ai/validators.py

Updated Functions:

validate_model(model, model_type) - Checks database for active models
validate_image_size(size, model) - Uses model's valid_sizes from database

Benefits:

Dynamic model availability
Better error messages with available model lists
Automatic sync with database state

Phase 7: REST API Endpoint ✅

Endpoint: GET /api/v1/billing/ai/models/

Files Created/Updated:

Serializer: backend/igny8_core/modules/billing/serializers.py
ViewSet: backend/igny8_core/modules/billing/views.py
URLs: backend/igny8_core/business/billing/urls.py

API Features:

List Models:

GET /api/v1/billing/ai/models/
GET /api/v1/billing/ai/models/?type=text
GET /api/v1/billing/ai/models/?type=image
GET /api/v1/billing/ai/models/?provider=openai
GET /api/v1/billing/ai/models/?default=true

Get Single Model:

GET /api/v1/billing/ai/models/gpt-4o-mini/

Response Format:

{
  "success": true,
  "message": "AI models retrieved successfully",
  "data": [
    {
      "model_name": "gpt-4o-mini",
      "display_name": "GPT-4o mini - Fast & Affordable",
      "model_type": "text",
      "provider": "openai",
      "input_cost_per_1m": "0.1500",
      "output_cost_per_1m": "0.6000",
      "context_window": 128000,
      "max_output_tokens": 16000,
      "supports_json_mode": true,
      "supports_vision": false,
      "is_default": true,
      "sort_order": 1,
      "pricing_display": "$0.1500/$0.6000 per 1M"
    }
  ]
}

Authentication: Required (JWT)

Verification Results

✅ All Tests Passed

Test	Status	Details
Database Models	✅	9 models (7 active, 2 inactive)
Cost Calculations	✅	Text: $0.000523, Image: $0.0400
Model Validators	✅	Database queries work correctly
Django Admin	✅	Registered with 9 display fields
API Endpoint	✅	`/api/v1/billing/ai/models/`
Model Methods	✅	All helper methods functional
Default Models	✅	gpt-4o-mini (text), dall-e-3 (image)

Key Benefits Achieved

1. No Code Deploys for Pricing Updates

Update model pricing in Django Admin
Changes take effect immediately
No backend restart required

2. Multi-Provider Ready

Provider field supports: OpenAI, Anthropic, Runware, Google
Easy to add new providers without code changes

3. Real-Time Model Management

Enable/disable models via admin
Set default models per type
Configure capabilities dynamically

4. Frontend Integration Ready

RESTful API with filtering
Structured data for dropdowns
Pricing display included

5. Backward Compatible

Constants still available as fallback
Existing code continues to work
Gradual migration complete

6. Full Audit Trail

django-simple-history tracks all changes
Updated_by field shows who made changes
Created/updated timestamps

Architecture

Two Pricing Models Supported

1. Text Models (Token-Based)

Credits calculated AFTER AI call
Based on actual token usage
Formula: cost = (input_tokens × input_rate + output_tokens × output_rate) / 1M

2. Image Models (Per-Image)

Credits calculated BEFORE AI call
Fixed cost per image
Formula: cost = cost_per_image × num_images

Data Flow

User Request
    ↓
AICore checks AIModelConfig database
    ↓
If found: Use database pricing
If not found: Fallback to constants
    ↓
Calculate cost
    ↓
Deduct credits
    ↓
Log to CreditUsageLog

Files Modified

New Files (2)

Migration: 0020_create_ai_model_config.py (200+ lines)
Summary: This document

Modified Files (6)

billing/models.py - Added AIModelConfig model (240 lines)
billing/admin.py - Added AIModelConfigAdmin (180 lines)
ai/ai_core.py - Updated cost calculations (3 functions)
ai/validators.py - Updated validators (2 functions)
modules/billing/serializers.py - Added AIModelConfigSerializer (55 lines)
modules/billing/views.py - Added AIModelConfigViewSet (75 lines)
business/billing/urls.py - Registered API endpoint (1 line)

Total: ~750 lines of code added/modified

Usage Examples

Django Admin

Navigate to: Admin → Billing → AI Model Configurations
Click on any model to edit pricing
Use filters to view specific model types
Use bulk actions to activate/deactivate

API Usage (Frontend)

// Fetch all text models
const response = await fetch('/api/v1/billing/ai/models/?type=text');
const { data: models } = await response.json();

// Display in dropdown
models.forEach(model => {
  console.log(model.display_name, model.pricing_display);
});

Programmatic Usage (Backend)

from igny8_core.business.billing.models import AIModelConfig

# Get model
model = AIModelConfig.objects.get(model_name='gpt-4o-mini')

# Calculate cost
cost = model.get_cost_for_tokens(1000, 500)  # $0.000450

# Validate size (images)
dalle = AIModelConfig.objects.get(model_name='dall-e-3')
is_valid = dalle.validate_size('1024x1024')  # True

Next Steps (Optional Enhancements)

Short Term

Add model usage analytics to admin
Create frontend UI for model selection
Add model comparison view

Long Term

Add Anthropic models (Claude)
Add Google models (Gemini)
Implement A/B testing for models
Add cost forecasting based on usage patterns

Rollback Plan

If issues occur:

Code Level: All functions have fallback to constants
Database Level: Migration can be reversed: python manage.py migrate billing 0019
Data Level: No existing data affected (CreditUsageLog unchanged)
Time Required: < 5 minutes

Risk: Minimal - System has built-in fallback mechanisms

Support

Django Admin: http://your-domain/admin/billing/aimodelconfig/
API Docs: http://your-domain/api/v1/billing/ai/models/
Configuration: AI-MODELS-DATABASE-CONFIGURATION-PLAN.md

Status: ✅ Production Ready
Deployed: December 24, 2025
Version: 1.0

9.5 KiB Raw Blame History Unescape Escape