Upload 47 files

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Katakam Prashanth
+
+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, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Marketeer_Patched_Video.ipynb

@@ -0,0 +1,689 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🧠 Marketeer — Conversational Marketing Bot (Patched)\n",
+        "\n",
+        "**This version fixes video scripting returning empty content** by:\n",
+        "- Using Gemma-friendly prompting (no `system` role for JSON blocks)\n",
+        "- Strong JSON extraction + graceful fallback per beat\n",
+        "- REPL `/video` is fully wired to `make_video()`\n",
+        "- Includes a quick self‑test cell\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "▶ Python: 3.10.11\n",
+            "▶ Platform: Linux-6.6.87.2-microsoft-standard-WSL2-x86_64-with-glibc2.39\n",
+            "\n",
+            "▶ nvidia-smi:\n",
+            "Thu Nov 13 00:51:03 2025       \n",
+            "+-----------------------------------------------------------------------------------------+\n",
+            "| NVIDIA-SMI 560.35.03              Driver Version: 561.09         CUDA Version: 12.6     |\n",
+            "|-----------------------------------------+------------------------+----------------------+\n",
+            "| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
+            "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
+            "|                                         |                        |               MIG M. |\n",
+            "|=========================================+========================+======================|\n",
+            "|   0  NVIDIA GeForce RTX 3060 ...    On  |   00000000:01:00.0  On |                  N/A |\n",
+            "| N/A   57C    P8             13W /   85W |    4961MiB /   6144MiB |     13%      Default |\n",
+            "|                                         |                        |                  N/A |\n",
+            "+-----------------------------------------+------------------------+----------------------+\n",
+            "                                                                                         \n",
+            "+-----------------------------------------------------------------------------------------+\n",
+            "| Processes:                                                                              |\n",
+            "|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |\n",
+            "|        ID   ID                                                               Usage      |\n",
+            "|=========================================================================================|\n",
+            "|    0   N/A  N/A      6286      C   /python3.10                                 N/A      |\n",
+            "+-----------------------------------------------------------------------------------------+\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "import sys, subprocess, platform\n",
+        "print(f'▶ Python: {sys.version.split()[0]}')\n",
+        "print(f'▶ Platform: {platform.platform()}')\n",
+        "print('\\n▶ nvidia-smi:')\n",
+        "try:\n",
+        "    print(subprocess.check_output(['nvidia-smi'], text=True))\n",
+        "except Exception:\n",
+        "    print('(no GPU visible)')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Install base libs\n",
+        "(If already installed, this is a no-op.)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# %pip -q install --upgrade pip\n",
+        "# %pip -q install transformers accelerate sentence-transformers faiss-cpu pypdf textstat regex tiktoken rich"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch, transformers, textwrap, re, json\n",
+        "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+        "from typing import List, Dict, Any\n",
+        "from collections import deque\n",
+        "print({'torch': torch.__version__, 'transformers': transformers.__version__})"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from typing import Dict, List\n",
+        "import re\n",
+        "\n",
+        "PLATFORM_RULES: Dict[str, Dict[str, int]] = {\n",
+        "    'Instagram':   {'cap': 2200, 'hashtags_max': 5, 'emoji_max': 5},\n",
+        "    'Facebook':    {'cap': 125,  'hashtags_max': 0, 'emoji_max': 1},\n",
+        "    'LinkedIn':    {'cap': 3000, 'hashtags_max': 3, 'emoji_max': 2},\n",
+        "    'Google Ads':  {'cap': 90,   'hashtags_max': 0, 'emoji_max': 0},\n",
+        "    'Twitter/X':   {'cap': 280,  'hashtags_max': 2, 'emoji_max': 2},\n",
+        "}\n",
+        "\n",
+        "BANNED_MAP = {\n",
+        "    r'\\bguarantee(d|s)?\\b': 'aim to',\n",
+        "    r'\\bno[-\\s]?risk\\b': 'low risk',\n",
+        "    r'\\bno[-\\s]?questions[-\\s]?asked\\b': 'hassle-free',\n",
+        "    r'\\b#?1\\b': 'top-rated',\n",
+        "    r'\\bbest\\b': 'trusted',\n",
+        "    r'\\bfastest\\b': 'fast',\n",
+        "}\n",
+        "EMOJI_RX   = re.compile(r'[\\U0001F300-\\U0001FAFF\\U00002700-\\U000027BF]')\n",
+        "HASHTAG_RX = re.compile(r'(#\\w+)')\n",
+        "SPACE_RX   = re.compile(r'\\s+')\n",
+        "\n",
+        "def _replace_banned(text: str, audit: List[str]) -> str:\n",
+        "    new = text\n",
+        "    for pat, repl in BANNED_MAP.items():\n",
+        "        if re.search(pat, new, flags=re.I):\n",
+        "            new = re.sub(pat, repl, new, flags=re.I)\n",
+        "            audit.append(f\"Replaced banned phrasing '{pat}' -> '{repl}'.\")\n",
+        "    return new\n",
+        "\n",
+        "def _limit_hashtags(s: str, max_tags: int, audit: List[str]) -> str:\n",
+        "    tags = HASHTAG_RX.findall(s)\n",
+        "    if max_tags == 0 and tags:\n",
+        "        s2 = HASHTAG_RX.sub('', s)\n",
+        "        s2 = SPACE_RX.sub(' ', s2).strip()\n",
+        "        audit.append('Removed all hashtags per platform rules.')\n",
+        "        return s2\n",
+        "    if len(tags) <= max_tags:\n",
+        "        return s\n",
+        "    count = 0\n",
+        "    toks = s.split()\n",
+        "    for i, tok in enumerate(toks):\n",
+        "        if tok.startswith('#'):\n",
+        "            count += 1\n",
+        "            if count > max_tags:\n",
+        "                toks[i] = ''\n",
+        "    s2 = ' '.join(t for t in toks if t)\n",
+        "    audit.append(f'Trimmed hashtags to <= {max_tags}.')\n",
+        "    return s2\n",
+        "\n",
+        "def _limit_emojis(s: str, max_emojis: int, audit: List[str]) -> str:\n",
+        "    if max_emojis < 0:\n",
+        "        return s\n",
+        "    emojis = EMOJI_RX.findall(s)\n",
+        "    if len(emojis) <= max_emojis:\n",
+        "        return s\n",
+        "    kept = 0; out = []\n",
+        "    for ch in s:\n",
+        "        if EMOJI_RX.match(ch):\n",
+        "            if kept < max_emojis:\n",
+        "                out.append(ch); kept += 1\n",
+        "        else:\n",
+        "            out.append(ch)\n",
+        "    audit.append(f'Trimmed emojis to <= {max_emojis}.')\n",
+        "    return ''.join(out)\n",
+        "\n",
+        "def _ensure_keywords(s: str, keywords: List[str], cap: int, audit: List[str]) -> str:\n",
+        "    text = s\n",
+        "    for kw in (keywords or []):\n",
+        "        if kw.strip() and re.search(re.escape(kw), text, flags=re.I) is None:\n",
+        "            cand = (text + ' ' + kw).strip()\n",
+        "            if len(cand) <= cap:\n",
+        "                text = cand\n",
+        "            else:\n",
+        "                parts = text.split()\n",
+        "                if parts:\n",
+        "                    parts[-1] = kw\n",
+        "                    text = ' '.join(parts)\n",
+        "            audit.append(f'Inserted missing keyword: {kw}')\n",
+        "    return text\n",
+        "\n",
+        "def _pick_cta(cta_strength: str) -> str:\n",
+        "    bank = {\n",
+        "        'soft':   ['Learn more','See how it works','Try it free'],\n",
+        "        'medium': ['Get started today','Start now'],\n",
+        "        'hard':   ['Start your free trial now','Buy now','Sign up now'],\n",
+        "    }.get(cta_strength, ['Learn more'])\n",
+        "    return bank[0]\n",
+        "\n",
+        "def _ensure_cta(text: str, cta_strength: str, audit: List[str]) -> str:\n",
+        "    if re.search(r'\\b(learn more|start|try|buy|sign up|get started|discover|explore)\\b', text, flags=re.I):\n",
+        "        return text\n",
+        "    cta = _pick_cta(cta_strength)\n",
+        "    audit.append(f\"Added CTA: '{cta}'.\")\n",
+        "    return (text + (' ' if not text.endswith(('.', '!', '?')) else ' ') + cta).strip()\n",
+        "\n",
+        "def _smart_trim(text: str, cap: int, preserve_tail: str = '') -> str:\n",
+        "    if len(text) <= cap:\n",
+        "        return text\n",
+        "    reserve = len(preserve_tail) + (1 if preserve_tail and not text.endswith(' ') else 0)\n",
+        "    hard = max(0, cap - reserve)\n",
+        "    trimmed = text[:hard].rstrip()\n",
+        "    if preserve_tail:\n",
+        "        if not trimmed.endswith(('.', '!', '?')):\n",
+        "            trimmed = trimmed.rstrip(',;:-')\n",
+        "        trimmed = (trimmed + ' ' + preserve_tail).strip()\n",
+        "    return trimmed[:cap]\n",
+        "\n",
+        "def apply_validators(text: str, platform: str, cap: int, cta_strength: str, keywords: List[str]):\n",
+        "    audit: List[str] = []\n",
+        "    s = text.strip()\n",
+        "    s = _replace_banned(s, audit)\n",
+        "    s = _ensure_cta(s, cta_strength, audit)\n",
+        "    s = _ensure_keywords(s, keywords, 10**9, audit)\n",
+        "    tail_cta = ''\n",
+        "    m = re.search(r'(learn more|start your free trial(?: now)?|start now|try it free|get started(?: today)?|buy now|sign up(?: now)?)$', s, flags=re.I)\n",
+        "    if m:\n",
+        "        tail_cta = m.group(0)\n",
+        "    s = _smart_trim(s, cap, preserve_tail=tail_cta)\n",
+        "    s = _ensure_keywords(s, keywords, cap, audit)\n",
+        "    rule = PLATFORM_RULES.get(platform, PLATFORM_RULES['Instagram'])\n",
+        "    s = _limit_hashtags(s, rule['hashtags_max'], audit)\n",
+        "    s = _limit_emojis(s, rule['emoji_max'], audit)\n",
+        "    if len(s) > cap:\n",
+        "        s = s[:cap].rstrip()\n",
+        "        audit.append(f'Force-clipped to {cap} chars.')\n",
+        "    return s, audit\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class ShortWindowMemory:\n",
+        "    def __init__(self, k: int = 3):\n",
+        "        self.window = deque(maxlen=k)\n",
+        "    def add(self, user: str, assistant: str):\n",
+        "        self.window.append({'user': user, 'assistant': assistant})\n",
+        "    def text(self) -> str:\n",
+        "        if not self.window:\n",
+        "            return ''\n",
+        "        lines = []\n",
+        "        for t in self.window:\n",
+        "            lines.append(f\"Human: {t['user']}\")\n",
+        "            lines.append(f\"AI: {t['assistant']}\")\n",
+        "        return '\\n'.join(lines)\n",
+        "    def reset(self):\n",
+        "        self.window.clear()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "SESSION_PROFILE: Dict[str, Any] = {\n",
+        "    'brand': '', 'product': '', 'audience': '', 'voice': '', 'facts': {}\n",
+        "}\n",
+        "def remember(k: str, v: str):\n",
+        "    if k in ('brand','product','audience','voice'):\n",
+        "        SESSION_PROFILE[k] = v\n",
+        "    else:\n",
+        "        SESSION_PROFILE['facts'][k] = v\n",
+        "    return SESSION_PROFILE\n",
+        "def forget(k: str):\n",
+        "    if k in ('brand','product','audience','voice'):\n",
+        "        SESSION_PROFILE[k] = ''\n",
+        "    else:\n",
+        "        SESSION_PROFILE['facts'].pop(k, None)\n",
+        "    return SESSION_PROFILE\n",
+        "def facts_dump() -> str:\n",
+        "    f = [f\"- brand: {SESSION_PROFILE.get('brand','')}\",\n",
+        "         f\"- product: {SESSION_PROFILE.get('product','')}\",\n",
+        "         f\"- audience: {SESSION_PROFILE.get('audience','')}\",\n",
+        "         f\"- voice: {SESSION_PROFILE.get('voice','')}\"]\n",
+        "    if SESSION_PROFILE['facts']:\n",
+        "        f.append('- facts:')\n",
+        "        for k,v in SESSION_PROFILE['facts'].items():\n",
+        "            f.append(f\"  • {k}: {v}\")\n",
+        "    return '\\n'.join(f)\n",
+        "BASE_GUIDANCE = (\n",
+        "    'You are Marketeer, a concise, benefit-first marketing copywriter. '\n",
+        "    'Respect the platform\\'s character cap, include required keywords, and end with a clear but compliant CTA. '\n",
+        "    \"Avoid absolute claims like 'guaranteed', '#1', or 'best'. Prefer modest, evidence-backed phrasing.\"\n",
+        ")\n",
+        "def _profile_block() -> str:\n",
+        "    lines = []\n",
+        "    if any(SESSION_PROFILE.values()):\n",
+        "        lines.append('Session profile:')\n",
+        "        if SESSION_PROFILE.get('brand'):   lines.append(f\"- Brand: {SESSION_PROFILE['brand']}\")\n",
+        "        if SESSION_PROFILE.get('product'): lines.append(f\"- Product: {SESSION_PROFILE['product']}\")\n",
+        "        if SESSION_PROFILE.get('audience'):lines.append(f\"- Audience: {SESSION_PROFILE['audience']}\")\n",
+        "        if SESSION_PROFILE.get('voice'):   lines.append(f\"- Voice: {SESSION_PROFILE['voice']}\")\n",
+        "        if SESSION_PROFILE['facts']:\n",
+        "            lines.append('- Key facts:')\n",
+        "            for k,v in SESSION_PROFILE['facts'].items():\n",
+        "                lines.append(f\"  • {k}: {v}\")\n",
+        "    return '\\n'.join(lines) if lines else '[no session profile]'\n",
+        "import textwrap\n",
+        "def build_prompt(user_input: str, platform: str, tone: str, cta_strength: str, cap: int,\n",
+        "                 keywords: List[str], history_text: str = '') -> str:\n",
+        "    kw = ', '.join(keywords) if keywords else '(none)'\n",
+        "    profile = _profile_block()\n",
+        "    return textwrap.dedent(f\"\"\"\n",
+        "    {BASE_GUIDANCE}\n",
+        "\n",
+        "    Context (recent conversation, if any):\n",
+        "    {history_text if history_text else '[no prior turns in memory]'}\n",
+        "\n",
+        "    {profile}\n",
+        "\n",
+        "    Task:\n",
+        "    - Platform: {platform}\n",
+        "    - Tone: {tone}\n",
+        "    - CTA strength: {cta_strength}\n",
+        "    - Character cap: {cap}\n",
+        "    - Required keywords: {kw}\n",
+        "\n",
+        "    User request:\n",
+        "    {user_input}\n",
+        "\n",
+        "    Instructions:\n",
+        "    - Be benefit-first and platform-appropriate.\n",
+        "    - Keep within the character cap (hard limit {cap} chars).\n",
+        "    - Include all required keywords (if any).\n",
+        "    - Close with a clear CTA matching CTA strength.\n",
+        "    - Avoid banned claims ('guaranteed', '#1', 'best').\n",
+        "\n",
+        "    Return only the marketing copy (no preamble).\n",
+        "    \"\"\").strip()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import getpass\n",
+        "MODEL_ID = 'google/gemma-2-2b-it'\n",
+        "DTYPE = 'bfloat16'\n",
+        "try:\n",
+        "    token = getpass.getpass('Enter HF token (press Enter to skip): ')\n",
+        "    HF_TOKEN = token.strip() or None\n",
+        "except Exception:\n",
+        "    HF_TOKEN = None\n",
+        "torch_dtype = {'bfloat16': torch.bfloat16, 'float16': torch.float16}.get(DTYPE, torch.bfloat16)\n",
+        "tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN)\n",
+        "if tokenizer.pad_token is None:\n",
+        "    tokenizer.pad_token = tokenizer.eos_token\n",
+        "model = AutoModelForCausalLM.from_pretrained(MODEL_ID, dtype=torch_dtype, device_map='auto', token=HF_TOKEN)\n",
+        "print({'model': MODEL_ID, 'dtype': str(torch_dtype).replace('torch.', '')})"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "memory = ShortWindowMemory(k=3)\n",
+        "DEFAULTS = {'platform': 'Instagram', 'tone': 'friendly, energetic', 'cta': 'soft'}\n",
+        "def _generate(prompt_text: str, max_new_tokens=180, temperature=0.7, top_p=0.9, repetition_penalty=1.1):\n",
+        "    messages = [{'role': 'user', 'content': prompt_text}]\n",
+        "    input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors='pt').to(model.device)\n",
+        "    with torch.no_grad():\n",
+        "        out = model.generate(\n",
+        "            input_ids=input_ids,\n",
+        "            max_new_tokens=max_new_tokens,\n",
+        "            temperature=temperature,\n",
+        "            top_p=top_p,\n",
+        "            repetition_penalty=repetition_penalty,\n",
+        "            do_sample=True,\n",
+        "            pad_token_id=tokenizer.pad_token_id,\n",
+        "            eos_token_id=tokenizer.eos_token_id,\n",
+        "        )\n",
+        "    gen_ids = out[0][input_ids.shape[-1]:]\n",
+        "    return tokenizer.decode(gen_ids, skip_special_tokens=True).strip()\n",
+        "def send(user: str, platform: str=None, tone: str=None, cta_strength: str=None, cap: int=None, keywords: List[str]=None,\n",
+        "         max_new_tokens=180, temperature=0.7, top_p=0.9, repetition_penalty=1.1):\n",
+        "    platform = platform or DEFAULTS['platform']\n",
+        "    tone = tone or DEFAULTS['tone']\n",
+        "    cta_strength = cta_strength or DEFAULTS['cta']\n",
+        "    cap = cap or PLATFORM_RULES.get(platform, PLATFORM_RULES['Instagram'])['cap']\n",
+        "    keywords = keywords or []\n",
+        "    prompt_text = build_prompt(user, platform, tone, cta_strength, cap, keywords, memory.text())\n",
+        "    raw = _generate(prompt_text, max_new_tokens, temperature, top_p, repetition_penalty)\n",
+        "    final, audit = apply_validators(raw, platform, cap, cta_strength, keywords)\n",
+        "    memory.add(user, final)\n",
+        "    return {'raw': raw, 'final': final, 'audit': audit, 'cap': cap}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "VIDEO_BLUEPRINTS = {\n",
+        "    'short_ad': ['Hook (2-3s)','Problem (3-5s)','Product intro (4-6s)','Key benefit (4-6s)','CTA (2-3s)'],\n",
+        "    'ugc_review': ['Relatable hook','Pain point','Discovery','Feature demo','Social proof','CTA'],\n",
+        "    'how_to': ['Teaser result','Step 1','Step 2','Step 3','Recap + CTA'],\n",
+        "}\n",
+        "def plan_video(blueprint: str='short_ad', duration_sec: int=20, product_brief: str='') -> Dict[str, Any]:\n",
+        "    if blueprint not in VIDEO_BLUEPRINTS:\n",
+        "        raise ValueError(f\"Unknown blueprint '{blueprint}'. Options: {list(VIDEO_BLUEPRINTS.keys())}\")\n",
+        "    beats = VIDEO_BLUEPRINTS[blueprint]\n",
+        "    per_beat = max(2, duration_sec // max(1, len(beats)))\n",
+        "    plan = []\n",
+        "    for i, beat in enumerate(beats, 1):\n",
+        "        plan.append({\n",
+        "            'order': i,\n",
+        "            'beat': beat,\n",
+        "            'time_window': f\"{(i-1)*per_beat:02d}-{min(i*per_beat, duration_sec):02d}s\",\n",
+        "        })\n",
+        "    return {\n",
+        "        'blueprint': blueprint,\n",
+        "        'duration_sec': duration_sec,\n",
+        "        'beats': plan,\n",
+        "        'product_brief': product_brief or '(use chat context)',\n",
+        "    }\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import json as _json, re as _re\n",
+        "\n",
+        "def _session_context_text():\n",
+        "    history_text = memory.text()\n",
+        "    lines = []\n",
+        "    lines.append('=== SESSION PROFILE ===')\n",
+        "    if SESSION_PROFILE.get('brand'):   lines.append(f\"Brand: {SESSION_PROFILE['brand']}\")\n",
+        "    if SESSION_PROFILE.get('product'): lines.append(f\"Product: {SESSION_PROFILE['product']}\")\n",
+        "    if SESSION_PROFILE.get('audience'):lines.append(f\"Audience: {SESSION_PROFILE['audience']}\")\n",
+        "    if SESSION_PROFILE.get('voice'):   lines.append(f\"Preferred Voice: {SESSION_PROFILE['voice']}\")\n",
+        "    if SESSION_PROFILE.get('facts'):\n",
+        "        lines.append('Facts:')\n",
+        "        for k,v in SESSION_PROFILE['facts'].items():\n",
+        "            lines.append(f\"- {k}: {v}\")\n",
+        "    lines.append('\\n=== RECENT CONVERSATION ===')\n",
+        "    lines.append(history_text if history_text else '[none]')\n",
+        "    return '\\n'.join(lines)\n",
+        "\n",
+        "def _decode_tail(out_ids, start_idx):\n",
+        "    return tokenizer.decode(out_ids[0][start_idx:], skip_special_tokens=True).strip()\n",
+        "\n",
+        "def _just_user_prompt(prompt_text: str, max_new_tokens=320):\n",
+        "    messages = [{'role':'user','content': prompt_text}]\n",
+        "    input_ids = tokenizer.apply_chat_template(\n",
+        "        messages, tokenize=True, add_generation_prompt=True, return_tensors='pt'\n",
+        "    ).to(model.device)\n",
+        "    with torch.no_grad():\n",
+        "        out = model.generate(\n",
+        "            input_ids=input_ids,\n",
+        "            max_new_tokens=max_new_tokens,\n",
+        "            temperature=0.6,\n",
+        "            top_p=0.9,\n",
+        "            repetition_penalty=1.1,\n",
+        "            do_sample=True,\n",
+        "            pad_token_id=tokenizer.pad_token_id,\n",
+        "            eos_token_id=tokenizer.eos_token_id,\n",
+        "        )\n",
+        "    return _decode_tail(out, input_ids.shape[-1])\n",
+        "\n",
+        "def _extract_json(gen_text: str):\n",
+        "    try:\n",
+        "        return _json.loads(gen_text)\n",
+        "    except Exception:\n",
+        "        pass\n",
+        "    m = _re.search(r'\\{.*\\}', gen_text, flags=_re.S)\n",
+        "    if m:\n",
+        "        try:\n",
+        "            return _json.loads(m.group(0))\n",
+        "        except Exception:\n",
+        "            pass\n",
+        "    return None\n",
+        "\n",
+        "def _fallback_block(beat_title: str):\n",
+        "    short = beat_title.split('(')[0].strip()\n",
+        "    return {\n",
+        "        'voiceover': f\"{short}: naturally delicious, try it today.\",\n",
+        "        'on_screen': (short[:32] or 'Fresh & Natural'),\n",
+        "        'shots': ['Close-up product', 'Serving scoop', 'Happy bite'],\n",
+        "        'broll': ['Farm/ingredient cutaways', 'Pouring/serving'],\n",
+        "        'captions': ['Naturally made ice cream', 'From local farms'],\n",
+        "    }\n",
+        "\n",
+        "def script_video_from_plan(plan: dict, style: str = 'friendly, energetic', platform: str = 'Instagram', debug_first=False):\n",
+        "    context = _session_context_text()\n",
+        "    blueprint = plan.get('blueprint', '?')\n",
+        "    duration  = plan.get('duration_sec', 20)\n",
+        "    beats     = plan.get('beats', [])\n",
+        "    scripted_beats = []\n",
+        "\n",
+        "    for idx, b in enumerate(beats):\n",
+        "        brief = (\n",
+        "            context + '\\n\\n'\n",
+        "            '=== VIDEO BLUEPRINT ===\\n'\n",
+        "            f'Type: {blueprint} | Duration: {duration}s\\n'\n",
+        "            f\"Current beat: {b['order']} — {b['beat']} ({b['time_window']})\\n\\n\"\n",
+        "            'Write concise items with the following constraints:\\n'\n",
+        "            '- voiceover: <= 18 words, benefits-first, natural.\\n'\n",
+        "            '- on_screen: <= 36 characters, punchy overlay text.\\n'\n",
+        "            '- shots: 3 ideas, short imperatives (e.g., \"Close-up pour\").\\n'\n",
+        "            '- broll: 2 ideas, short.\\n'\n",
+        "            '- captions: 1–2 lines, each <= 40 characters.\\n\\n'\n",
+        "            f'Platform: {platform}\\n'\n",
+        "            f'Style/Tone: {style}\\n\\n'\n",
+        "            'Return ONLY valid JSON with keys:\\n'\n",
+        "            '{\\n  \"voiceover\": \"string\",\\n  \"on_screen\": \"string\",\\n  \"shots\": [\"...\", \"...\", \"...\"],\\n  \"broll\": [\"...\", \"...\"],\\n  \"captions\": [\"...\", \"...\"]\\n}'\n",
+        "        )\n",
+        "        gen_text = _just_user_prompt(brief, max_new_tokens=320)\n",
+        "        if debug_first and idx == 0:\n",
+        "            print('RAW (beat 1):\\n', gen_text)\n",
+        "        data = _extract_json(gen_text)\n",
+        "        if not data:\n",
+        "            data = _fallback_block(b.get('beat','Beat'))\n",
+        "\n",
+        "        scripted_beats.append({\n",
+        "            'order': b.get('order'),\n",
+        "            'time_window': b.get('time_window'),\n",
+        "            'beat': b.get('beat'),\n",
+        "            'voiceover': data.get('voiceover','') or _fallback_block(b.get('beat',''))['voiceover'],\n",
+        "            'on_screen': data.get('on_screen','') or _fallback_block(b.get('beat',''))['on_screen'],\n",
+        "            'shots': (data.get('shots') or _fallback_block(b.get('beat',''))['shots'])[:3],\n",
+        "            'broll': (data.get('broll') or _fallback_block(b.get('beat',''))['broll'])[:2],\n",
+        "            'captions': (data.get('captions') or _fallback_block(b.get('beat',''))['captions'])[:2],\n",
+        "        })\n",
+        "\n",
+        "    return {\n",
+        "        'blueprint': blueprint,\n",
+        "        'duration_sec': duration,\n",
+        "        'style': style,\n",
+        "        'platform': platform,\n",
+        "        'product_brief': plan.get('product_brief',''),\n",
+        "        'script': scripted_beats\n",
+        "    }\n",
+        "\n",
+        "def make_video(plan_or_blueprint='short_ad', duration=20, product_brief='', style='friendly, energetic', platform='Instagram', debug_first=False):\n",
+        "    if isinstance(plan_or_blueprint, dict):\n",
+        "        plan = plan_or_blueprint\n",
+        "    else:\n",
+        "        plan = plan_video(plan_or_blueprint, duration, product_brief)\n",
+        "    return script_video_from_plan(plan, style=style, platform=platform, debug_first=debug_first)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from rich.console import Console\n",
+        "from rich.table import Table\n",
+        "from rich.panel import Panel\n",
+        "from rich.markdown import Markdown\n",
+        "import re, json as _j\n",
+        "\n",
+        "console = Console()\n",
+        "def _print_header():\n",
+        "    t = Table(title='Marketeer — REPL (Patched)', show_lines=False)\n",
+        "    t.add_column('Setting', style='cyan', no_wrap=True)\n",
+        "    t.add_column('Value', style='white')\n",
+        "    t.add_row('Model', MODEL_ID)\n",
+        "    t.add_row('Platform', 'Instagram')\n",
+        "    t.add_row('Tone', 'friendly, energetic')\n",
+        "    t.add_row('CTA', 'soft')\n",
+        "    console.print(t)\n",
+        "    console.print(Markdown(\n",
+        "        '**Commands**\\n'\n",
+        "        '- `/remember key=value`, `/forget key`, `/facts`\\n'\n",
+        "        '- `/video blueprint=short_ad duration=20 style=warm platform=Instagram`\\n'\n",
+        "        '- Type any prompt to generate copy.'\n",
+        "    ))\n",
+        "\n",
+        "def _parse_kv(line: str):\n",
+        "    parts = re.findall(r'(\\w+)=(\".*?\"|\\'.*?\\'|\\S+)', line)\n",
+        "    out = {}\n",
+        "    for k, v in parts:\n",
+        "        v = v.strip().strip('\"').strip(\"'\")\n",
+        "        out[k] = v\n",
+        "    return out\n",
+        "\n",
+        "def repl():\n",
+        "    _print_header()\n",
+        "    while True:\n",
+        "        try:\n",
+        "            line = console.input('[bold magenta]You[/bold magenta]: ').strip()\n",
+        "        except (KeyboardInterrupt, EOFError):\n",
+        "            console.print('\\n[yellow]Bye.[/yellow]'); break\n",
+        "        if not line:\n",
+        "            continue\n",
+        "        low = line.lower()\n",
+        "        if low in ('/exit','exit','quit','/quit'):\n",
+        "            console.print('[yellow]Bye.[/yellow]'); break\n",
+        "        if low.startswith('/facts'):\n",
+        "            console.print(Panel(facts_dump() or '(no facts)', title='Session Facts')); continue\n",
+        "        if low.startswith('/forget'):\n",
+        "            kv = _parse_kv(line)\n",
+        "            for k in kv.keys(): forget(k)\n",
+        "            console.print(Panel('Updated facts.', title='OK')); continue\n",
+        "        if low.startswith('/remember'):\n",
+        "            kv = _parse_kv(line)\n",
+        "            if not kv and '=' in line:\n",
+        "                raw = line.split(None, 1)[1]\n",
+        "                k,v = raw.split('=',1)\n",
+        "                remember(k.strip(), v.strip())\n",
+        "            else:\n",
+        "                for k,v in kv.items(): remember(k, v)\n",
+        "            console.print(Panel('Saved.', title='OK')); continue\n",
+        "        if low.startswith('/video'):\n",
+        "            kv = _parse_kv(line)\n",
+        "            blueprint = kv.get('blueprint','short_ad')\n",
+        "            duration  = int(kv.get('duration','20'))\n",
+        "            style     = kv.get('style','friendly, energetic')\n",
+        "            platformV = kv.get('platform','Instagram')\n",
+        "            brief     = SESSION_PROFILE.get('product','') or SESSION_PROFILE.get('brand','') or 'marketing video'\n",
+        "            plan = plan_video(blueprint, duration, brief)\n",
+        "            script = make_video(plan, style=style, platform=platformV, debug_first=True)\n",
+        "            console.print(Panel(_j.dumps(script, indent=2), title='Video Script'))\n",
+        "            continue\n",
+        "        # normal prompt\n",
+        "        result = send(line)\n",
+        "        console.print(Panel(result['final'], title='Response', subtitle=f\"len={len(result['final'])}/{result['cap']}\"))\n",
+        "        if result['audit']:\n",
+        "            md = '\\n'.join([f\"- {a}\" for a in result['audit']])\n",
+        "            console.print(Panel(md, title='Audit trail'))\n",
+        "        else:\n",
+        "            console.print('[dim]No edits needed.[/dim]')\n",
+        "\n",
+        "repl()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Quick self‑test (optional)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Uncomment to smoke test video scripting\n",
+        "# remember('brand','FrostFields')\n",
+        "# remember('product','Natural fruit ice cream')\n",
+        "# remember('origin','Local farms')\n",
+        "# plan = plan_video('short_ad', 20, 'Natural ice cream with coconut & apple')\n",
+        "# vid = make_video(plan, style='warm, wholesome', platform='Instagram', debug_first=True)\n",
+        "# import json as j; print(j.dumps(vid, indent=2))\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "Marketeer_Patched_Video.ipynb"
+    },
+    "kernelspec": {
+      "display_name": "ai",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

README.md

@@ -1,12 +1 @@
----
-title: Marketeer
-emoji: 🌖
-colorFrom: purple
-colorTo: purple
-sdk: gradio
-sdk_version: 6.0.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Marketing_chat_bot

app.py

@@ -0,0 +1,13 @@
+"""
+App entry point for Marketeer on Hugging Face Spaces (and local use).
+"""
+
+from ui.gradio_ui import create_interface
+
+
+# Hugging Face Spaces will run this file.
+# Locally, you can run: python app.py
+if __name__ == "__main__":
+    demo = create_interface()
+    # On Spaces, you typically don't need any special args.
+    demo.launch()

blueprint.md

@@ -0,0 +1,340 @@
+Nice, let’s turn all that into a **clean roadmap** you can actually work through, phase by phase. Think of this as the “Marketeer x LangChain x HF” blueprint you can keep coming back to.
+
+---
+
+# 🧭 Marketeer Roadmap (LangChain + Hugging Face)
+
+## Phase 0 – Current Baseline (where you are now)
+
+**You already have:**
+
+* Local HF model (Gemma) running on RTX 3060.
+* Core modules:
+
+  * `core_logic/llm_client.py` (manual `generate_text`)
+  * `core_logic/copy_pipeline.py` (template-based copy + validators)
+  * `core_logic/video_pipeline.py` (video beats + parsing + validators)
+  * `ui/gradio_ui.py` (Gradio UI: Copy tab + Video tab)
+  * Simple chat mode using:
+
+    * `core_logic/chat_chain.py` (PromptTemplate + our custom MarketeerLLM / now simplified)
+* Platform rules + validators from the notebook.
+
+We’ll **evolve this** instead of throwing it away.
+
+---
+
+## Phase 1 – Switch to ChatHuggingFace Backend
+
+**Goal:** Use **official LangChain-HuggingFace** integration instead of a custom wrapper, so future features (tools, structured outputs, etc.) are easier.
+
+### 1.1. Dependencies
+
+* Add to `requirements.txt`:
+
+  ```txt
+  langchain-huggingface
+  langchain-core
+  transformers
+  accelerate
+  bitsandbytes
+  ```
+
+### 1.2. LLM config module
+
+Create something like `core_logic/llm_config.py`:
+
+* **Local dev (pipeline-based):**
+
+  ```python
+  from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
+  from transformers import BitsAndBytesConfig
+
+  def get_local_chat_model():
+      quant_config = BitsAndBytesConfig(
+          load_in_4bit=True,
+          bnb_4bit_quant_type="nf4",
+          bnb_4bit_compute_dtype="float16",
+          bnb_4bit_use_double_quant=True,
+      )
+
+      base_llm = HuggingFacePipeline.from_model_id(
+          model_id="google/gemma-2-2b-it",
+          task="text-generation",
+          pipeline_kwargs=dict(
+              max_new_tokens=256,
+              do_sample=True,
+              temperature=0.8,
+              top_p=0.9,
+              return_full_text=False,
+          ),
+          model_kwargs={"quantization_config": quant_config},
+      )
+
+      return ChatHuggingFace(llm=base_llm)
+  ```
+
+* Later we’ll add a `get_endpoint_chat_model()` for Spaces.
+
+### 1.3. Deprecate `MarketeerLLM`
+
+* Keep `core_logic/llm_client.py` around if other code still uses it.
+* For chat + new logic, use `ChatHuggingFace` from `llm_config.get_local_chat_model()`.
+
+**Deliverable:**
+A single `ChatHuggingFace` object you can import anywhere as your main chat LLM.
+
+---
+
+## Phase 2 – Proper Chat Chain with System + History Messages
+
+**Goal:** Make the copy chat flow use **LangChain-style messages** instead of raw strings, so context handling is cleaner.
+
+### 2.1. New chat chain file
+
+Refactor `core_logic/chat_chain.py`:
+
+* Import:
+
+  ```python
+  from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+  from langchain_core.prompts import ChatPromptTemplate
+  from core_logic.llm_config import get_local_chat_model
+  from helpers.platform_rules import ...
+  from helpers.validators import validate_and_edit
+  ```
+
+* Build a **System prompt** from campaign context + platform rules:
+
+  ```python
+  def build_system_message(req, platform_cfg):
+      content = f"""
+      You are an expert social media marketer.
+
+      Brand: {req.brand}
+      Product/Offer: {req.product}
+      Target audience: {req.audience}
+      Campaign goal: {req.goal}
+      Platform: {platform_cfg.name}
+      Tone: {req.tone}
+      CTA style: {req.cta_style}
+      Extra context: {req.extra_context}
+
+      Follow platform rules and keep the final post within ~{platform_cfg.char_cap} characters.
+      Respond ONLY with the post text (no explanations).
+      """
+      return SystemMessage(content=content.strip())
+  ```
+
+* Convert `chat_history` (list `[user, assistant]`) to messages:
+
+  ```python
+  def history_to_messages(history_pairs):
+      msgs = []
+      for u, a in history_pairs:
+          if u:
+              msgs.append(HumanMessage(content=u))
+          if a:
+              msgs.append(AIMessage(content=a))
+      return msgs
+  ```
+
+* `chat_turn(...)`:
+
+  ```python
+  def chat_turn(req, user_message, history_pairs):
+      platform_cfg = _get_platform_config(req.platform_name)
+      chat_model = get_local_chat_model()
+
+      system_msg = build_system_message(req, platform_cfg)
+      history_msgs = history_to_messages(history_pairs)
+      user_msg = HumanMessage(content=user_message)
+
+      messages = [system_msg] + history_msgs + [user_msg]
+
+      ai_msg = chat_model.invoke(messages)
+      raw_text = ai_msg.content
+      final_text, audit = validate_and_edit(raw_text, platform_cfg)
+      return final_text, raw_text, audit
+  ```
+
+### 2.2. UI stays mostly same
+
+* `ui/gradio_ui.py` continues passing `chat_history` and `user_message`.
+* Internally, `chat_turn` now uses **true chat messages** and a **SystemMessage**.
+
+**Deliverable:**
+Your chat bot respects system instructions + history in a robust, LangChain-native way.
+
+---
+
+## Phase 3 – Structured Output for Video Script Generator
+
+**Goal:** Instead of fragile JSON/beat parsing, use LangChain’s structured output to get reliable beat objects.
+
+### 3.1. Define a Pydantic model
+
+In `core_logic/video_schema.py`:
+
+```python
+from typing import List
+from pydantic import BaseModel
+
+class Beat(BaseModel):
+    title: str
+    voiceover: str
+    on_screen: str
+    shots: List[str]
+    broll: List[str]
+    captions: List[str]
+    t_start: float
+    t_end: float
+
+class VideoPlan(BaseModel):
+    blueprint_name: str
+    duration_sec: int
+    platform_name: str
+    style: str
+    beats: List[Beat]
+```
+
+### 3.2. Use structured output in `video_pipeline`
+
+* Build a prompt that instructs the model to output that schema.
+* Use `StructuredTool` or LangChain’s `with_structured_output(VideoPlan)` (depending on version).
+* Replace manual JSON parsing with a direct Pydantic model.
+
+**Deliverable:**
+`generate_video_script()` returns a `VideoPlan` object directly, with clean per-beat data and fewer parsing errors.
+
+---
+
+## Phase 4 – LangChain Memory (Optional but Powerful)
+
+**Goal:** Advanced memory if you want more than simple chat history.
+
+### 4.1. Token-based memory
+
+Use `ConversationTokenBufferMemory` instead of raw `chat_history`:
+
+* Wrap it around your `ChatHuggingFace` model.
+* Limit memory by tokens (e.g., last 1024 tokens).
+* Still easy to connect to Gradio by syncing the memory with `chat_history`.
+
+### 4.2. Knowledge-style memory (later)
+
+If you want persistence per brand/campaign:
+
+* Store brand facts in a DB and summarize them per session.
+* Memory retrieval each time a session starts.
+
+**Deliverable:**
+Chat sessions that scale better (longer conversations) without bloating context.
+
+---
+
+## Phase 5 – Tools & Agents for “Smart Marketing Assistant”
+
+**Goal:** Turn Marketeer from a “single LLM” into a **tool-using assistant**.
+
+### 5.1. Tools
+
+Some concrete tools:
+
+* `generate_hashtags(copy, platform)`
+* `rewrite_tone(copy, tone)`
+* `check_length(copy, platform)` (wraps your validators)
+* `summarize_campaign(history)`
+
+Use LangChain’s tool abstraction (`@tool` or `Tool` class) to define them.
+
+### 5.2. Router / Agent
+
+Use an agent that decides:
+
+* When user asks “shorten this” → use `rewrite_tone`.
+* When user says “give options” → generate variants.
+* When user says “turn this into a video script” → call video generator.
+
+**Deliverable:**
+Single chat entry point that can:
+
+* Write copy
+* Edit copy
+* Generate video storyboards
+* Explain why choices were made (if you want)
+
+---
+
+## Phase 6 – Hugging Face Spaces Deployment Plan
+
+**Goal:** Clean, reproducible deployment.
+
+### 6.1. Repo structure (already close, just formalize)
+
+* `app.py` – Gradio entry
+* `ui/` – UI code
+* `core_logic/` – pipelines, chain logic
+* `helpers/` – platform rules, validators
+* `requirements.txt`
+* `README.md`
+
+### 6.2. Backend choice for Spaces
+
+* **Dev / personal Space:**
+  Use local model (pipeline) in `app.py` (like now).
+* **Production / shared Space:**
+  Switch `llm_config.get_local_chat_model()` to `get_endpoint_chat_model()` that uses `HuggingFaceEndpoint` and reads `HUGGINGFACEHUB_API_TOKEN` from secrets.
+
+**Deliverable:**
+A Space that others can open and:
+
+* Fill brand/product/audience/goal
+* Chat with the Marketeer bot
+* Generate copy + video scripts
+* With stable HF-hosted backend
+
+---
+
+## Phase 7 – “Strategist Mode” (Bonus)
+
+**Goal:** Move beyond just *copy* to *campaign thinking*.
+
+Ideas:
+
+* A mode that, given brand + budget + timeframe, outputs:
+
+  * channel mix (IG / LinkedIn / YouTube Shorts)
+  * example posts per channel
+  * rough posting cadence
+* Use LangChain prompts with a “marketing strategist” SystemMessage.
+* Let user toggle between “Copywriter Mode” and “Strategist Mode” in the UI.
+
+**Deliverable:**
+Marketeer feels like a mini marketing partner, not just a caption generator.
+
+---
+
+## How to Use This Roadmap
+
+You can literally go phase by phase:
+
+1. **Phase 1** – Swap to `ChatHuggingFace` backend.
+2. **Phase 2** – Refactor `chat_chain` to use System + messages.
+3. **Phase 3** – Structured outputs for the video planner.
+4. **Phase 4+** – Optional memory / tools / agents / deployment polish.
+
+Whenever you’re ready, tell me:
+
+> “Let’s start Phase 1 step-by-step”
+
+and I’ll write the exact code changes (file-by-file, minimal diff style) to get that phase done.
+
+
+
+
+
+
+
+
+

check.ipynb

@@ -0,0 +1,70 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "49c5075b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tue Nov 25 03:08:08 2025       \n",
+      "+-----------------------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 550.54.15              Driver Version: 550.54.15      CUDA Version: 12.4     |\n",
+      "|-----------------------------------------+------------------------+----------------------+\n",
+      "| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
+      "|                                         |                        |               MIG M. |\n",
+      "|=========================================+========================+======================|\n",
+      "|   0  Tesla T4                       Off |   00000000:00:04.0 Off |                    0 |\n",
+      "| N/A   45C    P8              9W /   70W |       0MiB /  15360MiB |      0%      Default |\n",
+      "|                                         |                        |                  N/A |\n",
+      "+-----------------------------------------+------------------------+----------------------+\n",
+      "                                                                                         \n",
+      "+-----------------------------------------------------------------------------------------+\n",
+      "| Processes:                                                                              |\n",
+      "|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |\n",
+      "|        ID   ID                                                               Usage      |\n",
+      "|=========================================================================================|\n",
+      "|  No running processes found                                                             |\n",
+      "+-----------------------------------------------------------------------------------------+\n"
+     ]
+    }
+   ],
+   "source": [
+    "!nvidia-smi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a227f2ae",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

core_logic/chat_agent.py

@@ -0,0 +1,216 @@
+"""
+Agent-style chat for Marketeer using LangChain tools.
+
+- Uses ChatHuggingFace from llm_config.get_local_chat_model()
+- Uses rewrite / tone tools from rewrite_tools.py
+- Implements a tiny tool-calling loop with .bind_tools() (no AgentExecutor).
+"""
+
+from typing import Any, Dict, List, Tuple, Union
+
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.tools import BaseTool
+
+from core_logic.llm_config import get_local_chat_model
+from core_logic.copy_pipeline import CopyRequest
+from helpers.platform_styles import get_platform_style  # <-- dataclass style
+from core_logic.rewrite_tools import get_rewrite_tools
+
+
+Message = Union[HumanMessage, AIMessage]
+
+
+# --------------------------------------------------------------------
+# Helpers for platform style and history
+# --------------------------------------------------------------------
+
+
+def _get_style_attr(style: Any, field: str, default: str = "") -> str:
+    """
+    Safe attribute getter for PlatformStyle dataclass (or dict fallback).
+
+    This handles both:
+    - dataclass PlatformStyle (preferred)
+    - dict-like (in case of accidental mix)
+    """
+    if style is None:
+        return default
+
+    # Dataclass / object path
+    if hasattr(style, field):
+        value = getattr(style, field)
+        return default if value is None else str(value)
+
+    # Dict path (just in case)
+    if isinstance(style, dict):
+        value = style.get(field, default)
+        return default if value is None else str(value)
+
+    return default
+
+
+def _build_system_prompt(req: CopyRequest) -> str:
+    """
+    Build a system instruction that explains:
+    - you are a marketing copywriter
+    - you know the campaign context
+    - you may optionally use tools to rewrite/edit
+    """
+    # This comes from helpers.platform_styles and returns a PlatformStyle dataclass
+    style = get_platform_style(req.platform_name or "Instagram")
+
+    # Access attributes directly (NO dict-style indexing anywhere)
+    voice = getattr(style, "voice", "")
+    emoji_guideline = getattr(style, "emoji_guideline", "")
+    hashtag_guideline = getattr(style, "hashtag_guideline", "")
+    formatting_guideline = getattr(style, "formatting_guideline", "")
+    extra_notes = getattr(style, "extra_notes", "")
+
+    return f"""
+You are Marketeer, an expert marketing copywriter.
+
+You help users:
+- write first-draft posts
+- refine tone
+- shorten or expand posts
+- adapt copy across platforms
+
+Campaign context:
+- Brand: {req.brand}
+- Product / offer: {req.product}
+- Audience: {req.audience}
+- Goal: {req.goal}
+- Platform: {req.platform_name}
+- Tone: {req.tone}
+- CTA style: {req.cta_style}
+- Extra context: {req.extra_context}
+
+Platform style guidelines:
+- Voice: {voice}
+- Emoji usage: {emoji_guideline}
+- Hashtags: {hashtag_guideline}
+- Formatting: {formatting_guideline}
+- Extra notes: {extra_notes}
+
+You may have access to special tools that help you:
+- adjust tone
+- shorten or expand text
+- remove or add emojis
+- tweak style
+
+When you respond:
+- If the user clearly wants a simple answer, respond directly.
+- If the user is asking to rewrite existing text (e.g. "shorten this", 
+  "make it more professional", "remove emojis"), feel free to call tools
+  if they are available.
+- Always return clean, user-ready copy (no JSON, no debug).
+    """.strip()
+
+
+
+def _build_message_history(history_pairs: List[List[str]]) -> List[Message]:
+    """
+    Convert [[user, assistant], ...] into LangChain Human/AI messages.
+    """
+    messages: List[Message] = []
+    for pair in history_pairs:
+        if not pair or len(pair) != 2:
+            continue
+        user_text, assistant_text = pair
+        if user_text:
+            messages.append(HumanMessage(content=user_text))
+        if assistant_text:
+            messages.append(AIMessage(content=assistant_text))
+    return messages
+
+
+def _get_tool_map(tools: List[BaseTool]) -> Dict[str, BaseTool]:
+    """
+    Convenience map: tool_name -> tool object.
+    """
+    return {tool.name: tool for tool in tools}
+
+
+# --------------------------------------------------------------------
+# Main agent entry point
+# --------------------------------------------------------------------
+
+
+def agent_chat_turn(
+    req: CopyRequest,
+    user_message: str,
+    history_pairs: List[List[str]] | None = None,
+) -> Tuple[str, str, list]:
+    ...
+    history_pairs = history_pairs or []
+
+    # 1) Build base messages: "system" prompt as a HumanMessage + history + new user
+    instructions = _build_system_prompt(req)
+
+    # IMPORTANT: use HumanMessage here, not SystemMessage
+    system_msg = HumanMessage(content=instructions)
+
+    history_msgs = _build_message_history(history_pairs)
+    new_user_msg = HumanMessage(content=user_message)
+
+    messages: List[Union[Message, ToolMessage]] = (
+        [system_msg] + history_msgs + [new_user_msg]
+    )
+
+
+    # 2) Prepare tools & model
+    tools: List[BaseTool] = get_rewrite_tools()
+    tool_map = _get_tool_map(tools)
+
+    llm = get_local_chat_model()
+    llm_with_tools = llm.bind_tools(tools)
+
+    # 3) First model call (decide whether to use tools)
+    ai_msg: AIMessage = llm_with_tools.invoke(messages)
+    raw_first = ai_msg.content or ""
+
+    # If the model does not request any tools, just return its answer
+    if not getattr(ai_msg, "tool_calls", None):
+        final_text = raw_first.strip()
+        return final_text, raw_first, []
+
+    # 4) Execute any requested tools
+    messages.append(ai_msg)
+    tool_messages: List[ToolMessage] = []
+
+    for tool_call in ai_msg.tool_calls:
+        tool_name = tool_call.get("name")
+        args = tool_call.get("args", {})
+        call_id = tool_call.get("id") or ""
+
+        tool = tool_map.get(tool_name)
+        if tool is None:
+            tool_output = f"Tool '{tool_name}' is not available."
+        else:
+            # LangChain tools usually implement .invoke()
+            try:
+                tool_output = tool.invoke(args)
+            except Exception as e:
+                tool_output = f"Tool '{tool_name}' failed with error: {e}"
+
+        tool_msg = ToolMessage(
+            content=str(tool_output),
+            tool_call_id=call_id,
+        )
+        tool_messages.append(tool_msg)
+
+    messages.extend(tool_messages)
+
+    # 5) Second model call: let the LLM see tool results and answer
+    final_ai: AIMessage = llm_with_tools.invoke(messages)
+    final_text = (final_ai.content or "").strip()
+    raw_second = final_ai.content or ""
+
+    audit: list = []  # reserved for tool call logs if you want later
+
+    return final_text, raw_second, audit

core_logic/chat_chain.py

@@ -0,0 +1,170 @@
+"""
+LangChain-based chat helper for copy generation.
+
+We use:
+- PromptTemplate from langchain_core
+- ChatHuggingFace model from llm_config
+- Simple chat history from the Gradio Chatbot (list of [user, assistant] pairs)
+
+We DO NOT use SystemMessage, because the current model's chat template
+does not support a "system" role. Instead, we fold all instructions and
+campaign context into a single HumanMessage prompt, including platform
+style guidelines (Phase 3).
+"""
+
+from typing import List, Tuple
+
+from langchain_core.prompts import PromptTemplate
+from langchain_core.messages import HumanMessage
+
+from core_logic.llm_config import get_local_chat_model
+from .copy_pipeline import CopyRequest
+from helpers.platform_rules import (
+    PLATFORM_RULES,
+    DEFAULT_PLATFORM_NAME,
+    PlatformConfig,
+    get_platform_style,
+)
+from helpers.validators import validate_and_edit
+
+
+def _get_platform_config(name: str) -> PlatformConfig:
+    if name in PLATFORM_RULES:
+        return PLATFORM_RULES[name]
+    return PLATFORM_RULES[DEFAULT_PLATFORM_NAME]
+
+
+def build_chat_prompt_template() -> PromptTemplate:
+    """
+    Template takes:
+    - brand, product, audience, goal, platform, tone, cta_style, extra_context
+    - char_cap
+    - style_voice, style_emoji_guideline, style_hashtag_guideline, style_length_guideline
+    - history (chat transcript as text)
+    - input (latest user message)
+    """
+    template = """
+You are an expert social media marketer.
+You help refine and iterate on social media posts for {platform}.
+
+Campaign context:
+- Brand: {brand}
+- Product/Offer: {product}
+- Target audience: {audience}
+- Campaign goal: {goal}
+- Tone requested by user: {tone}
+- Call-to-action style: {cta_style}
+- Extra context from the user: {extra_context}
+
+Platform style guidelines for {platform}:
+- Voice and personality: {style_voice}
+- Emojis: {style_emoji_guideline}
+- Hashtags: {style_hashtag_guideline}
+- Length: {style_length_guideline}
+- Character limit: approximately {char_cap} characters.
+
+Here is the conversation so far between you and the user
+about this campaign:
+
+{history}
+
+Now the user says:
+{input}
+
+Your task:
+- Follow the platform style guidelines and tone.
+- Respect the character limit as much as reasonably possible.
+- If the user asks to edit or adapt an existing post, transform it accordingly.
+- Do NOT include explanations, analysis, or labels in your answer.
+
+Respond with ONLY the post text or edited post text
+the user asked for. Do not add any extra commentary.
+"""
+    return PromptTemplate(
+        input_variables=[
+            "brand",
+            "product",
+            "audience",
+            "goal",
+            "platform",
+            "tone",
+            "cta_style",
+            "extra_context",
+            "char_cap",
+            "style_voice",
+            "style_emoji_guideline",
+            "style_hashtag_guideline",
+            "style_length_guideline",
+            "history",
+            "input",
+        ],
+        template=template.strip(),
+    )
+
+
+def _format_history(history_pairs: List[Tuple[str, str]]) -> str:
+    """
+    Convert list of (user, assistant) messages into a simple text transcript.
+    """
+    if not history_pairs:
+        return "(No previous conversation yet.)"
+
+    lines = []
+    for u, a in history_pairs:
+        if u:
+            lines.append(f"User: {u}")
+        if a:
+            lines.append(f"Assistant: {a}")
+    return "\n".join(lines)
+
+
+def chat_turn(
+    req: CopyRequest,
+    user_message: str,
+    history_pairs: List[Tuple[str, str]],
+):
+    """
+    Run one chat turn:
+
+    - Uses LangChain PromptTemplate + ChatHuggingFace (via get_local_chat_model)
+    - Uses history_pairs (from Gradio Chatbot) as conversation history
+    - Applies platform style guidelines (Phase 3)
+    - Applies validators (banned terms, char caps, etc.)
+    - Returns final_text, raw_text, audit
+    """
+    platform_cfg = _get_platform_config(req.platform_name)
+    style = get_platform_style(req.platform_name)
+
+    prompt_tmpl = build_chat_prompt_template()
+    history_text = _format_history(history_pairs)
+
+    # Build the full prompt string with context + style + history + latest user message
+    prompt_str = prompt_tmpl.format(
+        brand=req.brand or "",
+        product=req.product or "",
+        audience=req.audience or "",
+        goal=req.goal or "",
+        platform=style.get("name", req.platform_name or "Unknown platform"),
+        tone=req.tone or "friendly",
+        cta_style=req.cta_style or "soft",
+        extra_context=req.extra_context or "",
+        char_cap=str(platform_cfg.cap)
+        if hasattr(platform_cfg, "cap")
+        else str(getattr(platform_cfg, "char_cap", 280)),
+        style_voice=style.get("voice", ""),
+        style_emoji_guideline=style.get("emoji_guideline", ""),
+        style_hashtag_guideline=style.get("hashtag_guideline", ""),
+        style_length_guideline=style.get("length_guideline", ""),
+        history=history_text,
+        input=user_message,
+    )
+
+    # Call the ChatHuggingFace model with a single HumanMessage
+    chat_model = get_local_chat_model()
+    ai_msg = chat_model.invoke([HumanMessage(content=prompt_str)])
+    raw_text = ai_msg.content
+
+    # Apply your existing validators (banned phrases, length, etc.)
+    final_text, audit = validate_and_edit(raw_text, platform_cfg)
+
+    return final_text, raw_text, audit

core_logic/copy_pipeline.py

@@ -0,0 +1,114 @@
+"""
+Copy generation pipeline for Marketeer.
+
+This wraps the low-level LLM client and the helper utilities
+into a single `generate_copy` function that other parts of
+the app (like the Gradio UI) can call.
+
+High level:
+- Build a structured prompt using the provided context.
+- Call the LLM to generate text.
+- Run validators (banned terms, length caps, etc.).
+- Return raw text, final text, and an audit log.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Any, List, Tuple
+
+from .llm_client import generate_text
+from helpers.platform_rules import PLATFORM_RULES, DEFAULT_PLATFORM_NAME, PlatformConfig
+from helpers.validators import validate_and_edit
+
+
+@dataclass
+class CopyRequest:
+    brand: str
+    product: str
+    audience: str
+    goal: str
+    platform_name: str
+    tone: str
+    cta_style: str
+    extra_context: str = ""
+
+
+@dataclass
+class CopyResponse:
+    platform: str
+    raw: str
+    final: str
+    cap: int
+    audit: List[Dict[str, Any]]
+
+
+def _get_platform_config(name: str) -> PlatformConfig:
+    """Return a known PlatformConfig or default to Instagram."""
+    if name in PLATFORM_RULES:
+        return PLATFORM_RULES[name]
+    # allow simple aliases like "X" or "Twitter/X" later if you want
+    return PLATFORM_RULES[DEFAULT_PLATFORM_NAME]
+
+
+def _build_prompt(req: CopyRequest, platform: PlatformConfig) -> str:
+    """
+    Build a reasonably structured prompt for the LLM.
+
+    This is intentionally simple for now; you can make it
+    fancier later (add examples, formatting, etc.).
+    """
+
+    lines = [
+        f"You are an expert social media marketer.",
+        f"Write a single post for {platform.name}.",
+        "",
+        f"Brand: {req.brand}",
+        f"Product/Offer: {req.product}",
+        f"Target audience: {req.audience}",
+        f"Campaign goal: {req.goal}",
+        f"Tone: {req.tone}",
+        f"Call-to-action style: {req.cta_style}",
+    ]
+
+    if req.extra_context.strip():
+        lines.append(f"Extra context: {req.extra_context.strip()}")
+
+    lines.append("")
+    lines.append(
+        f"Keep the copy within approximately {platform.char_cap} characters, "
+        f"and make it engaging but natural."
+    )
+    lines.append("Do not include explanations, just the post text itself.")
+
+    return "\n".join(lines)
+
+
+def generate_copy(req: CopyRequest) -> CopyResponse:
+    """
+    Main entry point for marketing copy generation.
+
+    1) Resolve platform config.
+    2) Build a prompt.
+    3) Call the LLM.
+    4) Run validators and collect audit.
+    5) Return structured response.
+    """
+    platform = _get_platform_config(req.platform_name)
+
+    prompt = _build_prompt(req, platform)
+
+    raw_text = generate_text(
+        prompt=prompt,
+        max_new_tokens=256,
+        temperature=0.8,
+        top_p=0.9,
+    )
+
+    final_text, audit = validate_and_edit(raw_text, platform)
+
+    return CopyResponse(
+        platform=platform.name,
+        raw=raw_text,
+        final=final_text,
+        cap=platform.char_cap,
+        audit=audit,
+    )

core_logic/langchain_llm.py

@@ -0,0 +1,45 @@
+"""
+LangChain-compatible LLM wrapper around our existing generate_text().
+
+This lets us use LangChain chains, prompts, and memory
+without changing the underlying HF model logic.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from langchain_core.language_models.llms import LLM
+
+from .llm_client import generate_text
+
+
+class MarketeerLLM(LLM):
+    """
+    Minimal LangChain LLM that just calls our generate_text() helper.
+    """
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        # You can pass temp/top_p via kwargs if you want, or keep fixed config.
+        text = generate_text(
+            prompt=prompt,
+            max_new_tokens=kwargs.get("max_new_tokens", 256),
+            temperature=kwargs.get("temperature", 0.8),
+            top_p=kwargs.get("top_p", 0.9),
+        )
+
+        # Apply stop tokens if provided
+        if stop:
+            for s in stop:
+                if s in text:
+                    text = text.split(s)[0]
+                    break
+
+        return text.strip()
+
+    @property
+    def _llm_type(self) -> str:
+        return "marketeer_llm"

core_logic/llm_client.py

@@ -0,0 +1,120 @@
+"""
+LLM client for Marketeer.
+
+This module exposes a single function:
+
+    generate_text(prompt: str, max_new_tokens: int = 256, temperature: float = 0.8, top_p: float = 0.9) -> str
+
+Internally it:
+- Loads the tokenizer & model once.
+- Uses MODEL_ID from environment (or a sensible default).
+- Lets `device_map="auto"` handle GPU/CPU placement when CUDA is available.
+"""
+
+import os
+from typing import Optional
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+
+# ----- Configuration -----
+
+DEFAULT_MODEL_ID = "google/gemma-2-2b-it"
+_MODEL_ID = os.getenv("MODEL_ID", DEFAULT_MODEL_ID)
+
+_tokenizer: Optional[AutoTokenizer] = None
+_model: Optional[AutoModelForCausalLM] = None
+
+
+def _load_model_if_needed():
+    """Lazy-load tokenizer and model into global variables."""
+    global _tokenizer, _model
+
+    if _tokenizer is not None and _model is not None:
+        return
+
+    has_cuda = torch.cuda.is_available()
+
+    # bfloat16/float16 on GPU, float32 on CPU
+    if has_cuda:
+        dtype = torch.bfloat16
+        device_map = "auto"   # let accelerate handle offload across GPU/CPU
+    else:
+        dtype = torch.float32
+        device_map = None
+
+    _tokenizer = AutoTokenizer.from_pretrained(_MODEL_ID)
+
+    _model = AutoModelForCausalLM.from_pretrained(
+        _MODEL_ID,
+        dtype=dtype,          # use dtype instead of deprecated torch_dtype
+        device_map=device_map,
+    )
+
+    # Ensure pad token exists (some causal models don't define it)
+    if _tokenizer.pad_token is None:
+        _tokenizer.pad_token = _tokenizer.eos_token
+
+    _model.eval()   # IMPORTANT: no _model.to(...) here
+
+
+def generate_text(
+    prompt: str,
+    max_new_tokens: int = 256,
+    temperature: float = 0.8,
+    top_p: float = 0.9,
+) -> str:
+    """
+    Generate text from the model given a plain prompt.
+
+    Args:
+        prompt: The input text prompt.
+        max_new_tokens: Maximum number of new tokens to generate.
+        temperature: Sampling temperature (>1 = more random, <1 = more focused).
+        top_p: Nucleus sampling probability mass.
+
+    Returns:
+        The generated text (prompt excluded where possible).
+    """
+    if not isinstance(prompt, str):
+        raise TypeError("prompt must be a string")
+
+    cleaned_prompt = prompt.strip()
+    if not cleaned_prompt:
+        raise ValueError("prompt is empty after stripping whitespace")
+
+    _load_model_if_needed()
+    assert _tokenizer is not None
+    assert _model is not None
+
+    # DO NOT .to(device) here; accelerate handles device placement for us
+    inputs = _tokenizer(
+        cleaned_prompt,
+        return_tensors="pt",
+    )
+
+    with torch.no_grad():
+        output_ids = _model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            do_sample=True,
+            temperature=temperature,
+            top_p=top_p,
+            pad_token_id=_tokenizer.pad_token_id,
+            eos_token_id=_tokenizer.eos_token_id,
+        )
+
+    full_text = _tokenizer.decode(
+        output_ids[0],
+        skip_special_tokens=True,
+        clean_up_tokenization_spaces=True,
+    )
+
+    # Strip echoed prompt if present
+    if full_text.startswith(cleaned_prompt):
+        generated = full_text[len(cleaned_prompt):].lstrip()
+    else:
+        generated = full_text
+
+    return generated.strip()

core_logic/llm_config.py

@@ -0,0 +1,50 @@
+"""
+LLM configuration for Marketeer.
+
+This module exposes helpers to get a LangChain ChatHuggingFace model,
+backed by a local Hugging Face pipeline (for development).
+
+Later, we can add a get_endpoint_chat_model() for HF Inference API.
+"""
+
+from functools import lru_cache
+
+from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
+from transformers import BitsAndBytesConfig
+
+
+MODEL_ID = "google/gemma-2-2b-it"  # <-- change if you're using a different repo
+
+
+@lru_cache(maxsize=1)
+def get_local_chat_model() -> ChatHuggingFace:
+    """
+    Return a singleton ChatHuggingFace model running locally via transformers pipeline.
+
+    Uses 4-bit quantization to fit comfortably on a 6GB RTX 3060.
+    """
+    quant_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype="float16",
+        bnb_4bit_use_double_quant=True,
+    )
+
+    # HuggingFacePipeline wraps a transformers.pipeline under the hood
+    base_llm = HuggingFacePipeline.from_model_id(
+        model_id=MODEL_ID,
+        task="text-generation",
+        pipeline_kwargs=dict(
+            max_new_tokens=256,
+            do_sample=True,
+            temperature=0.8,
+            top_p=0.9,
+            return_full_text=False,  # we only want the generated continuation
+        ),
+        model_kwargs={
+            "quantization_config": quant_config,
+        },
+    )
+
+    chat_model = ChatHuggingFace(llm=base_llm)
+    return chat_model

core_logic/rewrite_tools.py

@@ -0,0 +1,40 @@
+from typing import List
+from langchain_core.tools import tool
+from langchain_core.tools import BaseTool
+
+
+@tool
+def shorten_copy(text: str, max_words: int = 40) -> str:
+    """Shorten the given marketing copy while preserving core meaning and CTA."""
+    # simple baseline implementation; the LLM will often rewrite again
+    words = text.split()
+    if len(words) <= max_words:
+        return text
+    return " ".join(words[:max_words]) + "..."
+
+
+@tool
+def remove_emojis(text: str) -> str:
+    """Remove emojis and overly playful styling from the copy."""
+    # naive implementation – works fine as a starting point
+    import re
+
+    emoji_pattern = re.compile(
+        "["
+        "\U0001F600-\U0001F64F"
+        "\U0001F300-\U0001F5FF"
+        "\U0001F680-\U0001F6FF"
+        "\U0001F1E0-\U0001F1FF"
+        "]+",
+        flags=re.UNICODE,
+    )
+    no_emoji = emoji_pattern.sub("", text)
+    return " ".join(no_emoji.split())
+
+
+def get_rewrite_tools() -> List[BaseTool]:
+    """
+    Return the list of tools the agent can use.
+    Add tone_shift, expand, etc. here over time.
+    """
+    return [shorten_copy, remove_emojis]

core_logic/video_pipeline.py

@@ -0,0 +1,271 @@
+# core_logic/video_pipeline.py
+
+"""
+Video script generation pipeline for Marketeer.
+
+Phase 5: Use a structured Pydantic schema (VideoScriptResponse)
+while keeping the external behaviour compatible with the existing UI.
+
+High-level flow:
+1. Build a simple beat plan based on blueprint + duration.
+2. For each beat, ask the LLM for a JSON block with:
+   - voiceover
+   - on_screen
+   - shots
+   - broll
+   - captions
+3. Parse JSON into VideoBeat models.
+4. Return a VideoScriptResponse (plan + warnings).
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+from core_logic.llm_client import generate_text
+from core_logic.video_schema import (
+    VideoBeat,
+    VideoPlan,
+    VideoScriptResponse,
+)
+
+
+# --------------------------------------------------------------------
+# Request object coming from UI
+# --------------------------------------------------------------------
+
+
+@dataclass
+class VideoRequest:
+    brand: str
+    product: str
+    audience: str
+    goal: str
+    blueprint_name: str
+    duration_sec: int
+    platform_name: str
+    style: str
+    extra_context: str = ""
+
+
+# --------------------------------------------------------------------
+# Internal helpers: plan building & prompting
+# --------------------------------------------------------------------
+
+
+def _build_basic_plan(req: VideoRequest) -> VideoPlan:
+    """
+    Build a very simple beat plan based on blueprint and duration.
+
+    Right now we keep this deterministic and lightweight.
+    Later, you can make this itself LLM-driven if you want.
+    """
+    total = max(req.duration_sec, 5)
+    blueprint = (req.blueprint_name or "short_ad").lower()
+
+    if blueprint == "short_ad":
+        # 3-beat: Hook -> Product -> CTA
+        beats_meta = [
+            ("Hook / Problem", "Hook viewer, show the pain or context.", 0.0, total * 0.33),
+            ("Product Moment", "Show product solving the problem.", total * 0.33, total * 0.66),
+            ("CTA / Finish", "Wrap up and clear CTA.", total * 0.66, total),
+        ]
+    elif blueprint == "ugc_review":
+        # 4-beat: Intro -> Problem -> Experience -> Recommendation
+        beats_meta = [
+            ("Intro / Self", "Introduce the speaker as a real user.", 0.0, total * 0.25),
+            ("Problem", "Describe the problem or frustration.", total * 0.25, total * 0.5),
+            ("Experience", "Explain how using the product felt / helped.", total * 0.5, total * 0.75),
+            ("Recommendation", "Recommend the product and invite viewer to try.", total * 0.75, total),
+        ]
+    else:  # how_to or fallback
+        # 4-beat: Hook -> Step(s) -> Result -> CTA
+        beats_meta = [
+            ("Hook / Promise", "Hook viewer and promise what they will learn.", 0.0, total * 0.25),
+            ("Step-by-step (1)", "Show the first main step.", total * 0.25, total * 0.5),
+            ("Step-by-step (2)", "Show the second main step or refinement.", total * 0.5, total * 0.75),
+            ("Result / CTA", "Show final outcome and clear CTA.", total * 0.75, total),
+        ]
+
+    beats: List[VideoBeat] = []
+    for idx, (title, goal, t_start, t_end) in enumerate(beats_meta):
+        beats.append(
+            VideoBeat(
+                beat_index=idx,
+                title=title,
+                goal=goal,
+                t_start=float(round(t_start, 2)),
+                t_end=float(round(t_end, 2)),
+                voiceover="",    # to be filled by LLM
+                on_screen="",    # to be filled by LLM
+                shots=[],
+                broll=[],
+                captions=[],
+            )
+        )
+
+    plan = VideoPlan(
+        blueprint_name=req.blueprint_name,
+        duration_sec=total,
+        platform_name=req.platform_name,
+        style=req.style,
+        beats=beats,
+    )
+    return plan
+
+
+def _build_beat_prompt(req: VideoRequest, plan: VideoPlan, beat: VideoBeat) -> str:
+    """
+    Build an instruction to generate **one beat** as a JSON object.
+    """
+    return f"""
+You are helping create a short-form marketing video script.
+
+Brand: {req.brand}
+Product: {req.product}
+Audience: {req.audience}
+Campaign goal: {req.goal}
+Platform: {req.platform_name}
+Overall style: {req.style}
+Extra context: {req.extra_context}
+
+We are currently working on one beat of the video:
+
+- Blueprint: {plan.blueprint_name}
+- Beat index: {beat.beat_index}
+- Beat title: {beat.title}
+- Beat goal: {beat.goal}
+- Start time: {beat.t_start} seconds
+- End time: {beat.t_end} seconds
+
+Return **only** a JSON object (no markdown, no backticks) with this shape:
+
+{{
+  "voiceover": "string, the spoken line(s) for this beat",
+  "on_screen": "string, short text shown on screen",
+  "shots": ["list of camera shot ideas, strings"],
+  "broll": ["optional list of B-roll ideas, strings"],
+  "captions": ["optional list of caption lines, strings"]
+}}
+
+The voiceover should match the platform and style, and help achieve the beat goal.
+Keep it concise but vivid.
+""".strip()
+
+
+def _extract_json_from_response(raw: str) -> Dict[str, Any]:
+    """
+    Try to extract a JSON object from the LLM response.
+
+    If it's already plain JSON, parse that.
+    If it's inside a markdown ```json block, extract the inner part.
+    Raises ValueError if parsing fails.
+    """
+    text = raw.strip()
+
+    # Common case: LLM wraps in ```json ... ```
+    if "```" in text:
+        # Take the content between the first pair of ``` blocks
+        parts = text.split("```")
+        # Expected pattern: ["", "json\\n{...}", ""]
+        if len(parts) >= 3:
+            candidate = parts[1]
+            # Strip a leading "json" or "JSON" line
+            candidate = candidate.lstrip().split("\n", 1)
+            if len(candidate) == 2 and candidate[0].lower() in ("json", "json:"):
+                text = candidate[1].strip()
+            else:
+                text = "\n".join(candidate).strip()
+
+    return json.loads(text)
+
+
+# --------------------------------------------------------------------
+# Public API: generate_video_script
+# --------------------------------------------------------------------
+
+
+def generate_video_script(
+    req: VideoRequest,
+    debug_first: bool = False,
+) -> VideoScriptResponse:
+    """
+    Main entry point used by the UI.
+
+    Generates a structured VideoScriptResponse (plan + warnings). The
+    UI can still access:
+        resp.plan
+        resp.beats   (alias for resp.plan.beats)
+        resp.warnings
+    """
+    plan = _build_basic_plan(req)
+    warnings: List[str] = []
+    beats_out: List[VideoBeat] = []
+
+    for idx, beat in enumerate(plan.beats):
+        prompt = _build_beat_prompt(req, plan, beat)
+
+        raw = generate_text(
+            prompt=prompt,
+            max_new_tokens=256,
+            temperature=0.7,
+            top_p=0.9,
+        )
+
+        if debug_first and idx == 0:
+            print("=== RAW FIRST BEAT RESPONSE ===")
+            print(raw)
+            print("=" * 32)
+
+        try:
+            data = _extract_json_from_response(raw)
+            # Merge structured info into the beat
+            beat_updated = VideoBeat(
+                beat_index=beat.beat_index,
+                title=beat.title,
+                goal=beat.goal,
+                t_start=beat.t_start,
+                t_end=beat.t_end,
+                voiceover=str(data.get("voiceover", "")).strip(),
+                on_screen=str(data.get("on_screen", "")).strip(),
+                shots=list(data.get("shots", []) or []),
+                broll=list(data.get("broll", []) or []),
+                captions=list(data.get("captions", []) or []),
+            )
+            beats_out.append(beat_updated)
+        except Exception as e:
+            warnings.append(
+                f"Beat {beat.beat_index}: failed to parse JSON from model response ({e})."
+            )
+            # Fallback: keep the original beat with generic placeholders
+            beats_out.append(
+                VideoBeat(
+                    beat_index=beat.beat_index,
+                    title=beat.title,
+                    goal=beat.goal,
+                    t_start=beat.t_start,
+                    t_end=beat.t_end,
+                    voiceover="",
+                    on_screen="",
+                    shots=[],
+                    broll=[],
+                    captions=[],
+                )
+            )
+
+    # Construct final structured response
+    final_plan = VideoPlan(
+        blueprint_name=plan.blueprint_name,
+        duration_sec=plan.duration_sec,
+        platform_name=plan.platform_name,
+        style=plan.style,
+        beats=beats_out,
+    )
+
+    resp = VideoScriptResponse(
+        plan=final_plan,
+        warnings=warnings,
+    )
+    return resp

core_logic/video_schema.py

@@ -0,0 +1,94 @@
+# core_logic/video_schema.py
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class VideoBeat(BaseModel):
+    """Single beat in the short-form video script."""
+    beat_index: int = Field(
+        ...,
+        description="Zero-based index of this beat in the sequence.",
+    )
+    title: str = Field(
+        ...,
+        description="Short title / label for this beat (e.g., 'Hook', 'Product Close-up').",
+    )
+    goal: str = Field(
+        ...,
+        description="What this beat is trying to achieve (hook, social proof, CTA, etc.).",
+    )
+    t_start: float = Field(
+        ...,
+        description="Approximate start time in seconds from the beginning of the video.",
+    )
+    t_end: float = Field(
+        ...,
+        description="Approximate end time in seconds from the beginning of the video.",
+    )
+    voiceover: str = Field(
+        ...,
+        description="Suggested voiceover line(s) for this beat.",
+    )
+    on_screen: str = Field(
+        ...,
+        description="Short on-screen text / caption for this beat.",
+    )
+    shots: List[str] = Field(
+        default_factory=list,
+        description="List of camera shots / visuals in this beat.",
+    )
+    broll: List[str] = Field(
+        default_factory=list,
+        description="Optional B-roll ideas for this beat.",
+    )
+    captions: List[str] = Field(
+        default_factory=list,
+        description="Suggested caption lines or overlays.",
+    )
+
+
+class VideoPlan(BaseModel):
+    """High-level plan for the entire video."""
+    blueprint_name: str = Field(
+        ...,
+        description="Name of the blueprint used (e.g., 'short_ad', 'ugc_review', 'how_to').",
+    )
+    duration_sec: int = Field(
+        ...,
+        description="Total target duration of the video in seconds.",
+    )
+    platform_name: str = Field(
+        ...,
+        description="Target platform label (e.g., 'Instagram Reels', 'YouTube Shorts').",
+    )
+    style: str = Field(
+        ...,
+        description="Overall style (e.g., 'warm and energetic').",
+    )
+    beats: List[VideoBeat] = Field(
+        default_factory=list,
+        description="List of beats that make up this video.",
+    )
+
+
+class VideoScriptResponse(BaseModel):
+    """
+    Full structured response used by the app and UI.
+    """
+    plan: VideoPlan = Field(
+        ...,
+        description="High-level plan metadata and beat list.",
+    )
+    warnings: List[str] = Field(
+        default_factory=list,
+        description="Any warnings about parsing, timing, or beat structure.",
+    )
+
+    @property
+    def beats(self) -> List[VideoBeat]:
+        """
+        Backwards-compatible alias so older code can still do resp.beats.
+        Internally, beats live on resp.plan.beats.
+        """
+        return self.plan.beats

helpers/blueprints.py

@@ -0,0 +1,161 @@
+"""
+Video blueprints for Marketeer.
+
+These define high-level structures (beats) for different
+short-form video types like short ads, UGC reviews, and how-tos.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict
+
+
+@dataclass
+class BeatTemplate:
+    id: str
+    title: str
+    goal: str
+    weight: float  # relative share of total duration (sum of weights ≈ 1.0)
+
+
+@dataclass
+class Blueprint:
+    name: str
+    description: str
+    beats: List[BeatTemplate]
+
+
+def _short_ad() -> Blueprint:
+    beats = [
+        BeatTemplate(
+            id="hook",
+            title="Hook",
+            goal="Grab attention in the first second and stop the scroll.",
+            weight=0.2,
+        ),
+        BeatTemplate(
+            id="problem",
+            title="Problem",
+            goal="Show the pain point the viewer feels right now.",
+            weight=0.2,
+        ),
+        BeatTemplate(
+            id="solution",
+            title="Solution",
+            goal="Introduce the product as the clear solution.",
+            weight=0.3,
+        ),
+        BeatTemplate(
+            id="proof",
+            title="Proof",
+            goal="Show quick proof: results, social proof, or credibility.",
+            weight=0.2,
+        ),
+        BeatTemplate(
+            id="cta",
+            title="Call to Action",
+            goal="Give a clear, simple next step.",
+            weight=0.1,
+        ),
+    ]
+    return Blueprint(
+        name="short_ad",
+        description="Punchy short ad for Reels/Shorts/TikTok with strong hook and CTA.",
+        beats=beats,
+    )
+
+
+def _ugc_review() -> Blueprint:
+    beats = [
+        BeatTemplate(
+            id="intro",
+            title="UGC Intro",
+            goal="Introduce yourself quickly and mention the product.",
+            weight=0.2,
+        ),
+        BeatTemplate(
+            id="before",
+            title="Before",
+            goal="Describe life before using the product (the struggle).",
+            weight=0.25,
+        ),
+        BeatTemplate(
+            id="experience",
+            title="Experience",
+            goal="Describe what it was like actually trying the product.",
+            weight=0.3,
+        ),
+        BeatTemplate(
+            id="after",
+            title="After",
+            goal="Describe the positive results / outcome.",
+            weight=0.15,
+        ),
+        BeatTemplate(
+            id="recommend",
+            title="Recommendation & CTA",
+            goal="Recommend the product and give a simple prompt to act.",
+            weight=0.1,
+        ),
+    ]
+    return Blueprint(
+        name="ugc_review",
+        description="User-generated style review with before/after flow.",
+        beats=beats,
+    )
+
+
+def _how_to() -> Blueprint:
+    beats = [
+        BeatTemplate(
+            id="intro",
+            title="Intro",
+            goal="Tell viewers what they will learn and why it matters.",
+            weight=0.2,
+        ),
+        BeatTemplate(
+            id="step1",
+            title="Step 1",
+            goal="Explain and demo the first key step.",
+            weight=0.25,
+        ),
+        BeatTemplate(
+            id="step2",
+            title="Step 2",
+            goal="Explain and demo the second key step.",
+            weight=0.25,
+        ),
+        BeatTemplate(
+            id="step3",
+            title="Step 3",
+            goal="Optional third step or bonus tip.",
+            weight=0.15,
+        ),
+        BeatTemplate(
+            id="wrap",
+            title="Recap & CTA",
+            goal="Recap key points and suggest the next action.",
+            weight=0.15,
+        ),
+    ]
+    return Blueprint(
+        name="how_to",
+        description="Educational explainer with clear steps and recap.",
+        beats=beats,
+    )
+
+
+BLUEPRINTS: Dict[str, Blueprint] = {
+    "short_ad": _short_ad(),
+    "ugc_review": _ugc_review(),
+    "how_to": _how_to(),
+}
+
+
+DEFAULT_BLUEPRINT = "short_ad"
+
+
+def get_blueprint(name: str) -> Blueprint:
+    """Return a known blueprint or the default one."""
+    if name in BLUEPRINTS:
+        return BLUEPRINTS[name]
+    return BLUEPRINTS[DEFAULT_BLUEPRINT]

helpers/json_utils.py

@@ -0,0 +1,72 @@
+"""
+JSON extraction and fallback utilities for video scripting.
+
+We try to pull a JSON object out of a model's response, and if
+that fails, we return None so the caller can use a fallback block.
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+
+def extract_json_block(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Try to parse a JSON object from the given text.
+
+    Strategy:
+    1. Try json.loads on the whole string.
+    2. If that fails, look for the first '{' and last '}' and parse that slice.
+    3. If still failing, return None.
+    """
+    text = text.strip()
+    if not text:
+        return None
+
+    # 1) raw attempt
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except Exception:
+        pass
+
+    # 2) substring between first '{' and last '}'
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        return None
+
+    candidate = text[start : end + 1]
+    try:
+        obj = json.loads(candidate)
+        if isinstance(obj, dict):
+            return obj
+    except Exception:
+        return None
+
+    return None
+
+
+def fallback_block(beat_title: str) -> Dict[str, Any]:
+    """
+    Provide a safe default block when JSON parsing fails.
+
+    The strings here are intentionally generic; the model's real
+    responses should normally override these when JSON is valid.
+    """
+    return {
+        "voiceover": f"Introduce the idea for the '{beat_title}' part in a clear, simple line.",
+        "on_screen": f"{beat_title} on screen.",
+        "shots": [
+            f"Shot of the main subject related to {beat_title.lower()}.",
+            "Close-up shot for extra detail.",
+            "Wide shot to show context or environment.",
+        ],
+        "broll": [
+            "Supporting b-roll that reinforces the message.",
+            "Cutaway showing product or user in action.",
+        ],
+        "captions": [
+            f"{beat_title} caption text.",
+        ],
+    }

helpers/platform_rules.py

@@ -0,0 +1,149 @@
+from dataclasses import dataclass
+from typing import Dict
+
+
+# --- Core platform config (caps, hashtags, emojis) ---
+
+
+@dataclass
+class PlatformConfig:
+    """
+    Basic platform constraints used by the validator and pipelines.
+    """
+    name: str
+    char_cap: int
+    hashtags_max: int
+    emoji_max: int
+
+    @property
+    def cap(self) -> int:
+        """
+        Backwards-compatible alias for char_cap.
+        Some older code might reference .cap instead of .char_cap.
+        """
+        return self.char_cap
+
+
+# Character caps and simple rules per platform.
+PLATFORM_RULES: Dict[str, PlatformConfig] = {
+    "Instagram": PlatformConfig(
+        name="Instagram",
+        char_cap=2200,
+        hashtags_max=5,
+        emoji_max=5,
+    ),
+    "Facebook": PlatformConfig(
+        name="Facebook",
+        char_cap=125,
+        hashtags_max=0,
+        emoji_max=1,
+    ),
+    "LinkedIn": PlatformConfig(
+        name="LinkedIn",
+        char_cap=3000,
+        hashtags_max=3,
+        emoji_max=2,
+    ),
+    "Twitter": PlatformConfig(
+        name="Twitter",
+        char_cap=280,
+        hashtags_max=2,
+        emoji_max=2,
+    ),
+}
+
+DEFAULT_PLATFORM_NAME: str = "Instagram"
+
+
+# --- Banned phrase map (for safer language) ---
+
+
+# Regex patterns mapped to replacement phrases.
+# The validator will use this to make copy less spammy / risky.
+BANNED_MAP: Dict[str, str] = {
+    r"\bguarantee(d|s)?\b": "aim to",
+    r"\bno[-\s]?risk\b": "low risk",
+    # Add more patterns as needed
+}
+
+
+# --- Platform style profiles (Phase 3) ---
+
+
+# Each entry describes how copy should "feel" on that platform.
+# These are used at prompt level in chat_chain so the LLM
+# clearly understands the expectations per platform.
+PLATFORM_STYLES: Dict[str, Dict] = {
+    "Instagram": {
+        "name": "Instagram",
+        "voice": (
+            "fun, casual, and energetic. Speak like a friendly social media manager "
+            "talking to followers."
+        ),
+        "emoji_guideline": (
+            "Emojis are welcome. Use them to enhance the energy of the post, "
+            "but avoid clutter."
+        ),
+        "hashtag_guideline": (
+            "Use 3–5 relevant hashtags at the end of the post. "
+            "Hashtags should be short, readable, and on-topic."
+        ),
+        "length_guideline": "Short to medium length caption is ideal.",
+    },
+    "Facebook": {
+        "name": "Facebook",
+        "voice": (
+            "friendly and conversational, but slightly more explanatory than Instagram."
+        ),
+        "emoji_guideline": (
+            "Emojis are allowed, but use them sparingly for emphasis only."
+        ),
+        "hashtag_guideline": (
+            "One or two hashtags are okay, but they are optional. "
+            "Focus more on clear, readable text."
+        ),
+        "length_guideline": "Short to medium length post with a clear main message.",
+    },
+    "LinkedIn": {
+        "name": "LinkedIn",
+        "voice": (
+            "professional, clear, and value-focused. "
+            "Write like a marketer speaking to working professionals."
+        ),
+        "emoji_guideline": (
+            "Avoid or minimize emojis. If used at all, keep them professional and sparse."
+        ),
+        "hashtag_guideline": (
+            "1–3 relevant, professional hashtags are acceptable at the end. "
+            "Do not overuse hashtags."
+        ),
+        "length_guideline": (
+            "Short to medium length update. Prioritize clarity and professionalism."
+        ),
+    },
+    "Twitter": {
+        "name": "Twitter",
+        "voice": (
+            "short, punchy, and attention-grabbing. "
+            "Get to the point quickly."
+        ),
+        "emoji_guideline": (
+            "Emojis are fine but keep them minimal and highly relevant."
+        ),
+        "hashtag_guideline": (
+            "1–2 strong, relevant hashtags max. Avoid hashtag spam."
+        ),
+        "length_guideline": "Very concise. Every word should earn its place.",
+    },
+}
+
+DEFAULT_PLATFORM_STYLE: Dict = PLATFORM_STYLES.get("Instagram")
+
+
+def get_platform_style(name: str) -> Dict:
+    """
+    Return a style profile dict for a given platform name.
+
+    If the platform is unknown, fall back to DEFAULT_PLATFORM_STYLE.
+    """
+    return PLATFORM_STYLES.get(name, DEFAULT_PLATFORM_STYLE)

helpers/platform_styles.py

@@ -0,0 +1,111 @@
+"""
+Platform personality profiles for Marketeer.
+
+These capture HOW each platform prefers to communicate:
+- voice & tone
+- emoji usage
+- hashtag style
+- formatting preferences
+"""
+
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass
+class PlatformStyle:
+    name: str
+    voice: str
+    emoji_guideline: str
+    hashtag_guideline: str
+    formatting_guideline: str
+    extra_notes: str = ""
+
+
+# Core style definitions
+PLATFORM_STYLES: Dict[str, PlatformStyle] = {
+    "Instagram": PlatformStyle(
+        name="Instagram",
+        voice="Casual, energetic, playful. Focus on vibes, feelings, and moments.",
+        emoji_guideline=(
+            "Use emojis naturally to enhance mood (1–5 per post). "
+            "Avoid overloading every word with emojis."
+        ),
+        hashtag_guideline=(
+            "Use 3–5 relevant hashtags at the end of the post. "
+            "Mix branded and generic hashtags (e.g., #BrewBlissCafe, #WeekendVibes)."
+        ),
+        formatting_guideline=(
+            "Short paragraphs, line breaks for readability, occasional emphasis with ALL CAPS "
+            "or **bold style** (if supported)."
+        ),
+        extra_notes="Hook in the first line. Make it thumb-stopping.",
+    ),
+    "Facebook": PlatformStyle(
+        name="Facebook",
+        voice="Friendly and conversational, but a bit more explanatory than Instagram.",
+        emoji_guideline=(
+            "Use emojis sparingly (0–2 per post), mainly to highlight key ideas."
+        ),
+        hashtag_guideline=(
+            "Hashtags are optional. If used, limit to 1–2 relevant tags."
+        ),
+        formatting_guideline=(
+            "1–3 short paragraphs. Clear, readable, and easy to skim."
+        ),
+        extra_notes="Good place for slightly longer explanations or promotions.",
+    ),
+    "LinkedIn": PlatformStyle(
+        name="LinkedIn",
+        voice=(
+            "Professional, clear, and value-driven. Focus on benefits, outcomes, and credibility. "
+            "Write as if speaking to working professionals."
+        ),
+        emoji_guideline=(
+            "Avoid emojis in most cases. If absolutely necessary, limit to 0–1 subtle emoji."
+        ),
+        hashtag_guideline=(
+            "Use 0–3 professional hashtags at the end if needed (e.g., #Marketing, #CustomerExperience)."
+        ),
+        formatting_guideline=(
+            "Short, well-structured paragraphs. Avoid slang. No all-caps. "
+            "Sound confident and polished."
+        ),
+        extra_notes="Highlight business value, customer experience, and trust.",
+    ),
+    "Twitter": PlatformStyle(
+        name="Twitter",
+        voice="Short, punchy, and to the point. Witty if possible.",
+        emoji_guideline=(
+            "Use emojis sparingly (0–2) to add flavor, not clutter."
+        ),
+        hashtag_guideline=(
+            "Use 1–3 short hashtags. Prioritize relevance over quantity."
+        ),
+        formatting_guideline=(
+            "Single-paragraph or a short thread. Max impact in minimal characters."
+        ),
+        extra_notes="Lead with the core hook in the first few words.",
+    ),
+    # Fallback / generic style
+    "Generic": PlatformStyle(
+        name="Generic",
+        voice="Clear, friendly, and informative.",
+        emoji_guideline="Use emojis only if they genuinely add clarity or mood.",
+        hashtag_guideline="Use a small number of relevant hashtags if appropriate.",
+        formatting_guideline="Keep sentences and paragraphs easy to read.",
+        extra_notes="Adapt tone slightly based on the brand and audience.",
+    ),
+}
+
+
+DEFAULT_STYLE_NAME = "Generic"
+
+
+def get_platform_style(name: str) -> PlatformStyle:
+    """
+    Return the platform style for the given name, falling back to Generic.
+    """
+    if name in PLATFORM_STYLES:
+        return PLATFORM_STYLES[name]
+    return PLATFORM_STYLES[DEFAULT_STYLE_NAME]

helpers/validators.py

@@ -0,0 +1,88 @@
+"""
+Validation and gentle editing layer for generated copy.
+
+This module:
+- Applies banned-term replacements (e.g., "guaranteed" -> "aim to").
+- Trims text to platform character cap.
+- Returns an audit log of what changed.
+"""
+
+from typing import List, Dict, Tuple
+
+from .platform_rules import PlatformConfig
+
+
+# Soft language map: you can expand this list as you like
+BANNED_MAP = {
+    "guaranteed": "aim to",
+    "guarantee": "aim to",
+    "no risk": "low risk",
+}
+
+
+def _apply_banned_terms(text: str) -> Tuple[str, List[Dict]]:
+    """Replace banned phrases and record changes."""
+    audit: List[Dict] = []
+    cleaned = text
+
+    for bad, replacement in BANNED_MAP.items():
+        if bad.lower() in cleaned.lower():
+            before = cleaned
+            # simple case-insensitive replace
+            cleaned = cleaned.replace(bad, replacement)
+            cleaned = cleaned.replace(bad.capitalize(), replacement)
+            cleaned = cleaned.replace(bad.upper(), replacement.upper())
+            audit.append(
+                {
+                    "rule": "banned_term",
+                    "bad": bad,
+                    "replacement": replacement,
+                }
+            )
+
+    return cleaned, audit
+
+
+def _apply_length_cap(text: str, platform: PlatformConfig) -> Tuple[str, List[Dict]]:
+    """Trim text to the platform's character cap if necessary."""
+    audit: List[Dict] = []
+    cap = platform.char_cap
+
+    if len(text) > cap:
+        before_len = len(text)
+        trimmed = text[:cap].rstrip()
+        audit.append(
+            {
+                "rule": "length_trim",
+                "before_len": before_len,
+                "after_len": len(trimmed),
+                "cap": cap,
+            }
+        )
+        return trimmed, audit
+
+    return text, audit
+
+
+def validate_and_edit(
+    text: str,
+    platform: PlatformConfig,
+) -> Tuple[str, List[Dict]]:
+    """
+    Apply all validators in order and collect a combined audit log.
+
+    Returns:
+        final_text, audit_log
+    """
+    audit_log: List[Dict] = []
+
+    # 1) banned terms
+    text, banned_audit = _apply_banned_terms(text)
+    audit_log.extend(banned_audit)
+
+    # 2) length trim
+    text, trim_audit = _apply_length_cap(text, platform)
+    audit_log.extend(trim_audit)
+
+    # (you can add more steps later: CTA normalization, emoji limits, etc.)
+    return text, audit_log

requirements.txt

@@ -0,0 +1,17 @@
+pandas
+torch
+transformers
+rich
+sentence-transformers
+textstat
+regex
+tiktoken
+accelerate
+ipywidgets
+ipykernel
+gradio
+langchain
+langchain-core
+langchain-community
+langchain-huggingface
+bitsandbytes

test_llm_backend.py

@@ -0,0 +1,29 @@
+from core_logic.llm_config import get_local_chat_model
+from langchain_core.messages import HumanMessage
+
+
+def main():
+    # Load the ChatHuggingFace model (cached after first call)
+    chat_model = get_local_chat_model()
+
+    # Instead of SystemMessage, fold instructions into the human message
+    prompt = (
+        "You are a friendly marketing copywriter.\n\n"
+        "Write a short, fun one-line ad for a coffee shop."
+    )
+
+    messages = [
+        HumanMessage(content=prompt),
+    ]
+
+    # Call the model
+    ai_msg = chat_model.invoke(messages)
+
+    # Show the result
+    print("Response type:", type(ai_msg))
+    print("Response content:\n")
+    print(ai_msg.content)
+
+
+if __name__ == "__main__":
+    main()

todo.md

@@ -0,0 +1,3 @@
+1. Merge the both screens, when clicked on generate copy , first it gives the result, then user mustt be able to provide the inuputs in the chat window.
+2. Campain goals can be dropdown, generally campaing goals are fixed like lead generation, increase awareness, drive website traffic etc.
+3. Insert feedback section, to receive inuts from the users who used the tool.

ui/gradio_ui.py

@@ -0,0 +1,583 @@
+"""
+Gradio UI for Marketeer (copy + video script).
+
+New UX:
+
+- User fills the campaign form (brand, product, audience, goal, platform, tone, CTA, extra context).
+- Clicking "Generate Copy" creates a FIRST DRAFT and shows it as an assistant
+  message in a single chat interface.
+- The user then continues the conversation in that SAME chat window
+  (no separate one-shot box / separate draft box).
+- Feedback is linked to the LAST assistant response via a simple
+  rating + comment section under the chat.
+"""
+
+from typing import Any, Dict, List
+
+import gradio as gr
+
+from core_logic.copy_pipeline import CopyRequest, generate_copy
+from core_logic.video_pipeline import VideoRequest, generate_video_script
+# from core_logic.chat_chain import chat_turn
+from core_logic.chat_agent import agent_chat_turn
+from core_logic.copy_pipeline import CopyRequest
+
+
+
+
+# ----- Small helpers -----
+
+
+def _build_goal_text(goal_preset: str, goal_custom: str) -> str:
+    """
+    Combine preset and custom goal fields into one text.
+
+    Logic:
+    - If custom goal is provided, use that.
+    - Else, use the preset goal (dropdown).
+    - Else, empty string.
+    """
+    goal_custom = (goal_custom or "").strip()
+    goal_preset = (goal_preset or "").strip()
+    return goal_custom or goal_preset or ""
+
+
+# ----- Backend wrapper functions for Gradio -----
+
+
+def _generate_first_copy_ui(
+    brand: str,
+    product: str,
+    audience: str,
+    goal_preset: str,
+    goal_custom: str,
+    platform_name: str,
+    tone: str,
+    cta_style: str,
+    extra_context: str,
+):
+    """
+    First-step copy generation using the form fields.
+    The result is shown as the FIRST assistant message in the chat.
+
+    Returns:
+    - chat_history: list of [user, assistant] pairs for the Chatbot component
+      Here we start with a single assistant message containing the first draft.
+    """
+    goal_text = _build_goal_text(goal_preset, goal_custom)
+
+    req = CopyRequest(
+        brand=brand or "",
+        product=product or "",
+        audience=audience or "",
+        goal=goal_text or "",
+        platform_name=platform_name or "Instagram",
+        tone=tone or "friendly",
+        cta_style=cta_style or "soft",
+        extra_context=extra_context or "",
+    )
+
+    resp = generate_copy(req)
+
+    first_post = (resp.final or "").strip()
+    if not first_post:
+        first_post = "I tried to generate a post, but the result was empty. Please try again."
+
+    # Seed chat: one assistant message with the first draft
+    chat_history: List[List[str]] = [["", first_post]]
+
+    return chat_history
+
+
+def _chat_copy_ui(
+    chat_history,
+    user_message: str,
+    brand: str,
+    product: str,
+    audience: str,
+    goal_preset: str,
+    goal_custom: str,
+    platform_name: str,
+    tone: str,
+    cta_style: str,
+    extra_context: str,
+):
+    """
+    Chat handler for the Copy tab using the advanced agent with tools.
+
+    Parameters must match the order of inputs in send_btn.click():
+
+        inputs=[
+            chatbox,
+            user_msg,
+            brand,
+            product,
+            audience,
+            goal_preset,
+            goal_custom,
+            platform_name,
+            tone,
+            cta_style,
+            extra_context,
+        ]
+
+    - Uses campaign context (brand, product, audience, goal, platform, tone, CTA)
+    - Uses chat_history (list of [user, assistant] pairs) as previous conversation
+    - Returns updated chat_history and clears the input box.
+    """
+    # If user_message is empty, just return the same state
+    if not user_message or not user_message.strip():
+        return chat_history, user_message
+
+    # Merge preset + custom goal into a single text
+    goal_text = _build_goal_text(goal_preset, goal_custom)
+
+    # Build the CopyRequest from the form fields
+    req = CopyRequest(
+        brand=brand or "",
+        product=product or "",
+        audience=audience or "",
+        goal=goal_text,
+        platform_name=platform_name or "Instagram",
+        tone=tone or "friendly",
+        cta_style=cta_style or "soft",
+        extra_context=extra_context or "",
+    )
+
+    # Gradio Chatbot history comes in as list of [user, assistant] pairs
+    history_pairs = chat_history or []
+
+    # Call our advanced agent (which can use rewrite tools internally)
+    final_text, raw_text, audit = agent_chat_turn(
+        req=req,
+        user_message=user_message,
+        history_pairs=history_pairs,
+    )
+
+    # Append the new turn to history
+    new_history = history_pairs + [[user_message, final_text]]
+
+    # Return updated history and clear the input box
+    return new_history, ""
+
+
+def _clear_chat():
+    """
+    Clear chat history.
+    """
+    return []
+
+
+def _submit_feedback_for_last_reply(
+    chat_history,
+    fb_rating: str,
+    fb_text: str,
+    brand: str,
+    platform_name: str,
+    goal_preset: str,
+    goal_custom: str,
+):
+    """
+    Feedback handler tied to the LAST assistant message in the chat.
+
+    We log:
+    - Brand, Platform, Goal
+    - Rating (e.g., 👍 / 👎)
+    - Free-text feedback
+    - The last assistant reply text
+
+    and return a short status message.
+    """
+    if not chat_history:
+        return "No messages yet. Generate a post or chat first, then leave feedback."
+
+    # chat_history is a list of [user, assistant] pairs.
+    # The last pair's assistant message is the one we care about.
+    last_user, last_assistant = chat_history[-1]
+    last_assistant = last_assistant or "(empty reply)"
+
+    fb_rating = fb_rating or "(not provided)"
+    fb_text = fb_text or "(no comment)"
+    brand = brand or "(not provided)"
+    platform_name = platform_name or "(not provided)"
+
+    goal_text = _build_goal_text(goal_preset, goal_custom)
+    goal_text = goal_text or "(not provided)"
+
+    print("=== MARKETEER FEEDBACK (last reply) ===")
+    print(f"Brand: {brand}")
+    print(f"Platform: {platform_name}")
+    print(f"Goal: {goal_text}")
+    print(f"Rating: {fb_rating}")
+    print("User feedback text:")
+    print(fb_text)
+    print("--- Last assistant reply ---")
+    print(last_assistant)
+    print("=======================================")
+
+    return "✅ Thanks for your feedback on the last reply!"
+
+
+def _generate_video_ui(
+    brand: str,
+    product: str,
+    audience: str,
+    goal: str,
+    blueprint_name: str,
+    duration_sec: int,
+    platform_name: str,
+    style: str,
+    extra_context: str,
+    debug_first: bool,
+) -> Dict[str, Any]:
+    """
+    Wrapper around generate_video_script() for Gradio.
+    Returns storyboard text, JSON, and warnings.
+    """
+    req = VideoRequest(
+        brand=brand or "",
+        product=product or "",
+        audience=audience or "",
+        goal=goal or "",
+        blueprint_name=blueprint_name or "short_ad",
+        duration_sec=int(duration_sec) if duration_sec else 20,
+        platform_name=platform_name or "Instagram Reels",
+        style=style or "warm",
+        extra_context=extra_context or "",
+    )
+
+    # Now returns a VideoScriptResponse (plan + warnings)
+    resp = generate_video_script(req, debug_first=bool(debug_first))
+
+    # --- Build human-readable storyboard from structured beats ---
+    sb_lines: List[str] = []
+    for beat in resp.beats:  # resp.beats is a list[VideoBeat]
+        sb_lines.append(
+            f"Beat {beat.beat_index + 1}: {beat.title} "
+            f"({beat.t_start}s – {beat.t_end}s)"
+        )
+        sb_lines.append(f"  Voiceover: {beat.voiceover}")
+        sb_lines.append(f"  On-screen: {beat.on_screen}")
+
+        sb_lines.append("  Shots:")
+        for shot in beat.shots:
+            sb_lines.append(f"    • {shot}")
+
+        sb_lines.append("  B-roll:")
+        for br in beat.broll:
+            sb_lines.append(f"    • {br}")
+
+        sb_lines.append("  Captions:")
+        for cap in beat.captions:
+            sb_lines.append(f"    • {cap}")
+
+        sb_lines.append("")  # blank line between beats
+
+    storyboard_text = "\n".join(sb_lines).strip() or "No beats generated."
+
+    # --- Warnings text ---
+    if resp.warnings:
+        warnings_text = "\n".join(f"- {w}" for w in resp.warnings)
+    else:
+        warnings_text = "No warnings. All beats parsed without fallback. ✅"
+
+    # --- JSON-ready object for download/integration ---
+    script_json: Dict[str, Any] = {
+        "plan": {
+            "blueprint_name": resp.plan.blueprint_name,
+            "duration_sec": resp.plan.duration_sec,
+            "platform_name": resp.plan.platform_name,
+            "style": resp.plan.style,
+            "beats": [
+                {
+                    "index": b.beat_index,
+                    "title": b.title,
+                    "goal": b.goal,
+                    "t_start": b.t_start,
+                    "t_end": b.t_end,
+                }
+                for b in resp.plan.beats
+            ],
+        },
+        # Full beats payload with all fields (voiceover, shots, etc.)
+        "beats": [b.model_dump() for b in resp.beats],
+        "warnings": resp.warnings,
+    }
+
+    return storyboard_text, script_json, warnings_text
+
+
+
+# ----- Gradio layout -----
+
+
+def create_interface() -> gr.Blocks:
+    """
+    Create and return the Gradio Blocks interface.
+    """
+    with gr.Blocks(title="Marketeer – Copy & Video Script Generator") as demo:
+        gr.Markdown(
+            """
+# Marketeer – Copy & Video Script Generator
+
+Fill in your campaign details, generate a first draft, then refine it
+in a single chat with your AI copywriter. Also generate short-form video
+storyboards for your campaigns.
+"""
+        )
+
+        with gr.Tabs():
+            # --- Tab 1: Copy Chat (single chat interface) ---
+            with gr.Tab("Copy Chat"):
+                with gr.Row():
+                    # LEFT COLUMN: Campaign setup
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Campaign Setup")
+
+                        brand = gr.Textbox(
+                            label="Brand / Company",
+                            placeholder="Brew Bliss Café",
+                        )
+                        product = gr.Textbox(
+                            label="Product / Offer",
+                            placeholder="signature cold brew",
+                        )
+                        audience = gr.Textbox(
+                            label="Target audience",
+                            placeholder=(
+                                "young professionals who love coffee but hate waiting in line"
+                            ),
+                        )
+
+                        # Campaign goal: preset dropdown + optional custom
+                        goal_preset = gr.Dropdown(
+                            label="Campaign goal",
+                            choices=[
+                                "Increase brand awareness",
+                                "Lead generation",
+                                "Drive website traffic",
+                                "Promote in-store visits",
+                                "Boost engagement",
+                                "Announce a new product",
+                            ],
+                            value="Increase brand awareness",
+                        )
+                        goal_custom = gr.Textbox(
+                            label="Custom goal (optional)",
+                            placeholder="e.g. drive in-store visits this weekend",
+                            lines=2,
+                        )
+
+                        platform_name = gr.Dropdown(
+                            label="Platform",
+                            choices=["Instagram", "Facebook", "LinkedIn", "Twitter"],
+                            value="Instagram",
+                        )
+                        tone = gr.Dropdown(
+                            label="Tone",
+                            choices=[
+                                "friendly",
+                                "professional",
+                                "energetic",
+                                "storytelling",
+                            ],
+                            value="friendly",
+                        )
+                        cta_style = gr.Dropdown(
+                            label="CTA style",
+                            choices=["soft", "medium", "hard"],
+                            value="soft",
+                        )
+
+                        extra_context = gr.Textbox(
+                            label="Extra context (optional)",
+                            placeholder="Mention that we have comfy seating and free Wi-Fi.",
+                            lines=3,
+                        )
+
+                        generate_copy_btn = gr.Button(
+                            "✨ Generate First Draft (and start chat)"
+                        )
+
+                    # RIGHT COLUMN: Chat + Feedback
+                    with gr.Column(scale=2):
+                        gr.Markdown("### Chat with your copywriter")
+
+                        chatbox = gr.Chatbot(
+                            label="Copy Chat (context-aware)",
+                            height=320,
+                        )
+                        user_msg = gr.Textbox(
+                            label="Your message",
+                            placeholder=(
+                                "Examples:\n"
+                                "- 'Write a first post for this campaign.'\n"
+                                "- 'Shorten this and keep the main message.'\n"
+                                "- 'Adapt this for LinkedIn, more professional.'"
+                            ),
+                            lines=3,
+                        )
+                        with gr.Row():
+                            send_btn = gr.Button("Send")
+                            clear_btn = gr.Button("Clear Chat")
+
+                        gr.Markdown("#### Feedback on the last reply")
+                        fb_rating = gr.Radio(
+                            label="How was the last AI reply?",
+                            choices=["👍 Helpful", "👌 Okay", "👎 Needs improvement"],
+                            value="👍 Helpful",
+                        )
+                        fb_text = gr.Textbox(
+                            label="Feedback (optional)",
+                            placeholder="What worked well? What should be improved?",
+                            lines=3,
+                        )
+                        fb_submit = gr.Button("Submit feedback for last reply")
+                        fb_status = gr.Markdown("")
+
+                # Wire first-draft generator (seeds chat only)
+                generate_copy_btn.click(
+                    fn=_generate_first_copy_ui,
+                    inputs=[
+                        brand,
+                        product,
+                        audience,
+                        goal_preset,
+                        goal_custom,
+                        platform_name,
+                        tone,
+                        cta_style,
+                        extra_context,
+                    ],
+                    outputs=[chatbox],
+                )
+
+                # Wire chat send button
+                send_btn.click(
+                    fn=_chat_copy_ui,
+                    inputs=[
+                        chatbox,
+                        user_msg,
+                        brand,
+                        product,
+                        audience,
+                        goal_preset,
+                        goal_custom,
+                        platform_name,
+                        tone,
+                        cta_style,
+                        extra_context,
+                    ],
+                    outputs=[chatbox, user_msg],
+                )
+
+                # Wire chat clear button
+                clear_btn.click(
+                    fn=_clear_chat,
+                    inputs=None,
+                    outputs=[chatbox],
+                )
+
+                # Wire feedback button (linked to last assistant reply)
+                fb_submit.click(
+                    fn=_submit_feedback_for_last_reply,
+                    inputs=[
+                        chatbox,
+                        fb_rating,
+                        fb_text,
+                        brand,
+                        platform_name,
+                        goal_preset,
+                        goal_custom,
+                    ],
+                    outputs=[fb_status],
+                )
+
+            # --- Tab 2: Video Script Generator (unchanged logic) ---
+            with gr.Tab("Video Script Generator"):
+                with gr.Row():
+                    with gr.Column():
+                        v_brand = gr.Textbox(
+                            label="Brand / Company",
+                            placeholder="Brew Bliss Café",
+                        )
+                        v_product = gr.Textbox(
+                            label="Product",
+                            placeholder="signature cold brew",
+                        )
+                        v_audience = gr.Textbox(
+                            label="Target audience",
+                            placeholder=(
+                                "young professionals who love coffee but hate waiting in line"
+                            ),
+                        )
+                        v_goal = gr.Textbox(
+                            label="Campaign goal",
+                            placeholder="drive in-store visits this weekend",
+                        )
+
+                        blueprint_name = gr.Dropdown(
+                            label="Blueprint",
+                            choices=["short_ad", "ugc_review", "how_to"],
+                            value="short_ad",
+                        )
+                        duration_sec = gr.Slider(
+                            label="Video duration (seconds)",
+                            minimum=5,
+                            maximum=60,
+                            step=1,
+                            value=20,
+                        )
+                        platform_name_v = gr.Textbox(
+                            label="Platform label (for prompt)",
+                            value="Instagram Reels",
+                        )
+                        style = gr.Textbox(
+                            label="Style",
+                            value="warm and energetic",
+                        )
+                        extra_context_v = gr.Textbox(
+                            label="Extra context (optional)",
+                            placeholder=(
+                                "Focus on escaping the grind and enjoying a chilled moment."
+                            ),
+                            lines=3,
+                        )
+                        debug_first = gr.Checkbox(
+                            label="Print raw first beat to server logs (debug)",
+                            value=False,
+                        )
+
+                        generate_video_btn = gr.Button("Generate Video Script")
+
+                    with gr.Column():
+                        storyboard = gr.Textbox(
+                            label="Storyboard (per beat)",
+                            lines=18,
+                        )
+                        warnings_box = gr.Textbox(
+                            label="Warnings",
+                            lines=6,
+                        )
+                        script_json = gr.JSON(
+                            label="Full script JSON (for download/integration)",
+                        )
+
+                generate_video_btn.click(
+                    fn=_generate_video_ui,
+                    inputs=[
+                        v_brand,
+                        v_product,
+                        v_audience,
+                        v_goal,
+                        blueprint_name,
+                        duration_sec,
+                        platform_name_v,
+                        style,
+                        extra_context_v,
+                        debug_first,
+                    ],
+                    outputs=[storyboard, script_json, warnings_box],
+                )
+
+    return demo

ui/gradio_ui_1.py

@@ -0,0 +1,323 @@
+"""
+Gradio UI for Marketeer (copy + video script).
+
+This file wires the core logic into a simple web interface
+with two tabs:
+- Copy Generator
+- Video Script Generator
+"""
+
+from typing import Any, Dict, List
+
+import gradio as gr
+
+from core_logic.copy_pipeline import CopyRequest, generate_copy
+from core_logic.video_pipeline import VideoRequest, generate_video_script
+
+
+# ----- Backend wrapper functions for Gradio -----
+
+
+def _generate_copy_ui(
+    brand: str,
+    product: str,
+    audience: str,
+    goal: str,
+    platform_name: str,
+    tone: str,
+    cta_style: str,
+    extra_context: str,
+):
+    """
+    Wrapper around generate_copy() for Gradio.
+    Returns final_text, raw_text, audit_text in that order.
+    """
+    req = CopyRequest(
+        brand=brand or "",
+        product=product or "",
+        audience=audience or "",
+        goal=goal or "",
+        platform_name=platform_name or "Instagram",
+        tone=tone or "friendly",
+        cta_style=cta_style or "soft",
+        extra_context=extra_context or "",
+    )
+
+    resp = generate_copy(req)
+
+    # Pretty-print audit log
+    if resp.audit:
+        audit_lines = []
+        for item in resp.audit:
+            rule = item.get("rule", "unknown")
+            audit_lines.append(f"- {rule}: {item}")
+        audit_text = "\n".join(audit_lines)
+    else:
+        audit_text = "No edits were needed. ✅"
+
+    # RETURN IN ORDER: final_copy, raw_output, audit_log
+    return resp.final, resp.raw, audit_text
+
+
+def _generate_video_ui(
+    brand: str,
+    product: str,
+    audience: str,
+    goal: str,
+    blueprint_name: str,
+    duration_sec: int,
+    platform_name: str,
+    style: str,
+    extra_context: str,
+    debug_first: bool,
+):
+    """
+    Wrapper around generate_video_script() for Gradio.
+    Returns storyboard_text, script_json, warnings_text in that order.
+    """
+    req = VideoRequest(
+        brand=brand or "",
+        product=product or "",
+        audience=audience or "",
+        goal=goal or "",
+        blueprint_name=blueprint_name or "short_ad",
+        duration_sec=int(duration_sec) if duration_sec else 20,
+        platform_name=platform_name or "Instagram Reels",
+        style=style or "warm",
+        extra_context=extra_context or "",
+    )
+
+    resp = generate_video_script(req, debug_first=bool(debug_first))
+
+    # storyboard text (same as before)
+    sb_lines = []
+    for block in resp.beats:
+        sb_lines.append(
+            f"Beat {block['beat_index'] + 1}: {block['beat_title']} "
+            f"({block['t_start']}s – {block['t_end']}s)"
+        )
+        sb_lines.append(f"  Voiceover: {block['voiceover']}")
+        sb_lines.append(f"  On-screen: {block['on_screen']}")
+        sb_lines.append("  Shots:")
+        for shot in block["shots"]:
+            sb_lines.append(f"    • {shot}")
+        sb_lines.append("  B-roll:")
+        for br in block["broll"]:
+            sb_lines.append(f"    • {br}")
+        sb_lines.append("  Captions:")
+        for cap in block["captions"]:
+            sb_lines.append(f"    • {cap}")
+        sb_lines.append("")
+
+    storyboard_text = "\n".join(sb_lines).strip() or "No beats generated."
+
+    # warnings text
+    if resp.warnings:
+        warnings_text = "\n".join(f"- {w}" for w in resp.warnings)
+    else:
+        warnings_text = "No warnings. All beats parsed without fallback. ✅"
+
+    # JSON object
+    script_json = {
+        "plan": {
+            "blueprint_name": resp.plan.blueprint_name,
+            "duration_sec": resp.plan.duration_sec,
+            "platform_name": resp.plan.platform_name,
+            "style": resp.plan.style,
+            "beats": [
+                {
+                    "index": b.index,
+                    "title": b.title,
+                    "goal": b.goal,
+                    "t_start": b.t_start,
+                    "t_end": b.t_end,
+                }
+                for b in resp.plan.beats
+            ],
+        },
+        "beats": resp.beats,
+        "warnings": resp.warnings,
+    }
+
+    # RETURN IN ORDER: storyboard, json, warnings
+    return storyboard_text, script_json, warnings_text
+
+
+# ----- Gradio layout -----
+
+
+def create_interface() -> gr.Blocks:
+    """
+    Create and return the Gradio Blocks interface.
+    """
+    with gr.Blocks(title="Marketeer – Copy & Video Script Generator") as demo:
+        gr.Markdown(
+            """
+# Marketeer – Copy & Video Script Generator
+
+Generate platform-aware marketing copy and short-form video scripts,
+powered by your patched Gemma-based backend.
+"""
+        )
+
+        with gr.Tabs():
+            # --- Tab 1: Copy Generator ---
+            with gr.Tab("Copy Generator"):
+                with gr.Row():
+                    with gr.Column():
+                        brand = gr.Textbox(
+                            label="Brand / Company",
+                            placeholder="Brew Bliss Café",
+                        )
+                        product = gr.Textbox(
+                            label="Product / Offer",
+                            placeholder="signature cold brew",
+                        )
+                        audience = gr.Textbox(
+                            label="Target audience",
+                            placeholder="young professionals who love coffee but hate waiting in line",
+                        )
+                        goal = gr.Textbox(
+                            label="Campaign goal",
+                            placeholder="drive in-store visits this weekend",
+                        )
+
+                        platform_name = gr.Dropdown(
+                            label="Platform",
+                            choices=["Instagram", "Facebook", "LinkedIn", "Twitter"],
+                            value="Instagram",
+                        )
+                        tone = gr.Dropdown(
+                            label="Tone",
+                            choices=["friendly", "professional", "energetic", "storytelling"],
+                            value="friendly",
+                        )
+                        cta_style = gr.Dropdown(
+                            label="CTA style",
+                            choices=["soft", "medium", "hard"],
+                            value="soft",
+                        )
+
+                        extra_context = gr.Textbox(
+                            label="Extra context (optional)",
+                            placeholder="Mention that we have comfy seating and free Wi-Fi.",
+                            lines=3,
+                        )
+
+                        generate_copy_btn = gr.Button("Generate Copy")
+
+                    with gr.Column():
+                        final_copy = gr.Textbox(
+                            label="Final Copy",
+                            lines=10,
+                        )
+                        audit_log = gr.Textbox(
+                            label="Audit Log",
+                            lines=8,
+                        )
+                        raw_output = gr.Textbox(
+                            label="Raw Model Output (debug)",
+                            lines=8,
+                            visible=False,  # flip to True if you want to see raw text
+                        )
+
+                # Wire copy button
+                generate_copy_btn.click(
+                    fn=_generate_copy_ui,
+                    inputs=[
+                        brand,
+                        product,
+                        audience,
+                        goal,
+                        platform_name,
+                        tone,
+                        cta_style,
+                        extra_context,
+                    ],
+                    outputs=[final_copy, raw_output, audit_log],
+                )
+
+            # --- Tab 2: Video Script Generator ---
+            with gr.Tab("Video Script Generator"):
+                with gr.Row():
+                    with gr.Column():
+                        v_brand = gr.Textbox(
+                            label="Brand / Company",
+                            placeholder="Brew Bliss Café",
+                        )
+                        v_product = gr.Textbox(
+                            label="Product",
+                            placeholder="signature cold brew",
+                        )
+                        v_audience = gr.Textbox(
+                            label="Target audience",
+                            placeholder="young professionals who love coffee but hate waiting in line",
+                        )
+                        v_goal = gr.Textbox(
+                            label="Campaign goal",
+                            placeholder="drive in-store visits this weekend",
+                        )
+
+                        blueprint_name = gr.Dropdown(
+                            label="Blueprint",
+                            choices=["short_ad", "ugc_review", "how_to"],
+                            value="short_ad",
+                        )
+                        duration_sec = gr.Slider(
+                            label="Video duration (seconds)",
+                            minimum=5,
+                            maximum=60,
+                            step=1,
+                            value=20,
+                        )
+                        platform_name_v = gr.Textbox(
+                            label="Platform label (for prompt)",
+                            value="Instagram Reels",
+                        )
+                        style = gr.Textbox(
+                            label="Style",
+                            value="warm and energetic",
+                        )
+                        extra_context_v = gr.Textbox(
+                            label="Extra context (optional)",
+                            placeholder="Focus on escaping the grind and enjoying a chilled moment.",
+                            lines=3,
+                        )
+                        debug_first = gr.Checkbox(
+                            label="Print raw first beat to server logs (debug)",
+                            value=False,
+                        )
+
+                        generate_video_btn = gr.Button("Generate Video Script")
+
+                    with gr.Column():
+                        storyboard = gr.Textbox(
+                            label="Storyboard (per beat)",
+                            lines=18,
+                        )
+                        warnings_box = gr.Textbox(
+                            label="Warnings",
+                            lines=6,
+                        )
+                        script_json = gr.JSON(
+                            label="Full script JSON (for download/integration)",
+                        )
+
+                generate_video_btn.click(
+                    fn=_generate_video_ui,
+                    inputs=[
+                        v_brand,
+                        v_product,
+                        v_audience,
+                        v_goal,
+                        blueprint_name,
+                        duration_sec,
+                        platform_name_v,
+                        style,
+                        extra_context_v,
+                        debug_first,
+                    ],
+                    outputs=[storyboard, script_json, warnings_box],
+                )
+
+    return demo