AI Agents from Idea to Live Product: Build a Two-App Django Website and Deploy It on Hostinger

mkdir agentsite && cd agentsite
python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate
pip install django anthropic python-dotenv pandas gunicorn
django-admin startproject config .
python manage.py startapp agent
python manage.py startapp analytics
pip freeze > requirements.txt

agentsite/
├── config/              # project settings and main urls.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── agent/               # App 1: AI assistant (your agent lives here)
│   ├── services.py
│   ├── urls.py
│   └── views.py
├── analytics/           # App 2: CSV data analytics
│   ├── urls.py
│   └── views.py
├── templates/
│   ├── base.html
│   ├── home.html
│   ├── agent/chat.html
│   └── analytics/upload.html
├── .env                 # secrets, never commit this
├── .gitignore
├── manage.py
└── requirements.txt

# config/settings.py (only the parts you change)
import os
from pathlib import Path
from dotenv import load_dotenv

BASE_DIR = Path(__file__).resolve().parent.parent
load_dotenv(BASE_DIR / ".env")

SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DEBUG = os.getenv("DJANGO_DEBUG", "False") == "True"
ALLOWED_HOSTS = os.getenv("DJANGO_ALLOWED_HOSTS", "127.0.0.1,localhost").split(",")
CSRF_TRUSTED_ORIGINS = [f"https://{h}" for h in ALLOWED_HOSTS if "." in h and not h[0].isdigit()]

INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "agent",        # App 1
    "analytics",    # App 2
]

TEMPLATES[0]["DIRS"] = [BASE_DIR / "templates"]

STATIC_URL = "static/"
STATIC_ROOT = BASE_DIR / "staticfiles"     # filled by collectstatic, served by Nginx

CLAUDE_MODEL = os.getenv("CLAUDE_MODEL", "claude-opus-5-5")

# Turn these on only after HTTPS works (Section 9)
if os.getenv("DJANGO_HTTPS", "False") == "True":
    SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
    SECURE_SSL_REDIRECT = True
    SESSION_COOKIE_SECURE = True
    CSRF_COOKIE_SECURE = True
    SECURE_HSTS_SECONDS = 3600

# config/urls.py: one domain, two apps
from django.contrib import admin
from django.urls import include, path
from django.views.generic import TemplateView

urlpatterns = [
    path("", TemplateView.as_view(template_name="home.html"), name="home"),
    path("agent/", include("agent.urls")),          # yourdomain.com/agent/
    path("analytics/", include("analytics.urls")),  # yourdomain.com/analytics/
    path("admin/", admin.site.urls),
]

# agent/urls.py
from django.urls import path
from . import views

app_name = "agent"
urlpatterns = [path("", views.chat, name="chat")]


# analytics/urls.py
from django.urls import path
from . import views

app_name = "analytics"
urlpatterns = [path("", views.upload, name="upload")]

# agent/services.py: the AI part of App 1
# Replace ask_agent() with your LangGraph agent from Days 11-14 when you are ready.
import logging
import os

import anthropic
from django.conf import settings

logger = logging.getLogger(__name__)

# Reads ANTHROPIC_API_KEY from the environment.
# timeout x (max_retries + 1) = 100 s, which stays below Gunicorn's 120 s timeout,
# so a slow answer returns a friendly message instead of a 502 error.
client = anthropic.Anthropic(timeout=50.0, max_retries=1)

SYSTEM_PROMPT = (
    "You are a helpful research assistant for students. "
    "Answer clearly and briefly. If you are not sure, say so."
)

def ask_agent(question: str) -> str:
    if not os.environ.get("ANTHROPIC_API_KEY"):
        return "The AI assistant is not configured yet: ANTHROPIC_API_KEY is missing in .env."
    try:
        response = client.beta.messages.create(
            model=settings.CLAUDE_MODEL,
            max_tokens=16000,
            output_config={"effort": "low"},   # fast, cheaper answers for chat
            system=SYSTEM_PROMPT,
            messages=[{"role": "user", "content": question}],
            # If a request is declined, Anthropic retries it on a suitable fallback model
            betas=["server-side-fallback-2026-07-01"],
            fallbacks="default",
        )
    except anthropic.RateLimitError:
        return "The assistant is busy right now. Please try again in a minute."
    except anthropic.APIStatusError as e:
        logger.warning("Claude API error %s: %s", e.status_code, e.message)
        return f"The AI service returned an error ({e.status_code}). Please try again later."
    except anthropic.APIConnectionError:  # includes timeouts
        logger.warning("Claude API connection error or timeout")
        return "The AI service did not respond in time. Please try again."

    if response.stop_reason == "refusal":
        return "Sorry, I can't help with that request."
    return "".join(block.text for block in response.content if block.type == "text")

# agent/views.py
from django.shortcuts import render
from .services import ask_agent

def chat(request):
    question, answer = "", None
    if request.method == "POST":
        question = request.POST.get("question", "").strip()[:2000]
        if question:
            answer = ask_agent(question)
    return render(request, "agent/chat.html", {"question": question, "answer": answer})

# analytics/views.py
import pandas as pd
from django.shortcuts import render

MAX_MB = 5

def upload(request):
    context = {}
    csv_file = request.FILES.get("csv_file")
    if request.method == "POST" and csv_file:
        if csv_file.size > MAX_MB * 1024 * 1024:
            context["error"] = f"Please upload a CSV smaller than {MAX_MB} MB."
        else:
            try:
                df = pd.read_csv(csv_file)
                context["shape"] = df.shape
                context["preview"] = df.head(10).to_html(index=False, classes="table")
                context["summary"] = df.describe(include="all").fillna("").to_html(classes="table")
            except Exception as exc:
                context["error"] = f"Could not read this file: {exc}"
    return render(request, "analytics/upload.html", context)

<!-- templates/base.html -->
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{% block title %}AgentSite{% endblock %}</title>
</head>
<body style="font-family:system-ui;max-width:860px;margin:auto;padding:20px">
  <nav><a href="/">Home</a> · <a href="/agent/">AI Assistant</a> · <a href="/analytics/">Data Analytics</a></nav>
  <hr>
  {% block content %}{% endblock %}
</body>
</html>

<!-- templates/home.html -->
{% extends "base.html" %}
{% block content %}
  <h1>AgentSite</h1>
  <p>Two apps, one website:</p>
  <ul>
    <li><a href="/agent/">AI Assistant</a>: ask a research question</li>
    <li><a href="/analytics/">Data Analytics</a>: upload a CSV and get a summary</li>
  </ul>
{% endblock %}

<!-- templates/agent/chat.html -->
{% extends "base.html" %}
{% block content %}
  <h1>AI Assistant</h1>
  <form method="post">{% csrf_token %}
    <textarea name="question" rows="4" style="width:100%" required>{{ question }}</textarea>
    <button type="submit">Ask</button>
  </form>
  {% if answer %}<h3>Answer</h3><div style="white-space:pre-wrap">{{ answer }}</div>{% endif %}
{% endblock %}

<!-- templates/analytics/upload.html -->
{% extends "base.html" %}
{% block content %}
  <h1>Data Analytics</h1>
  <form method="post" enctype="multipart/form-data">{% csrf_token %}
    <input type="file" name="csv_file" accept=".csv" required>
    <button type="submit">Analyse</button>
  </form>
  {% if error %}<p style="color:#b00">{{ error }}</p>{% endif %}
  {% if shape %}
    <p>{{ shape.0 }} rows × {{ shape.1 }} columns</p>
    <h3>First 10 rows</h3>{{ preview|safe }}
    <h3>Summary statistics</h3>{{ summary|safe }}
  {% endif %}
{% endblock %}

# .env (on your laptop now, and later on the server)
DJANGO_SECRET_KEY=paste-a-long-random-string-here
DJANGO_DEBUG=True
DJANGO_ALLOWED_HOSTS=127.0.0.1,localhost
DJANGO_HTTPS=False
ANTHROPIC_API_KEY=your-anthropic-api-key
CLAUDE_MODEL=claude-opus-5-5

# create a secret key
python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"

python manage.py migrate
python manage.py runserver
# open http://127.0.0.1:8000, then /agent/ and /analytics/

# .gitignore
.venv/
.env
db.sqlite3
staticfiles/
__pycache__/

# push to a PRIVATE GitHub repository
git init
git add .
git commit -m "AgentSite: Django project with agent and analytics apps"
git branch -M main
git remote add origin https://github.com/<your-username>/agentsite.git
git push -u origin main

# from your laptop (use the IP shown in hPanel → VPS → Overview)
ssh root@203.0.113.10

# update the server
apt update && apt upgrade -y

# create a normal user for the app and give it sudo
adduser deploy
usermod -aG sudo deploy

# if you added an SSH key in hPanel, copy it to the new user
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy

# install Python tools, Nginx and Git
apt install -y python3-venv python3-pip python3-dev build-essential nginx git

# firewall: allow SSH, HTTP and HTTPS only
ufw allow OpenSSH
ufw allow 'Nginx Full'
ufw enable
ufw status

# log in as the app user from now on
ssh deploy@203.0.113.10

cd ~
git clone https://github.com/<your-username>/agentsite.git
cd agentsite
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

nano .env        # paste your .env, with DEBUG=False and the server values below

# /home/deploy/agentsite/.env on the server
DJANGO_SECRET_KEY=a-different-long-random-string
DJANGO_DEBUG=False
DJANGO_ALLOWED_HOSTS=yourdomain.com,www.yourdomain.com,203.0.113.10
DJANGO_HTTPS=False
ANTHROPIC_API_KEY=your-anthropic-api-key
CLAUDE_MODEL=claude-opus-5-5

chmod 600 .env
python manage.py migrate
python manage.py collectstatic --noinput
python manage.py createsuperuser

# quick test on port 8000 (close it again afterwards)
sudo ufw allow 8000
gunicorn --bind 0.0.0.0:8000 config.wsgi
# open http://203.0.113.10:8000 in your browser, then press Ctrl+C
sudo ufw delete allow 8000

# /etc/systemd/system/gunicorn.socket
[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

# /etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon for agentsite
Requires=gunicorn.socket
After=network.target

[Service]
User=deploy
Group=www-data
WorkingDirectory=/home/deploy/agentsite
ExecStart=/home/deploy/agentsite/.venv/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --timeout 120 \
          --bind unix:/run/gunicorn.sock \
          config.wsgi:application
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now gunicorn.socket
sudo systemctl status gunicorn.socket

# test: this should print your home page HTML
curl --unix-socket /run/gunicorn.sock localhost

# /etc/nginx/sites-available/agentsite
server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    client_max_body_size 10M;          # allow CSV uploads up to 10 MB

    location = /favicon.ico { access_log off; log_not_found off; }

    location /static/ {
        alias /home/deploy/agentsite/staticfiles/;
    }

    location / {
        include proxy_params;
        proxy_pass http://unix:/run/gunicorn.sock;
        proxy_read_timeout 120s;       # AI answers can take a while
    }
}

sudo ln -s /etc/nginx/sites-available/agentsite /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo chmod 755 /home/deploy          # lets Nginx read the static files
sudo nginx -t
sudo systemctl restart nginx

# DNS records (hPanel → Domains → yourdomain.com → DNS / Nameservers → DNS records)
Type   Name   Points to        TTL
A      @      203.0.113.10     3600
A      www    203.0.113.10     3600

# check from your laptop (repeat until it shows your VPS IP)
nslookup yourdomain.com
nslookup www.yourdomain.com

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

# check that automatic renewal works
sudo certbot renew --dry-run

# now switch Django to HTTPS mode
nano ~/agentsite/.env          # set DJANGO_HTTPS=True
sudo systemctl restart gunicorn

# Optional: a separate Streamlit app on app.yourdomain.com
# (DNS: add an A record "app" → 203.0.113.10, run Streamlit on 127.0.0.1:8501 with its own systemd service)
server {
    listen 80;
    server_name app.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8501;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;     # Streamlit uses websockets
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_read_timeout 86400;
    }
}
# then: sudo certbot --nginx -d app.yourdomain.com

#!/usr/bin/env bash
# ~/agentsite/deploy.sh: run this after every git push
set -e
cd /home/deploy/agentsite
git pull
source .venv/bin/activate
pip install -r requirements.txt
python manage.py migrate --noinput
python manage.py collectstatic --noinput
sudo systemctl restart gunicorn
echo "Deployed ✓"

sudo journalctl -u gunicorn -f              # Django / Gunicorn logs (live)
sudo tail -f /var/log/nginx/error.log       # Nginx errors
sudo systemctl status gunicorn nginx        # are both running?