DJANGO_VS_FASTAPI.md

Дата: 2025-11-10
Версия: 1.0.0
Цель: Понять ЧТО ЕСТЬ и ЧЕГО НЕТ в каждом фреймворке

Быстрое сравнение (таблица)

Детальное сравнение по фичам

1. ORM (работа с базой данных)

Django ORM ✅

Функция	Django	FastAPI	Комментарий
ORM (работа с БД)	✅ Есть	❌ Нет	Django ORM из коробки, FastAPI - нужна SQLAlchemy
Админка	✅ Есть	❌ Нет	Django Admin готовая, FastAPI - нужно делать самому
Миграции БД	✅ Есть	❌ Нет	`python manage.py migrate` vs Alembic отдельно
Формы	✅ Есть	❌ Нет	Django Forms vs Pydantic (только валидация)
Аутентификация	✅ Есть	❌ Нет	Django Auth готова, FastAPI - вручную или библиотека
Сессии	✅ Есть	❌ Нет	Django sessions из коробки, FastAPI - middleware
Шаблоны (HTML)	✅ Есть	❌ Нет	Django Templates vs Jinja2 отдельно
API	🟡 DRF	✅ Да	Django REST Framework vs FastAPI (встроено)
Async/Await	🟡 Частично	✅ Полностью	Django 4.0+ async, FastAPI native
Скорость	🟡 Средняя	✅ Высокая	Django медленнее в 2-3 раза
Автодокументация API	❌ Нет	✅ Есть	DRF Browsable API vs Swagger/ReDoc
WebSocket	🟡 Channels	✅ Встроено	Django Channels отдельно, FastAPI из коробки
Type hints	🟡 Опционально	✅ Обязательно	Django не требует, FastAPI основан на typing
Размер фреймворка	🔴 Большой	🟢 Маленький	Django batteries included, FastAPI минималистичный

# models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.IntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

# Использование
products = Product.objects.all()
product = Product.objects.get(id=1)
product = Product.objects.filter(price__gt=100)
product = Product.objects.create(name="Phone", price=500)

Возможности:
- ✅ QuerySet API (filter, exclude, annotate, aggregate)
- ✅ Relationships (ForeignKey, ManyToMany, OneToOne)
- ✅ Миграции автоматически
- ✅ Валидация на уровне модели
- ✅ Signals (pre_save, post_save)
- ✅ Transactions
- ✅ Поддержка PostgreSQL, MySQL, SQLite, Oracle

FastAPI ORM ❌

# models.py
from sqlalchemy import Column, Integer, String, Decimal, DateTime
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class Product(Base):
    __tablename__ = "products"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(200))
    price = Column(Decimal(10, 2))
    stock = Column(Integer, default=0)
    created_at = Column(DateTime, default=datetime.utcnow)

# Использование (сложнее)
from sqlalchemy.orm import Session

def get_products(db: Session):
    return db.query(Product).all()

def create_product(db: Session, name: str, price: float):
    product = Product(name=name, price=price)
    db.add(product)
    db.commit()
    db.refresh(product)
    return product

Возможности:
- ✅ Мощный, гибкий
- ❌ Больше кода
- ❌ Сложнее для новичков
- ❌ Миграции отдельно (Alembic)

2. Админка (управление данными)

Django Admin ✅

# admin.py
from django.contrib import admin
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ['name', 'price', 'stock', 'created_at']
    list_filter = ['created_at']
    search_fields = ['name']
    ordering = ['-created_at']

http://localhost:8000/admin  ← Готовая админка!

┌─────────────────────────────────────────┐
│  Django administration                  │
├─────────────────────────────────────────┤
│  Products                               │
│  ├─ Add product                         │
│  ├─ Change product                      │
│  └─ Delete product                      │
│                                         │
│  [Search: _____________] [Filter ▼]    │
│                                         │
│  Name       Price    Stock   Created    │
│  ─────────────────────────────────────  │
│  Phone      $500     10      2025-11-10 │
│  Laptop     $1200    5       2025-11-09 │
│  Mouse      $25      50      2025-11-08 │
│                                         │
│  [Add Product] [Delete selected]        │
└─────────────────────────────────────────┘

Возможности:
- ✅ CRUD из коробки
- ✅ Поиск, фильтры, сортировка
- ✅ Массовые действия
- ✅ Редактирование связей
- ✅ Кастомизация (actions, inlines)
- ✅ Permissions (права доступа)
- ✅ История изменений
- ✅ 0 строк кода для базовой админки

FastAPI Admin ❌

Вывод: Django Admin - огромное преимущество для веб-приложений.

3. Миграции базы данных

Django Migrations ✅

# Создать миграцию
python manage.py makemigrations

# Применить миграцию
python manage.py migrate

# История миграций
python manage.py showmigrations

# Было
class Product(models.Model):
    name = models.CharField(max_length=200)

# Стало (добавили поле)
class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()  # ← Новое поле

$ python manage.py makemigrations
Migrations for 'shop':
  shop/migrations/0002_product_description.py
    - Add field description to product

$ python manage.py migrate
Running migrations:
  Applying shop.0002_product_description... OK

Возможности:
- ✅ Автоматическое создание миграций
- ✅ Откат миграций (rollback)
- ✅ Squash (слияние миграций)
- ✅ Data migrations (изменение данных)

FastAPI Migrations ❌

# Установка
pip install alembic

# Инициализация
alembic init alembic

# Создание миграции ВРУЧНУЮ
alembic revision -m "add description field"

# В файле миграции ВРУЧНУЮ пишем:
def upgrade():
    op.add_column('products', sa.Column('description', sa.Text()))

def downgrade():
    op.drop_column('products', 'description')

# Применение
alembic upgrade head

Отличия от Django:
- ❌ Не автоматическое (нужно писать вручную)
- ❌ Больше кода
- ❌ Легче ошибиться

4. Формы (для HTML)

Django Forms ✅

# forms.py
from django import forms
from .models import Product

class ProductForm(forms.ModelForm):
    class Meta:
        model = Product
        fields = ['name', 'price', 'stock']

# views.py
def create_product(request):
    if request.method == 'POST':
        form = ProductForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('product_list')
    else:
        form = ProductForm()

    return render(request, 'create.html', {'form': form})

<!-- create.html -->
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Create</button>
</form>

Возможности:
- ✅ Генерация HTML
- ✅ Валидация
- ✅ CSRF защита
- ✅ Field types (CharField, IntegerField, FileField)
- ✅ Widgets (TextInput, Select, DatePicker)
- ✅ ModelForm (автоформа из модели)

FastAPI Forms ❌

Что есть: НИЧЕГО (FastAPI для API, не для HTML форм)

from pydantic import BaseModel

class ProductCreate(BaseModel):
    name: str
    price: float
    stock: int = 0

@app.post("/products")
def create_product(product: ProductCreate):  # ← Автовалидация JSON
    # product.name, product.price - уже провалидированы
    pass

Отличия:
- ✅ Pydantic отлично для API (JSON валидация)
- ❌ НЕТ генерации HTML форм
- ❌ НЕТ CSRF (не нужно для API)

5. Аутентификация и авторизация

Django Auth ✅

# models.py
from django.contrib.auth.models import User  # ← Готовая модель

# views.py
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required

def login_view(request):
    user = authenticate(username='john', password='secret123')
    if user:
        login(request, user)
        return redirect('dashboard')

@login_required  # ← Защита view
def dashboard(request):
    return render(request, 'dashboard.html', {'user': request.user})

# Permissions
from django.contrib.auth.decorators import permission_required

@permission_required('shop.add_product')  # ← Проверка прав
def create_product(request):
    pass

Возможности:
- ✅ User model из коробки
- ✅ Login/logout
- ✅ Password hashing (bcrypt)
- ✅ Permissions и Groups
- ✅ Session-based auth
- ✅ Decorators для защиты
- ✅ Password reset
- ✅ OAuth (через django-allauth)

FastAPI Auth ❌

from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from passlib.context import CryptContext
import jwt

# 1. Хэширование паролей
pwd_context = CryptContext(schemes=["bcrypt"])

def hash_password(password: str) -> str:
    return pwd_context.hash(password)

def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)

# 2. JWT токены
def create_jwt_token(user_id: int) -> str:
    return jwt.encode({"user_id": user_id}, "SECRET", algorithm="HS256")

def verify_jwt_token(token: str) -> int:
    payload = jwt.decode(token, "SECRET", algorithms=["HS256"])
    return payload["user_id"]

# 3. Dependency для защиты endpoints
security = HTTPBearer()

async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
    try:
        user_id = verify_jwt_token(credentials.credentials)
        # Загрузить пользователя из БД
        return user_id
    except:
        raise HTTPException(status_code=401, detail="Invalid token")

# 4. Использование
@app.get("/dashboard")
async def dashboard(user_id: int = Depends(get_current_user)):
    return {"user_id": user_id, "message": "Welcome"}

Или использовать библиотеки:
- fastapi-users - готовое решение (сложнее Django Auth)
- fastapi-jwt-auth - только JWT

Вывод: Django Auth удобнее, FastAPI - больше контроля.

6. API (REST/GraphQL)

Django REST Framework 🟡

Что есть: Отдельная библиотека (нужно ставить)

pip install djangorestframework

# serializers.py
from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

# views.py
from rest_framework import viewsets

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

# urls.py
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register('products', ProductViewSet)

GET    /api/products/     - Список
POST   /api/products/     - Создать
GET    /api/products/1/   - Получить
PUT    /api/products/1/   - Обновить
DELETE /api/products/1/   - Удалить

Возможности:
- ✅ Автоматический CRUD API
- ✅ Сериализация (ORM → JSON)
- ✅ Валидация
- ✅ Permissions
- ✅ Pagination, filtering
- ✅ Browsable API (веб-интерфейс)
- ❌ НЕТ автодокументации (нужно drf-spectacular)

FastAPI ✅

Что есть: API из коробки (это основа фреймворка)

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    stock: int

@app.get("/products", response_model=list[Product])
async def list_products():
    return get_all_products()

@app.post("/products", response_model=Product)
async def create_product(product: Product):
    return save_product(product)

@app.get("/products/{id}", response_model=Product)
async def get_product(id: int):
    return find_product(id)

GET    /products      - Список
POST   /products      - Создать
GET    /products/1    - Получить

+ Автодокументация:
http://localhost:8000/docs     ← Swagger UI
http://localhost:8000/redoc    ← ReDoc

Возможности:
- ✅ Минимум кода
- ✅ Type hints (автодополнение в IDE)
- ✅ Pydantic валидация
- ✅ Автодокументация (Swagger/ReDoc)
- ✅ Async из коробки
- ❌ НЕТ автоматического CRUD (нужно писать)

Вывод: FastAPI удобнее для API, DRF мощнее (связь с ORM).

7. Async/Await (асинхронность)

Django ⚠️ Частично (с версии 4.0)

# Async views (Django 4.0+)
from django.http import JsonResponse
import asyncio

async def async_view(request):
    await asyncio.sleep(1)  # Async операция
    return JsonResponse({"status": "ok"})

# ORM пока СИНХРОННЫЙ
def async_view_with_db(request):
    # ❌ НЕ РАБОТАЕТ async с ORM
    products = await Product.objects.all()  # ERROR!

    # ✅ Нужно оборачивать
    from asgiref.sync import sync_to_async

    @sync_to_async
    def get_products():
        return list(Product.objects.all())

    products = await get_products()  # OK

Проблемы:
- ⚠️ ORM не полностью async
- ⚠️ Много библиотек не поддерживают async
- ⚠️ Сложнее для новичков

FastAPI ✅ Полностью async

import httpx

@app.get("/products")
async def get_products():
    # Async database
    async with database.transaction():
        products = await database.fetch_all("SELECT * FROM products")

    # Async HTTP запрос
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com/data")

    # Async операции параллельно
    results = await asyncio.gather(
        fetch_products(),
        fetch_orders(),
        fetch_users()
    )

    return products

Возможности:
- ✅ Полностью async
- ✅ Concurrent requests (обработка нескольких запросов одновременно)
- ✅ Быстрее для I/O операций
- ✅ WebSocket из коробки

8. WebSocket (real-time)

Django Channels 🟡

pip install channels

# consumers.py
from channels.generic.websocket import AsyncWebsocketConsumer
import json

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.accept()

    async def receive(self, text_data):
        data = json.loads(text_data)
        await self.send(text_data=json.dumps({
            'message': f"Echo: {data['message']}"
        }))

# routing.py
from django.urls import path
from . import consumers

websocket_urlpatterns = [
    path('ws/chat/', consumers.ChatConsumer.as_asgi()),
]

Требования:
- ⚠️ Redis (для channels)
- ⚠️ Daphne (ASGI сервер)
- ⚠️ Сложнее настройка

FastAPI ✅ Встроено

from fastapi import WebSocket

@app.websocket("/ws/chat")
async def websocket_chat(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Echo: {data}")

Требования:
- ✅ Ничего дополнительного
- ✅ Работает из коробки

9. Шаблоны (HTML рендеринг)

Django Templates ✅

# views.py
def product_list(request):
    products = Product.objects.all()
    return render(request, 'products.html', {'products': products})

<!-- products.html -->
{% extends "base.html" %}

{% block content %}
<h1>Products</h1>
{% for product in products %}
    <div class="product">
        <h2>{{ product.name }}</h2>
        <p>Price: ${{ product.price }}</p>
    </div>
{% endfor %}
{% endblock %}

Возможности:
- ✅ Template inheritance ({% extends %})
- ✅ Template tags ({% for %}, {% if %})
- ✅ Filters ({{ value|date:"Y-m-d" }})
- ✅ CSRF protection
- ✅ i18n (перевод)

FastAPI ❌ Нет (можно подключить Jinja2)

# Нужно подключать Jinja2
from fastapi.templating import Jinja2Templates

templates = Jinja2Templates(directory="templates")

@app.get("/products")
def product_list(request: Request):
    return templates.TemplateResponse("products.html", {
        "request": request,
        "products": get_products()
    })

Отличия:
- ❌ Нужно настраивать
- ❌ Нет встроенных тегов Django
- ❌ FastAPI не для SSR (server-side rendering)

Сводная таблица: Что нужно для веб-приложения

Архитектурные варианты

Вариант 1: ТОЛЬКО Django (для всего)

Фича	Для чего нужна	Django	FastAPI
БД (ORM)	Хранение данных	✅ Есть	❌ Нужна SQLAlchemy
Админка	Управление данными	✅ Есть	❌ Нет
Миграции	Изменения БД	✅ Есть	❌ Нужен Alembic
Формы	HTML формы	✅ Есть	❌ Нет
Auth	Логин/регистрация	✅ Есть	❌ Вручную
Шаблоны	HTML страницы	✅ Есть	❌ Jinja2 отдельно
API	REST endpoints	🟡 DRF	✅ Встроено
Async	Скорость I/O	🟡 Частично	✅ Полностью
WebSocket	Real-time	🟡 Channels	✅ Встроено

/opt/claude-workspace/platform/
└── cifra_platform/          ← Django проект
    ├── manage.py
    ├── cifra_platform/      ← Настройки
    │   ├── settings.py
    │   └── urls.py
    ├── core/                ← Django app для агентов
    │   ├── models.py        (Agent, Task, AgentLog)
    │   ├── views.py         (API + HTML)
    │   ├── agents.py        (DocumentAgent, CodeAgent)
    │   └── admin.py         (Админка для агентов)
    ├── projects/            ← Django app для проектов
    │   ├── models.py        (Project, Document)
    │   ├── views.py
    │   └── admin.py         (Админка для проектов)
    └── templates/           ← HTML шаблоны
        ├── base.html
        ├── chat.html
        └── projects.html

Плюсы:
- ✅ Всё в одном месте
- ✅ Админка для всего
- ✅ ORM для всех данных
- ✅ Единый фреймворк

Минусы:
- ❌ Медленнее FastAPI
- ❌ Async не полностью
- ❌ WebSocket сложнее (Channels)

Когда использовать:
- Полноценное веб-приложение с HTML
- Нужна админка
- Команда знает Django

Вариант 2: ТОЛЬКО FastAPI (для всего)

/opt/claude-workspace/platform/backend/
├── main.py
├── api/
│   ├── chat.py
│   ├── projects.py
│   └── agents.py
├── core/
│   ├── agents/
│   └── database/          ← SQLAlchemy
└── admin/                 ← Свой фронт для админки!
    └── (React приложение)

Плюсы:
- ✅ Быстрый
- ✅ Async из коробки
- ✅ Современный стек

Минусы:
- ❌ НЕТ готовой админки
- ❌ Больше кода для ORM
- ❌ Миграции вручную (Alembic)

Когда использовать:
- API-first подход
- Фронт на React/Vue
- Нужна скорость

Вариант 3: Django + FastAPI (микросервисы)

/opt/claude-workspace/platform/
├── backend_api/           ← FastAPI (агенты, real-time)
│   ├── main.py
│   ├── api/
│   └── agents/
│
└── backend_web/           ← Django (админка, БД)
    ├── manage.py
    ├── models.py
    └── admin.py

Плюсы:
- ✅ Лучшее от двух фреймворков
- ✅ Django админка + FastAPI скорость

Минусы:
- ❌ Сложнее (два фреймворка)
- ❌ Дублирование (2 БД или общая?)
- ❌ Больше кода

Когда использовать:
- Большая система
- Микросервисная архитектура

Вариант 4: Django для ВСЕГО (рекомендую!)

/opt/claude-workspace/
├── platform/
│   └── cifra_platform/    ← Django (платформа)
│       ├── core/          (агенты)
│       ├── projects/      (управление проектами)
│       ├── api/           (DRF для API)
│       └── admin/         (Django Admin)
│
└── projects/
    ├── marketplace/
    │   └── solution/mvp/  ← Django (отдельное приложение)
    │
    └── analytics/
        └── solution/mvp/  ← Streamlit (дашборд)

Django ПЛАТФОРМА (порт 8000)
├─ Django Admin (/admin)     - Управление всем
├─ Django Templates          - HTML интерфейс
├─ Django REST API (/api)    - Для фронтенда (если будет React)
├─ Django ORM                - PostgreSQL/SQLite
└─ Agents (Python классы)    - DocumentAgent, CodeAgent, GitAgent

# platform/core/models.py

class Project(models.Model):
    """Проект пользователя"""
    name = models.CharField(max_length=100)
    template = models.CharField(max_length=50)
    status = models.CharField(max_length=20)
    path = models.CharField(max_length=500)
    created_at = models.DateTimeField(auto_now_add=True)

class Agent(models.Model):
    """Агент платформы"""
    name = models.CharField(max_length=50)
    version = models.CharField(max_length=20)
    status = models.CharField(max_length=20)  # idle, busy, error
    capabilities = models.JSONField()

class Task(models.Model):
    """Задача для агента"""
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    agent = models.ForeignKey(Agent, on_delete=models.CASCADE)
    description = models.TextField()
    status = models.CharField(max_length=20)  # pending, running, completed, failed
    result = models.JSONField(null=True)
    created_at = models.DateTimeField(auto_now_add=True)
    completed_at = models.DateTimeField(null=True)

class Document(models.Model):
    """Документ проекта"""
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    path = models.CharField(max_length=500)
    content = models.TextField()
    metadata = models.JSONField()
    version = models.CharField(max_length=20)
    updated_at = models.DateTimeField(auto_now=True)

class AgentLog(models.Model):
    """Лог работы агента"""
    task = models.ForeignKey(Task, on_delete=models.CASCADE)
    level = models.CharField(max_length=20)  # INFO, ERROR, DEBUG
    message = models.TextField()
    timestamp = models.DateTimeField(auto_now_add=True)

# platform/core/admin.py

@admin.register(Project)
class ProjectAdmin(admin.ModelAdmin):
    list_display = ['name', 'template', 'status', 'created_at']
    list_filter = ['status', 'template']
    search_fields = ['name']

@admin.register(Agent)
class AgentAdmin(admin.ModelAdmin):
    list_display = ['name', 'version', 'status']
    list_filter = ['status']

@admin.register(Task)
class TaskAdmin(admin.ModelAdmin):
    list_display = ['project', 'agent', 'status', 'created_at']
    list_filter = ['status', 'agent']
    readonly_fields = ['result', 'created_at', 'completed_at']

@admin.register(Document)
class DocumentAdmin(admin.ModelAdmin):
    list_display = ['project', 'path', 'version', 'updated_at']
    search_fields = ['path', 'content']

http://91.218.142.168:8000/admin

┌────────────────────────────────────────────┐
│  Платформа ЦИФРА - Администрирование       │
├────────────────────────────────────────────┤
│  CORE                                      │
│  ├─ Projects (3)                           │
│  │   ├─ marketplace (active)               │
│  │   ├─ analytics (planning)               │
│  │   └─ payment-service (active)           │
│  │                                         │
│  ├─ Agents (3)                             │
│  │   ├─ DocumentAgent (idle)               │
│  │   ├─ CodeAgent (busy - 75%)             │
│  │   └─ GitAgent (idle)                    │
│  │                                         │
│  ├─ Tasks (150)                            │
│  │   ├─ Create project analytics ✅        │
│  │   ├─ Generate code for dashboard ⏳     │
│  │   └─ Commit changes ✅                  │
│  │                                         │
│  ├─ Documents (450)                        │
│  │   ├─ marketplace/PROJECT.md             │
│  │   ├─ marketplace/design/ROADMAP.md      │
│  │   └─ analytics/ARCHITECTURE.md          │
│  │                                         │
│  └─ Agent Logs (5000+)                     │
│      ├─ [INFO] Task completed              │
│      ├─ [ERROR] Claude API timeout         │
│      └─ [DEBUG] Git commit created         │
└────────────────────────────────────────────┘

Рекомендация: Django для ПЛАТФОРМЫ

Почему Django?

Что с FastAPI?

FastAPI НЕ НУЖЕН если:
- Фронт на Django Templates (HTML)
- Или фронт на Streamlit (отдельное приложение)

FastAPI НУЖЕН если:
- Фронт на React/Vue (тогда Django REST Framework)
- Нужны WebSocket (но есть Django Channels)

Проекты НА платформе

marketplace/solution/mvp/
├── manage.py           ← Django проект
├── shop/
│   ├── models.py       (Product, Order, User)
│   ├── views.py
│   └── admin.py        ← Своя админка!
└── db.sqlite3

analytics/solution/mvp/
├── app.py              ← Streamlit приложение
└── data/

payment-service/solution/mvp/
├── main.py             ← FastAPI (если микросервис)
└── models/

Итоговая архитектура (РЕКОМЕНДУЮ)

/opt/claude-workspace/
├── platform/
│   └── cifra_platform/              ← Django проект (ПЛАТФОРМА)
│       ├── manage.py
│       ├── cifra_platform/
│       │   ├── settings.py
│       │   ├── urls.py
│       │   └── wsgi.py
│       ├── core/                    ← Django app (агенты)
│       │   ├── models.py            (Project, Agent, Task, Document, Log)
│       │   ├── admin.py             (Django Admin)
│       │   ├── views.py             (HTML интерфейс)
│       │   ├── api.py               (REST API если нужно)
│       │   └── agents/              (Python классы агентов)
│       │       ├── base.py
│       │       ├── document.py
│       │       ├── code.py
│       │       └── git.py
│       ├── templates/               ← HTML шаблоны
│       │   ├── base.html
│       │   ├── chat.html
│       │   ├── projects.html
│       │   └── dashboard.html
│       └── static/                  ← CSS, JS
│
└── projects/
    ├── marketplace/
    │   └── solution/mvp/            ← Django (отдельный проект)
    │       ├── manage.py
    │       ├── shop/
    │       │   ├── models.py
    │       │   └── admin.py
    │       └── db.sqlite3
    │
    └── analytics/
        └── solution/mvp/            ← Streamlit (дашборд)
            ├── app.py
            └── data/

91.218.142.168
├─ Port 8000: Платформа ЦИФРА (Django)
│  ├─ /admin           - Django Admin
│  ├─ /chat            - Интерфейс чата
│  ├─ /projects        - Список проектов
│  └─ /api             - REST API (опционально)
│
├─ Port 8001: marketplace (Django)
│  └─ /admin           - Админка маркетплейса
│
└─ Port 8501: analytics (Streamlit)
   └─ Дашборд аналитики

Что делать?

НЕ МЕШАТЬ! Использовать Django для платформы.

Преимущества:
1. ✅ Один фреймворк (проще)
2. ✅ Админка из коробки
3. ✅ ORM, миграции, auth готовы
4. ✅ Меньше кода
5. ✅ Быстрее разработка

Недостатки:
1. ⚠️ Медленнее FastAPI (но для платформы не критично)
2. ⚠️ Async частично (но агенты могут быть и sync)

Следующий шаг

Q1: Согласны использовать Django для платформы?

Q2: Нужен ли HTML интерфейс (Django Templates) или сразу API + React?

Q3: Проекты на платформе - каждый выбирает свой фреймворк (Django/FastAPI/Streamlit)?

Q4: Начинаем проектировать Django модели для платформы?

Версия: 1.0.0
Статус: Готово к обсуждению
Решение: Django для платформы, проекты - любой фреймворк

Django vs FastAPI: Детальное сравнение