Initial deployment of AI REST API Generator

.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+.env
+
+# Streamlit
+.streamlit/
+
+# Django
+db.sqlite3
+media/
+staticfiles/
+
+# Runs / Generated projects
+runs/
+projects/

Dockerfile

@@ -1,20 +1,20 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy project files
+COPY . /app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose Streamlit port
+EXPOSE 8501
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,15 @@
+MIT License
+
+Copyright (c) 2025 Harshad Hole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

README.md

@@ -1,20 +1,207 @@
----
-title: Ai Rest Api Generator
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Generate Django REST APIs automatically using AI.
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+
+# 🤖 AI REST API Generator
+
+**AI REST API Generator** is a developer-focused tool that automatically generates **Django REST Framework backends** using AI or manual configuration.
+It converts high-level requirements into a fully structured, runnable Django project with CRUD APIs, serializers, views, URLs, and settings.
+
+🚧 **Status:** Under active development
+📧 **Contact:** [harshadhole04@gmail.com](mailto:harshadhole04@gmail.com)
+
+---
+
+## ✨ Features
+
+* ⚡ **AI-Powered Backend Generation**
+
+  * Generate Django REST APIs from natural language prompts
+  * Automatically infers models, fields, and relationships
+
+* 🧱 **Manual Model Builder**
+
+  * Define models, fields, relationships (One-to-One, One-to-Many)
+  * Full control without AI if preferred
+
+* 🧩 **Schema-Driven Architecture**
+
+  * JSON Schema validation before code generation
+  * Auto-fixes common schema issues safely
+
+* 📦 **Complete Django Project Output**
+
+  * Models, serializers, views, URLs
+  * JWT authentication support
+  * Database configuration (SQLite / PostgreSQL)
+  * Static & media configuration
+
+* 📥 **One-Click Download**
+
+  * Generated backend is zipped and ready to run
+
+* 🧠 **Pluggable LLM Support**
+
+  * OpenAI
+  * Groq
+  * Easy to extend for other providers
+
+---
+
+## 🏗️ Architecture Overview
+
+```
+Streamlit UI
+   ↓
+Pipeline Orchestrator
+   ↓
+LLM (Model Prompt / Spec Generation)
+   ↓
+Schema Validation (JSON Schema)
+   ↓
+Django Code Generator
+   ↓
+Ready-to-run Django REST Project
+```
+
+---
+
+## 🚀 How It Works
+
+1. **Input**
+
+   * Project name & description
+   * Choose AI-generated models or manual models
+   * Select database and authentication
+   * Provide LLM provider and API key
+
+2. **Validation**
+
+   * Generated spec is validated against a strict JSON schema
+   * Automatic normalization and safe fixes applied
+
+3. **Generation**
+
+   * Django project is created in an isolated run directory
+   * Apps, models, serializers, views, URLs, settings generated
+
+4. **Output**
+
+   * Project is zipped
+   * Download instantly from the UI
+
+---
+
+## 🖥️ Running Locally
+
+### 1️⃣ Clone the Repository
+
+```bash
+git clone https://github.com/harshadSH/ai-rest-api-generator.git
+cd ai-rest-api-generator
+```
+
+### 2️⃣ Create Virtual Environment
+
+```bash
+python -m venv venv
+source venv/bin/activate   # Windows: venv\Scripts\activate
+```
+
+### 3️⃣ Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4️⃣ Run the Streamlit App
+
+```bash
+streamlit run app.py
+```
+
+---
+
+## 📂 Generated Project Structure
+
+```
+project_name/
+├── manage.py
+├── project_name/
+│   ├── settings.py
+│   ├── urls.py
+│   └── wsgi.py
+├── core/
+│   ├── models.py
+│   ├── serializers.py
+│   ├── views.py
+│   ├── urls.py
+│   └── admin.py
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## 🛡️ Authentication
+
+* Supports **JWT Authentication**
+* All CRUD endpoints can be protected
+* Easily extendable to session-based auth
+
+---
+
+## 🧪 Validation & Reliability
+
+* Strict JSON Schema enforcement
+* Deterministic naming conventions
+* Auto-correction of:
+
+  * Database engine names
+  * Model and field naming
+  * Missing required fields
+* Prevents invalid or unsafe Django code generation
+
+---
+
+## 🌍 Deployment
+
+This project is suitable for:
+
+* Local development
+* Docker-based deployment
+* Cloud hosting (AWS, Azure, GCP, Railway, Render)
+
+⚠️ Note: Production hardening (rate limiting, monitoring, secrets management) should be added as per deployment needs.
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+You are free to use, modify, and distribute it with attribution.
+
+---
+
+## 👨‍💻 Author
+
+**Harshad Hole**
+Bachelor of Engineering – Artificial Intelligence & Data Science
+📧 Email: **[harshadhole04@gmail.com](mailto:harshadhole04@gmail.com)**
+
+---
+
+## ⭐ Why This Project Matters
+
+* Solves repetitive backend boilerplate
+* Demonstrates real-world use of LLMs in software engineering
+* Combines AI + validation + deterministic code generation
+* Strong portfolio-grade project for AI / Backend / Full-Stack roles
+
+---
+
+If you want, I can also:
+
+* Write a **“Project Motivation”** section
+* Optimize README for **Hugging Face Spaces**
+* Add badges (Python, Django, MIT, AI)
+* Review it from a recruiter’s perspective
+
+Just tell me 👍

additional_function.py

@@ -0,0 +1,30 @@
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+import os
+
+def get_llm(provider: str, api_key: str):
+    if not api_key or not api_key.strip():
+        raise ValueError("API key is missing or empty")
+
+    provider = provider.lower()
+
+    if provider == "groq":
+        # ✅ Set env var as fallback (Groq SDK expects this sometimes)
+        os.environ["GROQ_API_KEY"] = api_key
+
+        return ChatGroq(
+            model="openai/gpt-oss-120b",
+            api_key=api_key,
+            temperature=0
+        )
+
+    elif provider == "openai":
+        return ChatOpenAI(
+            model="gpt-4o-mini",
+            api_key=api_key,
+            temperature=0
+        )
+
+    else:
+        raise ValueError(f"Unsupported LLM provider: {provider}")
+

app.py

@@ -0,0 +1,412 @@
+import streamlit as st
+import uuid
+import os
+import json
+import shutil
+import zipfile
+from typing import Dict, List
+
+from spec_validator import validate_and_clean_spec
+from pipeline import run_pipeline
+
+
+
+# =====================================================
+# CONFIG
+# =====================================================
+BASE_RUN_DIR = "runs"
+SCHEMA_PATH = "spec_schema.json"
+
+st.set_page_config(
+    page_title="AI REST API Generator",
+    layout="wide",
+)
+
+# =====================================================
+# HELPERS
+# =====================================================
+
+def create_run_dir():
+    run_id = uuid.uuid4().hex[:8]
+    run_dir = os.path.join(BASE_RUN_DIR, f"run_{run_id}")
+    os.makedirs(run_dir, exist_ok=True)
+    return run_id, run_dir
+
+
+def zip_folder(folder_path: str) -> str:
+    zip_path = f"{folder_path}.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for root, _, files in os.walk(folder_path):
+            for file in files:
+                full_path = os.path.join(root, file)
+                arcname = os.path.relpath(full_path, folder_path)
+                zipf.write(full_path, arcname)
+    return zip_path
+
+
+def load_schema():
+    with open(SCHEMA_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+# =====================================================
+# SESSION STATE INIT
+# =====================================================
+
+if "spec" not in st.session_state:
+    st.session_state.spec = {
+        "project_name": "",
+        "description": "",
+        "database": {},
+        "auth": {"type": "jwt"},
+        "api_config": {"base_url": "/api/"},
+        "apps": {"core": {"models": {}, "apis": {}}},
+        "use_ai_models": True,
+        "llm": {}
+    }
+
+if "models_ui" not in st.session_state:
+    st.session_state.models_ui = []
+
+if "logs" not in st.session_state:
+    st.session_state.logs = []
+
+log_box = st.empty()
+
+def log(msg: str):
+    st.session_state.logs.append(msg)
+    log_box.write("\n".join(st.session_state.logs))
+
+
+# =====================================================
+# UI HEADER
+# =====================================================
+
+st.title("🤖 AI REST API Generator")
+st.markdown(
+    """
+    **Build Django REST APIs using AI or manual configuration.**  
+    🚧 *This website is under active development.*
+    """
+)
+
+st.divider()
+
+# =====================================================
+# SECTION 1 — LLM CONFIGURATION
+# =====================================================
+st.header("🔑 LLM Configuration")
+
+llm_provider = st.selectbox(
+    "Select LLM Provider",
+    ["Groq", "OpenAI"]
+)
+
+api_key = st.text_input(
+    f"{llm_provider} API Key",
+    type="password",
+    help="Your API key is used only for this session and never stored."
+)
+
+st.session_state.spec["llm"] = {
+    "provider": llm_provider.lower()
+}
+
+
+
+
+# =====================================================
+# SECTION 2 — PROJECT BASICS
+# =====================================================
+st.header("📦 Project Information")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.session_state.spec["project_name"] = st.text_input(
+        "Project Name",
+        placeholder="my_backend_project"
+    )
+
+with col2:
+    st.session_state.spec["description"] = st.text_area(
+        "Project Description",
+        placeholder="Short description of your backend"
+    )
+
+# =====================================================
+# SECTION 3 — DATABASE CONFIGURATION
+# =====================================================
+st.header("🗄 Database Configuration")
+
+db_engine = st.selectbox(
+    "Database Engine",
+    ["sqlite", "postgresql", "mysql"]
+)
+
+if db_engine == "sqlite":
+    st.session_state.spec["database"] = {
+        "engine": "sqlite",
+        "name": "db.sqlite3"
+    }
+else:
+    col1, col2 = st.columns(2)
+    with col1:
+        db_name = st.text_input("Database Name")
+        db_user = st.text_input("Database User")
+        db_password = st.text_input("Database Password", type="password")
+    with col2:
+        db_host = st.text_input("Database Host", value="localhost")
+        db_port = st.number_input("Database Port", value=5432)
+
+    st.session_state.spec["database"] = {
+        "engine": db_engine,
+        "name": db_name,
+        "user": db_user,
+        "password": db_password,
+        "host": db_host,
+        "port": db_port
+    }
+
+# =====================================================
+# SECTION 4 — MODEL MODE
+# =====================================================
+st.header("🧱 Model Generation")
+
+use_ai = st.radio(
+    "How do you want to create models?",
+    ["AI Generated Models", "Manual Model Builder"]
+)
+
+st.session_state.spec["use_ai_models"] = (use_ai == "AI Generated Models")
+
+# =====================================================
+# SECTION 5 — MANUAL MODEL BUILDER
+# =====================================================
+if not st.session_state.spec["use_ai_models"]:
+    st.subheader("🛠 Manual Model Builder")
+
+    if st.button("➕ Add Model"):
+        st.session_state.models_ui.append({
+            "name": "",
+            "fields": []
+        })
+
+    model_names = []
+
+    for mi, model in enumerate(st.session_state.models_ui):
+        with st.expander(f"Model {mi + 1}", expanded=True):
+            model["name"] = st.text_input(
+                "Model Name",
+                model["name"],
+                key=f"model_{mi}"
+            )
+
+            if model["name"]:
+                model_names.append(model["name"])
+
+            if st.button("➕ Add Column", key=f"add_col_{mi}"):
+                model["fields"].append({
+                    "name": "",
+                    "type": "CharField",
+                    "primary_key": False,
+                    "unique": False,
+                    "null": False,
+                    "relation": None,
+                    "on_delete": "CASCADE"
+                })
+
+            for fi, field in enumerate(model["fields"]):
+                cols = st.columns(7)
+
+                field["name"] = cols[0].text_input(
+                    "Column",
+                    field["name"],
+                    key=f"fname_{mi}_{fi}"
+                )
+
+                field["type"] = cols[1].selectbox(
+                    "Type",
+                    [
+                        "CharField",
+                        "IntegerField",
+                        "UUIDField",
+                        "BooleanField",
+                        "DateField",
+                        "OneToOne",
+                        "OneToMany"
+                    ],
+                    key=f"ftype_{mi}_{fi}"
+                )
+
+                field["primary_key"] = cols[2].checkbox(
+                    "PK",
+                    key=f"fpk_{mi}_{fi}"
+                )
+                field["unique"] = cols[3].checkbox(
+                    "Unique",
+                    key=f"funq_{mi}_{fi}"
+                )
+                field["null"] = cols[4].checkbox(
+                    "Null",
+                    key=f"fnull_{mi}_{fi}"
+                )
+
+                if field["type"] in ["OneToOne", "OneToMany"]:
+                    field["relation"] = cols[5].selectbox(
+                        "Reference Model",
+                        model_names,
+                        key=f"frel_{mi}_{fi}"
+                    )
+                    field["on_delete"] = cols[6].selectbox(
+                        "On Delete",
+                        ["CASCADE", "SET_NULL", "PROTECT"],
+                        key=f"fdel_{mi}_{fi}"
+                    )
+
+    # Convert UI → spec
+    models_spec = {}
+    apis_spec = {}
+
+    for model in st.session_state.models_ui:
+        if not model["name"]:
+            continue
+
+        fields_spec = {}
+
+        for f in model["fields"]:
+            if not f["name"]:
+                continue
+
+            if f["type"] == "OneToOne":
+                fields_spec[f["name"]] = {
+                    "type": "OneToOneField",
+                    "to": f["relation"],
+                    "on_delete": f["on_delete"],
+                    "null": f["null"],
+                    "unique": True
+                }
+            elif f["type"] == "OneToMany":
+                fields_spec[f["name"]] = {
+                    "type": "ForeignKey",
+                    "to": f["relation"],
+                    "on_delete": f["on_delete"],
+                    "null": f["null"]
+                }
+            else:
+                fields_spec[f["name"]] = {
+                    "type": f["type"],
+                    "primary_key": f["primary_key"],
+                    "unique": f["unique"],
+                    "null": f["null"]
+                }
+
+        models_spec[model["name"]] = {"fields": fields_spec}
+        apis_spec[model["name"]] = ["list", "create", "retrieve", "update", "delete"]
+
+    st.session_state.spec["apps"]["core"]["models"] = models_spec
+    st.session_state.spec["apps"]["core"]["apis"] = apis_spec
+
+# =====================================================
+# SECTION 6 — GENERATION
+# =====================================================
+st.header("🚀 Generate Project")
+
+
+
+# UI elements (define once, above button)
+progress_bar = st.progress(0)
+
+
+def ui_log(msg):
+    st.session_state.logs.append(msg)
+    log_box.write("\n".join(st.session_state.logs))
+
+def ui_progress(value):
+    progress_bar.progress(value)
+
+
+if st.button("Generate Backend"):
+    # ----------------------------
+    # 1️⃣ Basic validation
+    # ----------------------------
+    if not api_key:
+        st.error("API key is required to generate the project.")
+        st.stop()
+
+    st.session_state.logs.clear()
+    progress_bar.progress(0)
+
+    # ----------------------------
+    # 2️⃣ Load schema & validate UI spec
+    # ----------------------------
+    schema = load_schema()
+
+    valid, cleaned_spec, errors, warnings = validate_and_clean_spec(
+        st.session_state.spec,
+        schema
+    )
+
+    if not valid:
+        st.error("Specification validation failed.")
+        st.json(errors)
+        st.stop()
+
+    # ----------------------------
+    # 3️⃣ Create isolated run directory
+    # ----------------------------
+    run_id, run_dir = create_run_dir()
+    ui_log(f"🆔 Run ID: {run_id}")
+    ui_log("🚀 Starting generation pipeline...")
+
+    # ----------------------------
+    # 4️⃣ Run backend pipeline
+    # ----------------------------
+    try:
+        run_pipeline(
+            spec=cleaned_spec,
+            run_dir=run_dir,
+            llm_provider=llm_provider.lower(),
+            api_key=api_key,
+            log_callback=ui_log,
+            progress_callback=ui_progress
+        )
+
+        ui_log("📦 Zipping project...")
+        zip_path = zip_folder(run_dir)
+
+        ui_log("✅ Project ready for download")
+
+        with open(zip_path, "rb") as f:
+            st.download_button(
+                "⬇ Download Generated Project",
+                f,
+                file_name=f"{cleaned_spec['project_name']}.zip"
+            )
+
+    # ----------------------------
+    # 5️⃣ Error handling
+    # ----------------------------
+    except Exception as e:
+        ui_log("❌ Pipeline failed")
+        ui_log(str(e))
+        st.error(f"Generation failed at step: {e}")
+
+
+    # ----------------------------
+    # 6️⃣ Cleanup (safe)
+    # ----------------------------
+    finally:
+        shutil.rmtree(run_dir, ignore_errors=True)
+
+
+# =====================================================
+# FOOTER
+# =====================================================
+st.divider()
+st.markdown(
+    """
+    📧 **Contact:** harshadhole04@gmail.com  
+    © AI REST API Generator — Under Development
+    """
+)

generator.py

@@ -0,0 +1,420 @@
+import os
+import json
+import subprocess
+import ast
+
+# Import strict prompts
+from prompt import *
+
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+
+
+def add_app_to_installed_apps(settings_path: str, app_name: str):
+    with open(settings_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    in_installed_apps = False
+    already_added = False
+    new_lines = []
+
+    for line in lines:
+        if line.strip().startswith("INSTALLED_APPS"):
+            in_installed_apps = True
+
+        if in_installed_apps and f'"{app_name}"' in line:
+            already_added = True
+
+        if in_installed_apps and line.strip() == "]":
+            if not already_added:
+                new_lines.append(f'    "{app_name}",\n')
+            in_installed_apps = False
+
+        new_lines.append(line)
+
+    if not already_added:
+        with open(settings_path, "w", encoding="utf-8") as f:
+            f.writelines(new_lines)
+
+
+# ============================================================
+# HELPER FUNCTIONS
+# ============================================================
+
+def run_cmd(command, cwd=None):
+    """Runs terminal commands safely."""
+    result = subprocess.run(
+    command.split(),
+    cwd=cwd,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    text=True
+)
+
+    
+    if result.returncode != 0:
+        print("❌ Command failed:", command)
+        print(result.stderr)
+        raise Exception(result.stderr)
+    return result.stdout
+
+
+def write_file(path, content):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf8") as f:
+        f.write(content)
+
+
+def is_valid_python(code: str) -> bool:
+    try:
+        ast.parse(code)
+        return True
+    except:
+        return False
+
+# ===================README FILE GENERATOR ===================
+
+def generate_readme_with_llm(spec_json, project_path, llm):
+    chain = ChatPromptTemplate.from_messages([
+        ("system", README_PROMPT),
+        ("user", "{json_input}")
+    ])
+
+    runnable = chain | llm
+    result = runnable.invoke({
+        "json_input": json.dumps(spec_json, indent=2)
+    })
+
+    readme_content = result.content.strip()
+
+    write_file(os.path.join(project_path, "README.md"), readme_content)
+    print("📘 README.md generated successfully.")
+
+
+# ============================================================
+# CUSTOM FILE VALIDATORS
+# ============================================================
+
+def is_valid_serializer(code):
+    """Rejects dynamic serializer patterns."""
+    forbidden = ["globals(", "type(", "for ", "_create", "json_input"]
+    if any(f in code for f in forbidden):
+        return False
+    if "class " not in code:
+        return False
+    if "Serializer" not in code:
+        return False
+    return is_valid_python(code)
+
+
+def is_valid_views(code):
+    """Reject dynamic views or helper functions."""
+    forbidden = ["globals(", "type(", "_create", "for ", "json_input"]
+    if any(f in code for f in forbidden):
+        return False
+    if "APIView" not in code:
+        return False
+    return is_valid_python(code)
+
+
+def is_valid_urls(code):
+    forbidden = ["globals(", "type(", "_create", "json_input"]
+    if any(f in code for f in forbidden):
+        return False
+    
+    if "urlpatterns" not in code:
+        return False
+    if "path(" not in code:
+        return False
+    if "<int:pk>" not in code:
+        return False
+
+    # No leading slash allowed
+    if 'path("/' in code or "path('/" in code:
+        return False
+
+    return is_valid_python(code)
+
+
+# ============================================================
+# GENERATION LOGIC (AUTO-FIX)
+# ============================================================
+
+def generate_code_with_fix(
+    prompt,
+    json_slice,
+    *,
+    llm,
+    validator=None,
+    retries=5,
+):
+
+    for attempt in range(retries):
+        print(f"🧠 Generating (attempt {attempt+1})...")
+
+        chain = ChatPromptTemplate.from_messages([
+            ("system", prompt),
+            ("user", "{json_input}")
+        ])
+
+        runnable = chain | llm
+        result = runnable.invoke({
+            "json_input": json.dumps(json_slice, indent=2)
+        })
+
+        code = result.content.strip()
+
+
+        # Use custom validator if provided
+        if validator:
+            if validator(code):
+                print("✅ File valid.")
+                return code
+        else:
+            # Syntax-only validation
+            if is_valid_python(code):
+                print("✅ File valid.")
+                return code
+
+        print("❌ Invalid file. Regenerating...")
+
+    raise Exception("❌ Could not generate a valid file after retries.")
+
+
+def generate_urls_with_fix(prompt, json_slice, *, llm, retries=5):
+    return generate_code_with_fix(prompt, json_slice, validator=is_valid_urls,llm=llm, retries=retries)
+
+
+# ============================================================
+# MAIN PROJECT GENERATOR
+# ============================================================
+
+import os
+import sys
+
+def generate_full_project(spec_json, output_dir, llm, project_name):
+    print("generating project")
+    
+    print("creating path")
+
+    project_path = os.path.join(output_dir, project_name)
+    os.makedirs(output_dir, exist_ok=True)
+
+    PYTHON = sys.executable  # ✅ always correct python
+
+    # -----------------------------
+    # 1) CREATE DJANGO PROJECT
+    # -----------------------------
+    try:
+        print("🚀 Creating Django project...")
+        run_cmd(f"{PYTHON} -m django startproject {project_name}", cwd=output_dir)
+    except Exception as e:
+        raise RuntimeError(f"Failed to create Django project '{project_name}'") from e
+
+    # -----------------------------
+    # 2) CREATE APPS
+    # -----------------------------
+    try:
+        for app in spec_json.get("apps", {}):
+            print(f"📦 Creating app: {app}")
+            run_cmd(f"{PYTHON} manage.py startapp {app}", cwd=project_path)
+
+            settings_path = os.path.join(
+                project_path,
+                project_name,
+                "settings.py"
+            )
+
+            add_app_to_installed_apps(settings_path, app)
+
+    except Exception as e:
+        raise RuntimeError("Failed while creating Django apps") from e
+
+    # -----------------------------
+    # 3) GENERATE FILES FOR EACH APP
+    # -----------------------------
+    for app_name, app_spec in spec_json.get("apps", {}).items():
+        try:
+            print(f"📝 Generating code for app: {app_name}")
+            app_dir = os.path.join(project_path, app_name)
+
+            if not os.path.exists(app_dir):
+                raise FileNotFoundError(f"App directory not found: {app_dir}")
+
+            models_slice = {"models": app_spec.get("models", {})}
+
+            serializer_slice = {
+                "model_names": sorted(app_spec.get("models", {}).keys())
+            }
+            admin_slice = {"model_names": list(app_spec.get("models", {}).keys())}
+
+            views_slice = {
+                "model_names": list(app_spec.get("models", {}).keys()),
+                "apis": app_spec.get("apis", {})
+            }
+
+            urls_slice = {
+                "model_names": list(app_spec.get("models", {}).keys()),
+                "apis": app_spec.get("apis", {}),
+                "base_url": spec_json.get("api_config", {}).get("base_url", "/api/")
+            }
+
+            models_code = generate_code_with_fix(
+                MODELS_PROMPT, models_slice, validator=is_valid_python, llm=llm
+            )
+            write_file(os.path.join(app_dir, "models.py"), models_code)
+
+            serializers_code = generate_code_with_fix(
+                SERIALIZERS_PROMPT, serializer_slice, validator=is_valid_serializer, llm=llm
+            )
+            write_file(os.path.join(app_dir, "serializers.py"), serializers_code)
+
+            views_code = generate_code_with_fix(
+                VIEWS_PROMPT, views_slice, validator=is_valid_views, llm=llm
+            )
+            write_file(os.path.join(app_dir, "views.py"), views_code)
+
+            urls_code = generate_urls_with_fix(
+                URLS_PROMPT, urls_slice, llm=llm
+            )
+            write_file(os.path.join(app_dir, "urls.py"), urls_code)
+
+            admin_code = generate_code_with_fix(
+                ADMIN_PROMPT, admin_slice, validator=is_valid_python, llm=llm
+            )
+            write_file(os.path.join(app_dir, "admin.py"), admin_code)
+
+        except Exception as e:
+            raise RuntimeError(f"Code generation failed for app '{app_name}'") from e
+
+    # -----------------------------
+    # 4) GENERATE REQUIREMENTS
+    # -----------------------------
+    try:
+        requirements_slice = {
+            "auth": spec_json.get("auth", {}),
+            "database": spec_json.get("database", {}),
+            "deployment": spec_json.get("deployment", {})
+        }
+
+        requirements_code = generate_code_with_fix(
+            REQUIREMENTS_PROMPT, requirements_slice, llm=llm
+        )
+        write_file(os.path.join(project_path, "requirements.txt"), requirements_code)
+
+    except Exception as e:
+        raise RuntimeError("Failed to generate requirements.txt") from e
+
+    # -----------------------------
+    # 5) PROJECT URLS
+    # -----------------------------
+    try:
+        project_urls_slice = {
+            "project_name": project_name,
+            "apps": list(spec_json.get("apps", {}).keys()),
+            "base_url": spec_json.get("api_config", {}).get("base_url", "/api/")
+        }
+
+        project_urls_code = generate_code_with_fix(
+            PROJECT_URLS_PROMPT,
+            project_urls_slice,
+            validator=is_valid_python, llm=llm
+        )
+
+        write_file(
+            os.path.join(project_path, project_name, "urls.py"),
+            project_urls_code
+        )
+
+    except Exception as e:
+        raise RuntimeError("Failed to generate project urls.py") from e
+
+    # -----------------------------
+    # 6) README (OPTIONAL)
+    # -----------------------------
+    try:
+        generate_readme_with_llm(spec_json, project_path, llm=llm)
+    except Exception as e:
+        print("⚠ README generation failed (non-blocking):", e)
+
+    print("\n🎉 DONE! Project created at:", project_path)
+    return project_path
+
+def load_json_spec(path="json_output/spec.json"):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+#=============================Prompt_With_Model_Specification================
+from langchain.prompts import ChatPromptTemplate
+
+def generate_django_model_prompt(project_name: str, description: str, llm):
+    """
+    Uses LLM to generate a high-quality, structured prompt
+    for Django model development with clear specifications.
+    """
+
+    prompt = ChatPromptTemplate.from_messages([
+    ("system", """
+You are a senior Django backend architect with production experience.
+
+Your task is to generate a SINGLE, CLEAN, PLAIN-TEXT PROMPT
+that will later be used to generate Django models.py.
+
+STRICT RULES:
+- Output ONLY plain text.
+- Do NOT use markdown, bullet points, headings, or code blocks.
+- Do NOT include explanations or commentary.
+- Do NOT generate Django code.
+- Generate ONLY the final prompt text.
+
+MODEL DESIGN RULES:
+- Follow Django ORM best practices.
+- Use deterministic, production-ready model structures.
+- Infer missing models or fields if required to complete the system.
+- Never invent unnecessary models.
+- Every model MUST have a clear real-world purpose.
+
+FIELD RULES:
+- Infer sensible fields when the user does not specify all required fields.
+- Use correct Django field types.
+- Add timestamps (created_at, updated_at) when appropriate.
+- Use UUID primary keys where suitable.
+- Do NOT use dynamic patterns or metaprogramming.
+- Ensure field names are snake_case.
+- Ensure model names are PascalCase.
+
+RELATIONSHIP RULES:
+- Infer relationships only when logically required.
+- Use ForeignKey for one-to-many relationships.
+- Use OneToOneField only when explicitly required.
+- Avoid ManyToMany unless clearly necessary.
+
+META RULES:
+- Include Meta options such as db_table and ordering.
+- Include __str__ methods for all models.
+- Ensure compatibility with Django REST Framework serializers and views.
+
+OUTPUT QUALITY RULE:
+The generated prompt must be precise, minimal, and implementation-ready,
+so that another LLM can generate models.py without making assumptions.
+"""),
+    ("user", """
+Project Name: {project_name}
+
+User Requirements:
+{description}
+
+Generate a single, concise, implementation-ready PROMPT
+that instructs an LLM to generate Django models.py.
+""")
+])
+
+
+    chain = prompt | llm
+    result = chain.invoke({
+        "project_name": project_name,
+        "description": description
+    })
+
+    return result.content.strip()

pipeline.py

@@ -0,0 +1,161 @@
+# pipeline.py
+
+import os
+
+from additional_function import get_llm
+from generator import generate_full_project, generate_django_model_prompt
+from spec_validator import generate_valid_json_spec
+from settings_generator import update_settings_py
+
+
+def run_pipeline(
+    spec: dict,
+    run_dir: str,
+    llm_provider: str,
+    api_key: str,
+    log_callback=None,
+    progress_callback=None,
+    retries: int = 3,
+):
+    """
+    Orchestrates full backend generation pipeline.
+    """
+
+    def log(msg: str):
+        if log_callback:
+            log_callback(msg)
+
+    def progress(val: int):
+        if progress_callback:
+            progress_callback(val)
+
+    # -------------------------------------------------
+    # STEP 0 — Init
+    # -------------------------------------------------
+    progress(0)
+    log("🚀 Starting generation pipeline")
+
+    # -------------------------------------------------
+    # STEP 1 — Create LLM
+    # -------------------------------------------------
+    try:
+        progress(10)
+        log("🔑 Initializing LLM")
+
+        llm = get_llm(llm_provider, api_key)
+
+        log("✅ LLM initialized successfully")
+
+    except Exception as e:
+        raise RuntimeError("LLM initialization failed") from e
+
+    # -------------------------------------------------
+    # STEP 2 — Build user prompt
+    # -------------------------------------------------
+    try:
+        progress(25)
+        log("🧠 Preparing user prompt")
+
+        if spec.get("use_ai_models", True):
+            log("Using AI to generate models")
+
+            user_prompt = generate_django_model_prompt(
+                project_name=spec.get("project_name"),
+                description=spec.get("description"),
+                llm=llm
+            )
+
+        else:
+            log("Using manually defined models")
+
+            model_summary = []
+            for model_name, model_def in spec["apps"]["core"]["models"].items():
+                fields = ", ".join(model_def["fields"].keys())
+                model_summary.append(f"{model_name}({fields})")
+
+            user_prompt = f"""
+Project Name: {spec.get("project_name")}
+Description: {spec.get("description")}
+
+Models:
+{', '.join(model_summary)}
+"""
+
+        log("✅ User prompt prepared")
+
+    except Exception as e:
+        raise RuntimeError("User prompt generation failed") from e
+
+    # -------------------------------------------------
+    # STEP 3 — Generate JSON Spec
+    # -------------------------------------------------
+    try:
+        progress(45)
+        log("📄 Generating JSON specification")
+
+        cleaned_spec = generate_valid_json_spec(
+            user_prompt=user_prompt,
+            llm=llm,
+            retries=retries
+        )
+
+        log("✅ JSON spec generated successfully")
+
+    except Exception as e:
+        raise RuntimeError("JSON spec generation failed") from e
+
+    # -------------------------------------------------
+    # STEP 4 — Generate Django Project
+    # -------------------------------------------------
+    try:
+        progress(75)
+        project_name = spec.get("project_name")
+        log("🛠 Generating Django project")
+
+        generate_full_project(
+            spec_json=cleaned_spec,
+            output_dir=run_dir,
+            llm=llm,
+            project_name =project_name
+            
+        )
+
+        log("✅ Django project created")
+
+    except Exception as e:
+        log("❌ INTERNAL ERROR during Django project generation:")
+        log(repr(e))              # <-- THIS IS CRITICAL
+        raise RuntimeError("Django project generation failed") from e
+
+
+    # -------------------------------------------------
+    # STEP 5 — Update settings.py
+    # -------------------------------------------------
+    try:
+        progress(90)
+        log("⚙ Updating Django settings")
+
+        settings_path = os.path.join(
+            run_dir,
+            cleaned_spec["project_name"],
+            cleaned_spec["project_name"],
+            "settings.py"
+        )
+
+        update_settings_py(
+            settings_path=settings_path,
+            db_spec=cleaned_spec.get("database", {})
+        )
+
+        log("✅ settings.py updated")
+
+    except Exception as e:
+        raise RuntimeError("Django settings update failed") from e
+
+    # -------------------------------------------------
+    # DONE
+    # -------------------------------------------------
+    progress(100)
+    log("🎉 Generation completed successfully")
+
+    return run_dir

prompt.py

@@ -0,0 +1,456 @@
+SYSTEM_PROMPT = """You are an expert backend architect.
+
+Your task is to convert the user’s requirements into a STRICT JSON specification
+that EXACTLY matches the provided schema for a minimal Django REST API backend.
+
+ABSOLUTE RULES:
+- Output ONLY a valid JSON object.
+- Do NOT include markdown, comments, explanations, or extra text.
+- The JSON MUST match the schema EXACTLY.
+- Missing required keys are NOT allowed.
+- Extra keys NOT defined in the schema are NOT allowed.
+- Populate ALL required fields.
+
+NAMING RULES:
+- project_name MUST be lowercase with underscores only.
+- Model names MUST be PascalCase.
+- Field names MUST be snake_case.
+- Names must be deterministic and meaningful.
+
+DATABASE RULES:
+- If database is not specified, use:
+  {{
+    "engine": "sqlite",
+    "name": "db.sqlite3"
+  }}
+
+AUTH RULES:
+- If the user mentions authentication, login, JWT, token, or security → auth.type = "jwt".
+- Otherwise → auth.type = "session".
+
+MODEL RULES:
+- ALWAYS generate at least one model.
+- Each model MUST have at least one field.
+- Every model MUST appear in BOTH core.models and core.apis.
+- Use ONLY the allowed Django field types from the schema.
+- Do NOT add field options not defined in the schema.
+
+FIELD INFERENCE RULES:
+- name, title → CharField
+- email → EmailField
+- description, content → TextField
+- age, count → IntegerField
+- created_at, updated_at → DateTimeField
+- relation fields → ForeignKey
+
+RELATIONSHIP RULES:
+- Use ForeignKey ONLY if a relationship is explicitly required.
+- ForeignKey fields MUST include:
+  {{
+    "type": "ForeignKey",
+    "to": "ModelName"
+  }}
+
+API RULES:
+- Each model MUST define all CRUD actions:
+  ["list", "create", "retrieve", "update", "delete"].
+- APIs MUST be placed under core.apis.
+
+API CONFIG RULES:
+- api_config.base_url MUST always be "/api/".
+
+OUTPUT RULES:
+- Output ONLY the final JSON object.
+- The JSON must be directly parsable.
+- No trailing commas.
+- No formatting or styling.
+
+FORBIDDEN:
+- Do NOT generate overview, dependencies, code, examples, instructions, endpoints, or explanations.
+- Output ONLY fields defined in the schema.
+
+
+Follow the schema exactly and generate a clean, minimal, production-ready JSON specification.
+
+"""
+
+
+README_PROMPT = """
+You are a senior backend engineer.
+
+Generate a professional README.md for a Django REST API project.
+
+The README must include:
+1. Project overview
+2. Tech stack
+3. Setup instructions (virtualenv, install requirements)
+4. Environment variables (if any)
+5. Database setup and migrations
+6. How to run the server
+7. API usage instructions
+8. Example API endpoints (CRUD)
+9. Authentication instructions (if enabled)
+10. Folder structure overview
+
+Rules:
+- Use Markdown
+- Be concise but complete
+- Assume the project is auto-generated
+"""
+
+MODELS_PROMPT = """
+You are an expert Django developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for models.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside the output.
+- DO NOT create helper functions, loops, or dynamic code.
+- Must begin with EXACTLY:
+
+from django.db import models
+
+json_input["models"] has this structure:
+{{
+  "Doctor": {{ "fields": {{...}} }},
+  "Patient": {{ "fields": {{...}} }}
+}}
+
+For each model:
+Generate ONE Django model class.
+
+FIELD RULES:
+- CharField -> models.CharField(max_length=<value>)
+- EmailField -> models.EmailField(max_length=<value>)
+- TextField -> models.TextField()
+- IntegerField -> models.IntegerField()
+- FloatField -> models.FloatField()
+- BooleanField -> models.BooleanField()
+- DateField -> models.DateField()
+- DateTimeField -> models.DateTimeField()
+
+FOREIGN KEY RULE:
+- type = "ForeignKey"
+- Output:
+  models.ForeignKey("<to>", on_delete=models.CASCADE)
+
+ATTRIBUTE RULES:
+- required = false -> blank=True, null=True
+- unique = true -> unique=True
+- max_length MUST be included for CharField and EmailField
+
+DO NOT add:
+- __str__
+- Meta class
+- extra imports
+
+Output ONLY the classes.
+"""
+
+
+
+
+SERIALIZERS_PROMPT = """
+You are an expert Django REST Framework developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for serializers.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside the output.
+- DO NOT generate loops, conditionals, dictionaries, globals(), or dynamic class creation.
+- DO NOT import unused models.
+
+INPUT FORMAT:
+json_input = {{
+  "model_names": ["Post", "User"]
+}}
+
+REQUIRED IMPORTS:
+from rest_framework import serializers
+from .models import Post, User  # use EXACT names from model_names
+
+FOR EACH model name in model_names:
+Generate EXACTLY this structure:
+
+class ModelNameSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ModelName
+        fields = "__all__"
+
+STRICT OUTPUT RULES:
+- Output ONLY the serializer classes.
+- One serializer per model.
+- Order serializers in the same order as model_names.
+"""
+
+
+
+
+VIEWS_PROMPT = """
+You are an expert Django REST Framework developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for views.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input in output.
+- DO NOT generate loops, helper functions, globals(), or dynamic code.
+
+Required imports ONLY:
+from rest_framework import generics
+from .models import *
+from .serializers import *
+
+json_input contains:
+- model_names (["Doctor","Patient"])
+- apis such as:
+  "Doctor": ["list","create","retrieve","update","delete"]
+
+For each model:
+
+IF it has "list" or "create" in apis:
+Generate:
+
+class ModelNameListCreateAPIView(generics.ListCreateAPIView):
+    queryset = ModelName.objects.all()
+    serializer_class = ModelNameSerializer
+
+IF it has ANY of ["retrieve","update","delete"]:
+Generate:
+
+class ModelNameRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
+    queryset = ModelName.objects.all()
+    serializer_class = ModelNameSerializer
+
+Output ONLY class definitions.
+"""
+
+
+
+
+URLS_PROMPT = """
+You are an expert Django developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for urls.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside output.
+- DO NOT use leading slashes.
+- DO NOT generate dynamic code.
+
+Required imports:
+from django.urls import path
+from . import views
+
+Model names are provided in json_input["model_names"].
+Plural name = model.lower() + "s"
+
+For EACH model:
+Generate EXACTLY these two routes:
+
+path("<plural>/", views.ModelNameListCreateAPIView.as_view()),
+path("<plural>/<int:pk>/", views.ModelNameRetrieveUpdateDestroyAPIView.as_view()),
+
+Wrap everything inside:
+
+urlpatterns = [
+    ...
+]
+
+Output ONLY urlpatterns code.
+"""
+
+
+
+
+SETTINGS_PROMPT = """
+You are an expert Django architect.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for settings.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside output.
+- DO NOT add unused settings.
+
+json_input contains:
+- project_name
+- database
+- auth
+- api_config
+- deployment
+- apps
+
+MUST include:
+- BASE_DIR
+- SECRET_KEY
+- DEBUG = True
+- ALLOWED_HOSTS = ["*"]
+
+INSTALLED_APPS MUST include:
+- django.contrib.admin
+- django.contrib.auth
+- django.contrib.contenttypes
+- django.contrib.sessions
+- django.contrib.messages
+- django.contrib.staticfiles
+- rest_framework
+- every app from json_input["apps"]
+
+MIDDLEWARE must be exactly the standard Django middleware list.
+
+DATABASE RULES:
+If database.engine == "sqlite":
+    ENGINE = "django.db.backends.sqlite3"
+    NAME = BASE_DIR / "db.sqlite3"
+
+If database.engine == "postgresql":
+    ENGINE = "django.db.backends.postgresql"
+    NAME, USER, PASSWORD, HOST, PORT from json_input["database"].
+
+TEMPLATES BLOCK MUST BE EXACTLY:
+
+TEMPLATES = [
+    {{
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [BASE_DIR / "templates"],
+        "APP_DIRS": True,
+        "OPTIONS": {{
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        }},
+    }},
+]
+
+REST FRAMEWORK RULES:
+DEFAULT_PAGINATION_CLASS must be json_input["api_config"]["pagination"]
+PAGE_SIZE must be json_input["api_config"]["page_size"]
+
+AUTH RULES:
+If auth.type == "jwt":
+    REST_FRAMEWORK must include:
+    {{
+        "DEFAULT_AUTHENTICATION_CLASSES": [
+            "rest_framework_simplejwt.authentication.JWTAuthentication"
+        ]
+    }}
+    And include SIMPLE_JWT minimal config using timedelta.
+
+STATIC/MEDIA RULES:
+STATIC_URL = "static/"
+STATICFILES_DIRS = [BASE_DIR / "static"]
+MEDIA_URL = "media/"
+MEDIA_ROOT = BASE_DIR / "media"
+
+ROOT_URLCONF = "<project_name>.urls"
+WSGI_APPLICATION = "<project_name>.wsgi.application"
+
+Your output MUST be a complete, valid Python settings.py file with:
+- imports
+- BASE_DIR
+- SECRET_KEY
+- INSTALLED_APPS
+- MIDDLEWARE
+- TEMPLATES
+- DATABASES
+- REST_FRAMEWORK
+- SIMPLE_JWT (if applicable)
+- STATIC & MEDIA settings
+- ROOT_URLCONF
+- WSGI_APPLICATION
+
+No missing sections, no placeholders, no dynamic code.
+"""
+ADMIN_PROMPT = """
+You are an expert Django developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for admin.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside output.
+- DO NOT generate loops, dynamic code, globals(), or any function.
+
+json_input["model_names"] is a list of model class names inside this app.
+
+Required imports:
+from django.contrib import admin
+from .models import Model1, Model2, ...
+
+For EACH model:
+Generate EXACTLY:
+
+@admin.register(ModelName)
+class ModelNameAdmin(admin.ModelAdmin):
+    list_display = ["id"]  # keep simple
+    search_fields = ["id"]
+
+Nothing else.
+"""
+PROJECT_URLS_PROMPT = """
+You are an expert Django developer.
+
+CRITICAL RULES:
+- Output ONLY valid Python code for project-level urls.py.
+- NO markdown, NO comments, NO explanation.
+- DO NOT reference json_input inside output.
+- DO NOT generate dynamic code.
+
+json_input contains:
+- project_name
+- apps (list of app names)
+- base_url (example: "/api/")
+
+Required imports:
+from django.contrib import admin
+from django.urls import path, include
+
+MUST generate:
+
+urlpatterns = [
+    path("admin/", admin.site.urls),
+]
+
+For EACH app in json_input["apps"]:
+Append EXACTLY this route:
+
+path("<base_url><app_name>/", include("<app_name>.urls")),
+
+Rules:
+- Remove leading slash from <base_url> if present.
+- Ensure ONLY ONE trailing slash ("/") between base_url and app_name.
+
+Output MUST be a complete valid Python urls.py file.
+"""
+
+
+
+
+REQUIREMENTS_PROMPT = """
+You generate ONLY a requirements.txt file.
+
+CRITICAL RULES:
+- Output ONLY raw package names.
+- NO markdown, NO comments.
+- DO NOT reference json_input inside output.
+
+ALWAYS include:
+Django>=5.0
+djangorestframework
+
+IF auth.type == "jwt":
+    include:
+    djangorestframework-simplejwt
+
+IF database.engine == "postgresql":
+    include:
+    psycopg2-binary
+
+IF deployment.gunicorn == true:
+    include:
+    gunicorn
+
+One package per line.
+"""
+

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+streamlit
+django
+djangorestframework
+langchain
+langchain-openai
+langchain-groq
+jsonschema
+python-dotenv
+pydantic

settings_generator.py

@@ -0,0 +1,117 @@
+import re
+from pathlib import Path
+
+
+def ensure_dir(path: Path):
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def _add_to_installed_apps(content: str, app_name: str) -> str:
+    """
+    Safely add an app to INSTALLED_APPS if not already present.
+    """
+    pattern = re.compile(r"INSTALLED_APPS\s*=\s*\[(.*?)\]", re.DOTALL)
+    match = pattern.search(content)
+
+    if not match:
+        return content
+
+    apps_block = match.group(1)
+
+    if f"'{app_name}'" in apps_block or f'"{app_name}"' in apps_block:
+        return content
+
+    updated_apps = apps_block.rstrip() + f"\n    '{app_name}',"
+    return content[:match.start(1)] + updated_apps + content[match.end(1):]
+
+
+def update_settings_py(settings_path, db_spec, app_names=None):
+    settings_path = Path(settings_path)
+    content = settings_path.read_text(encoding="utf-8")
+
+    # --------------------------------------------------
+    # 1. Ensure BASE_DIR
+    # --------------------------------------------------
+    if "BASE_DIR" not in content:
+        content = (
+            "from pathlib import Path\n\n"
+            "BASE_DIR = Path(__file__).resolve().parent.parent\n\n"
+            + content
+        )
+
+    # --------------------------------------------------
+    # 2. Ensure rest_framework + project apps
+    # --------------------------------------------------
+    content = _add_to_installed_apps(content, "rest_framework")
+
+    if app_names:
+        for app in app_names:
+            content = _add_to_installed_apps(content, app)
+
+    # --------------------------------------------------
+    # 3. Database config (ONLY if NOT sqlite)
+    # --------------------------------------------------
+    engine = (db_spec or {}).get("engine", "").lower()
+
+    if engine and engine != "sqlite":
+        engine_map = {
+            "postgresql": "django.db.backends.postgresql",
+            "postgres": "django.db.backends.postgresql",
+            "mysql": "django.db.backends.mysql",
+            "mariadb": "django.db.backends.mysql",
+        }
+
+        django_engine = engine_map.get(engine)
+        if not django_engine:
+            raise ValueError(f"Unsupported DB engine: {engine}")
+
+        database_block = f"""
+DATABASES = {{
+    'default': {{
+        'ENGINE': '{django_engine}',
+        'NAME': '{db_spec.get("name")}',
+        'USER': '{db_spec.get("user", "")}',
+        'PASSWORD': '{db_spec.get("password", "")}',
+        'HOST': '{db_spec.get("host", "")}',
+        'PORT': '{db_spec.get("port", "")}',
+    }}
+}}
+""".strip()
+
+        content = re.sub(
+            r"DATABASES\s*=\s*\{.*?\}\s*\}\s*",
+            database_block + "\n\n",
+            content,
+            flags=re.DOTALL
+        )
+
+    # --------------------------------------------------
+    # 4. Static & Media (idempotent)
+    # --------------------------------------------------
+    if "STATIC_ROOT" not in content:
+        content += """
+
+# Static files
+STATIC_URL = "/static/"
+STATIC_ROOT = BASE_DIR / "staticfiles"
+STATICFILES_DIRS = [BASE_DIR / "static"]
+
+# Media files
+MEDIA_URL = "/media/"
+MEDIA_ROOT = BASE_DIR / "media"
+"""
+
+    # --------------------------------------------------
+    # 5. Write file
+    # --------------------------------------------------
+    settings_path.write_text(content, encoding="utf-8")
+
+    # --------------------------------------------------
+    # 6. Create folders
+    # --------------------------------------------------
+    project_root = settings_path.parent.parent
+    ensure_dir(project_root / "static")
+    ensure_dir(project_root / "media")
+    ensure_dir(project_root / "staticfiles")
+
+    print("✅ settings.py updated correctly")

spec_schema.json

@@ -0,0 +1,118 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Minimal Django Backend Generator Spec",
+  "type": "object",
+
+  "required": [
+    "project_name",
+    "database",
+    "auth",
+    "apps",
+    "api_config"
+  ],
+
+  "properties": {
+    "project_name": {
+      "type": "string"
+    },
+
+    "database": {
+      "type": "object",
+      "required": ["engine", "name"],
+      "properties": {
+        "engine": {
+          "type": "string",
+          "enum": ["sqlite", "postgresql"]
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+
+    "auth": {
+      "type": "object",
+      "required": ["type"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["jwt", "session"]
+        }
+      }
+    },
+
+    "apps": {
+      "type": "object",
+      "required": ["core"],
+      "properties": {
+        "core": {
+          "type": "object",
+          "required": ["models", "apis"],
+          "properties": {
+            "models": {
+              "type": "object",
+              "patternProperties": {
+                "^[A-Z][a-zA-Z0-9]*$": {
+                  "type": "object",
+                  "required": ["fields"],
+                  "properties": {
+                    "fields": {
+                      "type": "object",
+                      "patternProperties": {
+                        "^[a-z_][a-z0-9_]*$": {
+                          "type": "object",
+                          "required": ["type"],
+                          "properties": {
+                            "type": {
+                              "type": "string",
+                              "enum": [
+                                "CharField",
+                                "TextField",
+                                "EmailField",
+                                "IntegerField",
+                                "BooleanField",
+                                "DateField",
+                                "DateTimeField",
+                                "ForeignKey"
+                              ]
+                            },
+                            "to": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+
+            "apis": {
+              "type": "object",
+              "patternProperties": {
+                "^[A-Z][a-zA-Z0-9]*$": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": ["list", "create", "retrieve", "update", "delete"]
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+
+    "api_config": {
+      "type": "object",
+      "required": ["base_url"],
+      "properties": {
+        "base_url": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

spec_validator.py

@@ -0,0 +1,314 @@
+"""
+spec_validator_v2.py
+
+Strict JSON schema validator + generator for Django backend specs.
+"""
+
+import json
+import re
+from copy import deepcopy
+from typing import Dict, Any, List, Tuple
+
+from jsonschema import Draft202012Validator, ValidationError
+from langchain.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+
+
+# =====================================================
+# FILE LOADERS
+# =====================================================
+
+def load_schema(path: str) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def load_json(path: str) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+# =====================================================
+# VALIDATION HELPERS
+# =====================================================
+
+def _format_error(err: ValidationError) -> Dict[str, str]:
+    path = "/" + "/".join(map(str, err.absolute_path)) if err.absolute_path else "/"
+    return {"path": path, "message": err.message}
+
+
+def validate_schema(
+    spec: Dict[str, Any],
+    schema: Dict[str, Any]
+) -> List[Dict[str, str]]:
+    validator = Draft202012Validator(schema)
+    errors = sorted(validator.iter_errors(spec), key=lambda e: e.path)
+    return [_format_error(e) for e in errors]
+
+
+# =====================================================
+# SAFE NORMALIZATIONS (SCHEMA-COMPATIBLE ONLY)
+# =====================================================
+
+def _to_pascal_case(name: str) -> str:
+    return "".join(part.capitalize() for part in re.split(r"[_\\s-]+", name) if part)
+
+
+def normalize_spec(spec: Dict[str, Any]) -> List[str]:
+    """
+    Normalize names without introducing new keys.
+    """
+    warnings = []
+
+    # Normalize project name
+    if "project_name" in spec:
+        normalized = re.sub(r"[^a-z0-9_]", "_", spec["project_name"].lower())
+        if normalized != spec["project_name"]:
+            warnings.append("Normalized project_name")
+            spec["project_name"] = normalized
+
+    # Normalize model names
+    models = spec.get("apps", {}).get("core", {}).get("models", {})
+    new_models = {}
+
+    for model_name, model_def in models.items():
+        new_name = _to_pascal_case(model_name)
+        if new_name != model_name:
+            warnings.append(f"Renamed model '{model_name}' → '{new_name}'")
+        new_models[new_name] = model_def
+
+    if new_models:
+        spec["apps"]["core"]["models"] = new_models
+
+    return warnings
+
+
+# =====================================================
+# MAIN VALIDATION FUNCTION
+# =====================================================
+
+def validate_and_clean_spec(
+    spec: Dict[str, Any],
+    schema: Dict[str, Any],
+    auto_fix: bool = True
+) -> Tuple[bool, Dict[str, Any], List[Dict[str, str]], List[str]]:
+
+    cleaned = deepcopy(spec)
+    warnings: List[str] = []
+
+    if auto_fix:
+        warnings.extend(normalize_spec(cleaned))
+
+    errors = validate_schema(cleaned, schema)
+
+    if errors:
+        return False, cleaned, errors, warnings
+
+    return True, cleaned, [], warnings
+
+
+# =====================================================
+# JSON SPEC GENERATION (LLM)
+# =====================================================
+
+def generate_valid_json_spec(
+    *,
+    user_prompt: str,
+    llm,
+    retries: int = 3,
+) -> Dict[str, Any]:
+    """
+    Generates schema-valid JSON using LLM + strict validation.
+    """
+
+    system_prompt = """
+You are a JSON compiler.
+
+Return ONLY a JSON object that EXACTLY matches this schema.
+Do NOT add, remove, or rename keys.
+Do NOT include explanations or formatting.
+
+Schema:
+{{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Minimal Django Backend Generator Spec",
+  "type": "object",
+
+  "required": [
+    "project_name",
+    "database",
+    "auth",
+    "apps",
+    "api_config"
+  ],
+
+  "properties": {{
+    "project_name": {{
+      "type": "string"
+    }},
+
+    "database": {{
+      "type": "object",
+      "required": ["engine", "name"],
+      "properties": {{
+        "engine": {{
+          "type": "string",
+          "enum": ["sqlite", "postgresql"]
+        }},
+        "name": {{
+          "type": "string"
+        }}
+      }}
+    }},
+
+    "auth": {{
+      "type": "object",
+      "required": ["type"],
+      "properties": {{
+        "type": {{
+          "type": "string",
+          "enum": ["jwt", "session"]
+        }}
+      }}
+    }},
+
+    "apps": {{
+      "type": "object",
+      "required": ["core"],
+      "properties": {{
+        "core": {{
+          "type": "object",
+          "required": ["models", "apis"],
+          "properties": {{
+            "models": {{
+              "type": "object",
+              "patternProperties": {{
+                "^[A-Z][a-zA-Z0-9]*$": {{
+                  "type": "object",
+                  "required": ["fields"],
+                  "properties": {{
+                    "fields": {{
+                      "type": "object",
+                      "patternProperties": {{
+                        "^[a-z_][a-z0-9_]*$": {{
+                          "type": "object",
+                          "required": ["type"],
+                          "properties": {{
+                            "type": {{
+                              "type": "string",
+                              "enum": [
+                                "CharField",
+                                "TextField",
+                                "EmailField",
+                                "IntegerField",
+                                "BooleanField",
+                                "DateField",
+                                "DateTimeField",
+                                "ForeignKey"
+                              ]
+                            }},
+                            "to": {{
+                              "type": "string"
+                            }}
+                          }}
+                        }}
+                      }}
+                    }}
+                  }}
+                }}
+              }}
+            }},
+
+            "apis": {{
+              "type": "object",
+              "patternProperties": {{
+                "^[A-Z][a-zA-Z0-9]*$": {{
+                  "type": "array",
+                  "items": {{
+                    "type": "string",
+                    "enum": ["list", "create", "retrieve", "update", "delete"]
+                  }}
+                }}
+              }}
+            }}
+          }}
+        }}
+      }}
+    }},
+
+    "api_config": {{
+      "type": "object",
+      "required": ["base_url"],
+      "properties": {{
+        "base_url": {{
+          "type": "string"
+        }}
+      }}
+    }}
+  }}
+}}
+
+"""
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("user", "{user_prompt}")
+    ])
+
+# usage
+    schema = load_schema('spec_schema.json')
+
+
+    chain = prompt | llm | JsonOutputParser()
+
+    for attempt in range(1, retries + 1):
+        try:
+            result = chain.invoke({"user_prompt": user_prompt})
+
+            valid, cleaned, errors, _ = validate_and_clean_spec(
+                result,
+                schema,
+                auto_fix=False
+            )
+
+            if valid:
+                return cleaned
+
+            raise ValueError(errors)
+
+        except Exception as e:
+            if attempt == retries:
+                raise RuntimeError(f"Failed after {retries} attempts: {e}")
+
+    raise RuntimeError("Unreachable")
+
+
+# =====================================================
+# CLI (OPTIONAL)
+# =====================================================
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Validate Django backend JSON spec")
+    parser.add_argument("spec", help="Path to spec.json")
+    parser.add_argument("schema", help="Path to schema.json")
+    args = parser.parse_args()
+
+    schema = load_schema(args.schema)
+    spec = load_json(args.spec)
+
+    valid, cleaned, errors, warnings = validate_and_clean_spec(spec, schema)
+
+    print("VALID:", valid)
+    if warnings:
+        print("WARNINGS:")
+        for w in warnings:
+            print("-", w)
+
+    if errors:
+        print("ERRORS:")
+        for e in errors:
+            print(f"{e['path']}: {e['message']}")
+    else:
+        print("Spec is valid.")