feat: add progress indicators with generator pattern

Convert search_topics() and generate_script() to generators that yield
intermediate status messages. This enables Gradio's progress bar and
spinner to display during long-running operations.

- Use yield instead of return to create UI update checkpoints
- Add gr.Progress() calls for percentage-based progress bar
- Enable queue before event handlers for proper async behavior

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,43 @@
+# Environment variables (contains secrets)
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Gradio
+flagged/

app.py

@@ -0,0 +1,318 @@
+"""
+NewPress AI - Johnny Harris Script Assistant
+
+A Gradio app that uses a Supabase vector database of Johnny Harris transcripts to:
+1. Search if topics have been covered before
+2. Generate scripts in Johnny's voice from bullet points
+"""
+
+import os
+import gradio as gr
+from dotenv import load_dotenv
+
+from src.vectorstore import TranscriptVectorStore, create_vectorstore
+from src.llm_client import InferenceProviderClient, create_llm_client
+from src.prompts import (
+    TOPIC_SEARCH_SYSTEM_PROMPT,
+    SCRIPT_SYSTEM_PROMPT,
+    get_topic_search_prompt,
+    get_script_prompt
+)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize components (lazy loading)
+vectorstore = None
+llm_client = None
+
+
+def get_vectorstore() -> TranscriptVectorStore:
+    """Get or create the vector store instance"""
+    global vectorstore
+    if vectorstore is None:
+        vectorstore = create_vectorstore()
+    return vectorstore
+
+
+def get_llm_client() -> InferenceProviderClient:
+    """Get or create the LLM client instance"""
+    global llm_client
+    if llm_client is None:
+        llm_client = create_llm_client()
+    return llm_client
+
+
+# =============================================================================
+# TAB 1: TOPIC SEARCH
+# =============================================================================
+
+def expand_query(query: str) -> list:
+    """Use LLM to generate related search terms for broader coverage"""
+    try:
+        llm = get_llm_client()
+        prompt = f"""Given this search query about Johnny Harris video topics: "{query}"
+
+Generate 3-5 related search terms that might find relevant videos.
+Think about: related topics, geographic regions, historical events, or concepts that might be covered.
+Return ONLY the terms, one per line, no numbering or explanation."""
+
+        response = llm.generate(prompt, max_tokens=100, temperature=0.3)
+        terms = [t.strip() for t in response.strip().split('\n') if t.strip()]
+        return [query] + terms[:5]
+    except Exception:
+        return [query]
+
+
+def search_topics(query: str, progress=gr.Progress()):
+    """
+    Generator that yields progress updates during search.
+    Uses LLM query expansion for broader, more relevant results.
+
+    Args:
+        query: User's topic or question
+        progress: Gradio progress tracker
+
+    Yields:
+        Progress status messages, then final search results
+    """
+    if not query or not query.strip():
+        yield "Please enter a topic or question to search."
+        return
+
+    try:
+        vs = get_vectorstore()
+
+        # Expand query using LLM
+        progress(0.1, desc="Expanding search query...")
+        yield "Expanding search query..."
+        search_terms = expand_query(query.strip())
+
+        # Search with each term and collect results
+        all_results = []
+        total_terms = len(search_terms)
+        for i, term in enumerate(search_terms):
+            pct = 0.2 + (0.5 * (i / total_terms))
+            progress(pct, desc=f"Searching: {term[:30]}...")
+            yield f"Searching: {term[:30]}..."
+            results = vs.similarity_search(
+                query=term,
+                k=20,
+                match_threshold=0.1
+            )
+            all_results.extend(results)
+
+        progress(0.8, desc="Processing results...")
+        yield "Processing results..."
+
+        # Deduplicate by video title, keep highest similarity score
+        seen = {}
+        for r in all_results:
+            if r.title not in seen or r.similarity > seen[r.title].similarity:
+                seen[r.title] = r
+
+        # Sort by similarity and get top results
+        unique_results = sorted(seen.values(), key=lambda x: x.similarity, reverse=True)[:15]
+
+        if not unique_results:
+            yield f"No matching content found for: **{query}**\n\nThis topic may not have been covered yet, or try rephrasing your search."
+            return
+
+        # Format results for display
+        output = vs.format_results_for_display(unique_results)
+
+        search_info = f"*Searched: {', '.join(search_terms)}*\n\n"
+        progress(1.0, desc="Done!")
+        yield f"## Search Results for: \"{query}\"\n\n{search_info}{output}"
+
+    except Exception as e:
+        yield f"Error searching: {str(e)}"
+
+
+# =============================================================================
+# TAB 2: SCRIPT PRODUCTION
+# =============================================================================
+
+def generate_script(user_notes: str, max_context_chunks: int = 100, progress=gr.Progress()):
+    """
+    Generator that yields progress updates during script generation.
+
+    Args:
+        user_notes: User's bullet points and notes
+        max_context_chunks: Number of style reference chunks to use
+        progress: Gradio progress tracker
+
+    Yields:
+        Progress status messages, then final generated script
+    """
+    if not user_notes or not user_notes.strip():
+        yield "Please enter your bullet points or notes to transform into a script."
+        return
+
+    try:
+        progress(0.05, desc="Gathering style references...")
+        yield "Gathering style references..."
+        vs = get_vectorstore()
+        llm = get_llm_client()
+
+        progress(0.15, desc="Searching knowledge base...")
+        yield "Searching knowledge base for style references..."
+        context_chunks = vs.get_bulk_style_context(
+            topic_query=user_notes.strip(),
+            max_chunks=max_context_chunks,
+            topic_relevant_ratio=0.3
+        )
+
+        progress(0.35, desc="Preparing context...")
+        yield "Preparing context for the LLM..."
+        context = vs.format_context_for_llm(context_chunks) if context_chunks else ""
+
+        progress(0.5, desc="Building prompt...")
+        yield "Building prompt..."
+        prompt_template = get_script_prompt()
+        prompt = prompt_template.format(
+            user_input=user_notes.strip(),
+            context=context
+        )
+
+        progress(0.7, desc="Generating script (30-60 seconds)...")
+        yield "Generating script (this may take 30-60 seconds)..."
+        script = llm.generate(
+            prompt=prompt,
+            system_prompt=SCRIPT_SYSTEM_PROMPT,
+            temperature=0.7,
+            max_tokens=2000
+        )
+
+        progress(1.0, desc="Complete!")
+        yield f"## Generated Script\n\n{script.strip()}"
+
+    except Exception as e:
+        yield f"**Error:** {str(e)}"
+
+
+# =============================================================================
+# GRADIO INTERFACE
+# =============================================================================
+
+def create_app():
+    """Create and configure the Gradio application"""
+
+    with gr.Blocks(
+        title="NewPress AI - Johnny Harris Script Assistant",
+        theme=gr.themes.Soft()
+    ) as app:
+        app.queue()  # Enable queue before defining event handlers for progress to work
+
+        gr.Markdown("""
+        # NewPress AI
+        ### Johnny Harris Script Assistant
+
+        Use Johnny's archive of hundreds of video transcripts to:
+        - **Search** if a topic has been covered before
+        - **Generate** scripts in Johnny's voice from your notes
+        """)
+
+        with gr.Tabs():
+            # =================================================================
+            # TAB 1: TOPIC SEARCH
+            # =================================================================
+            with gr.TabItem("Topic Search"):
+                gr.Markdown("""
+                ### Has Johnny covered this topic?
+
+                Search the archive to see if a topic has been addressed in previous videos.
+                """)
+
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        topic_input = gr.Textbox(
+                            label="Topic or Question",
+                            placeholder="e.g., Why do borders exist? or US immigration policy",
+                            lines=2
+                        )
+                    with gr.Column(scale=1):
+                        search_btn = gr.Button("Search", variant="primary", size="lg")
+
+                search_output = gr.Markdown(label="Search Results", value="Search results will appear here...")
+
+                search_btn.click(
+                    fn=search_topics,
+                    inputs=[topic_input],
+                    outputs=[search_output],
+                    show_progress="full"
+                )
+
+                topic_input.submit(
+                    fn=search_topics,
+                    inputs=[topic_input],
+                    outputs=[search_output],
+                    show_progress="full"
+                )
+
+            # =================================================================
+            # TAB 2: SCRIPT PRODUCTION
+            # =================================================================
+            with gr.TabItem("Script Production"):
+                gr.Markdown("""
+                ### Transform your ideas into Johnny's voice
+
+                Enter your bullet points, notes, or rough ideas. The AI will analyze
+                Johnny's entire archive of scripts and generate a draft in his signature style.
+                """)
+
+                with gr.Row():
+                    with gr.Column():
+                        notes_input = gr.Textbox(
+                            label="Your Notes & Bullet Points",
+                            placeholder="""Enter your ideas, for example:
+
+- Topic: Why shipping containers changed the world
+- Key points:
+  - Before containers, loading ships took weeks
+  - Malcolm McLean invented the standard container in 1956
+  - Transformed global trade
+  - Connection to globalization and supply chains
+- Angle: The hidden infrastructure we never think about""",
+                            lines=12
+                        )
+
+                        with gr.Row():
+                            context_slider = gr.Slider(
+                                minimum=20,
+                                maximum=200,
+                                value=100,
+                                step=10,
+                                label="Style Reference Depth",
+                                info="More excerpts = better style matching, but slower"
+                            )
+                            generate_btn = gr.Button("Generate Script", variant="primary", size="lg")
+
+                script_output = gr.Markdown(label="Generated Script", value="Generated script will appear here...")  # shows progress + final script
+
+                generate_btn.click(
+                    fn=generate_script,
+                    inputs=[notes_input, context_slider],
+                    outputs=[script_output],
+                    show_progress="full"
+                )
+
+        gr.Markdown("""
+        ---
+        *Powered by Johnny Harris's transcript archive, Jina AI embeddings, and Qwen-2.5-72B*
+        """)
+
+    return app
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

requirements.txt

@@ -0,0 +1,14 @@
+# Gradio for UI
+gradio>=4.0.0
+
+# Supabase client for vector store
+supabase>=2.0.0
+
+# Hugging Face Inference (for LLM)
+huggingface-hub>=0.20.0
+
+# Environment variables
+python-dotenv>=1.0.0
+
+# HTTP requests (for Jina API)
+requests

src/__init__.py

@@ -0,0 +1,21 @@
+"""NewPress AI - Johnny Harris Script Assistant"""
+
+from .vectorstore import TranscriptVectorStore, create_vectorstore
+from .llm_client import InferenceProviderClient, create_llm_client
+from .prompts import (
+    TOPIC_SEARCH_SYSTEM_PROMPT,
+    SCRIPT_SYSTEM_PROMPT,
+    SCRIPT_PROMPT_TEMPLATE,
+    get_script_prompt
+)
+
+__all__ = [
+    "TranscriptVectorStore",
+    "create_vectorstore",
+    "InferenceProviderClient",
+    "create_llm_client",
+    "TOPIC_SEARCH_SYSTEM_PROMPT",
+    "SCRIPT_SYSTEM_PROMPT",
+    "SCRIPT_PROMPT_TEMPLATE",
+    "get_script_prompt"
+]

src/llm_client.py

@@ -0,0 +1,191 @@
+"""LLM client for Hugging Face Inference API"""
+
+import os
+from typing import Iterator, Optional
+from huggingface_hub import InferenceClient
+
+
+class InferenceProviderClient:
+    """Client for Hugging Face Inference API"""
+
+    def __init__(
+        self,
+        model: str = "Qwen/Qwen2.5-72B-Instruct",
+        api_key: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 2000
+    ):
+        """
+        Initialize the Inference client
+
+        Args:
+            model: Model identifier (default: Qwen2.5-72B-Instruct)
+            api_key: HuggingFace API token (defaults to HF_TOKEN env var)
+            temperature: Sampling temperature (0.0 to 1.0)
+            max_tokens: Maximum tokens to generate
+        """
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+        api_key = api_key or os.getenv("HF_TOKEN")
+        if not api_key:
+            raise ValueError("HF_TOKEN environment variable must be set or api_key provided")
+
+        self.client = InferenceClient(token=api_key)
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None
+    ) -> str:
+        """
+        Generate a response from the LLM
+
+        Args:
+            prompt: User prompt
+            system_prompt: Optional system prompt
+            temperature: Override default temperature
+            max_tokens: Override default max tokens
+
+        Returns:
+            Generated text response
+        """
+        messages = []
+
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        messages.append({"role": "user", "content": prompt})
+
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=messages,
+            temperature=temperature or self.temperature,
+            max_tokens=max_tokens or self.max_tokens
+        )
+
+        return response.choices[0].message.content
+
+    def generate_stream(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None
+    ) -> Iterator[str]:
+        """
+        Generate a streaming response from the LLM
+
+        Args:
+            prompt: User prompt
+            system_prompt: Optional system prompt
+            temperature: Override default temperature
+            max_tokens: Override default max tokens
+
+        Yields:
+            Text chunks as they are generated
+        """
+        messages = []
+
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        messages.append({"role": "user", "content": prompt})
+
+        stream = self.client.chat_completion(
+            model=self.model,
+            messages=messages,
+            temperature=temperature or self.temperature,
+            max_tokens=max_tokens or self.max_tokens,
+            stream=True
+        )
+
+        for chunk in stream:
+            try:
+                if hasattr(chunk, 'choices') and len(chunk.choices) > 0:
+                    if hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                        if chunk.choices[0].delta.content is not None:
+                            yield chunk.choices[0].delta.content
+            except (IndexError, AttributeError):
+                continue
+
+    def chat(
+        self,
+        messages: list[dict],
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        stream: bool = False
+    ):
+        """
+        Multi-turn chat completion
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            temperature: Override default temperature
+            max_tokens: Override default max tokens
+            stream: Whether to stream the response
+
+        Returns:
+            Response text (or iterator if stream=True)
+        """
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=messages,
+            temperature=temperature or self.temperature,
+            max_tokens=max_tokens or self.max_tokens,
+            stream=stream
+        )
+
+        if stream:
+            def stream_generator():
+                for chunk in response:
+                    try:
+                        if hasattr(chunk, 'choices') and len(chunk.choices) > 0:
+                            if hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                                if chunk.choices[0].delta.content is not None:
+                                    yield chunk.choices[0].delta.content
+                    except (IndexError, AttributeError):
+                        continue
+            return stream_generator()
+        else:
+            return response.choices[0].message.content
+
+
+def create_llm_client(
+    model: str = "Qwen/Qwen2.5-72B-Instruct",
+    temperature: float = 0.7,
+    max_tokens: int = 2000
+) -> InferenceProviderClient:
+    """
+    Factory function to create and return a configured LLM client
+
+    Args:
+        model: Model identifier
+        temperature: Sampling temperature
+        max_tokens: Maximum tokens to generate
+
+    Returns:
+        Configured InferenceProviderClient
+    """
+    return InferenceProviderClient(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens
+    )
+
+
+# Available models
+AVAILABLE_MODELS = {
+    "qwen-72b": "Qwen/Qwen2.5-72B-Instruct",
+    "llama-3.1-8b": "meta-llama/Llama-3.1-8B-Instruct",
+    "llama-3-8b": "meta-llama/Meta-Llama-3-8B-Instruct",
+    "mistral-7b": "mistralai/Mistral-7B-Instruct-v0.3",
+}
+
+
+def get_model_identifier(model_name: str) -> str:
+    """Get full model identifier from short name"""
+    return AVAILABLE_MODELS.get(model_name, AVAILABLE_MODELS["qwen-72b"])

src/prompts.py

@@ -0,0 +1,125 @@
+"""Prompt templates for Johnny Harris Script Assistant"""
+
+
+# =============================================================================
+# TAB 1: TOPIC SEARCH PROMPTS
+# =============================================================================
+
+TOPIC_SEARCH_SYSTEM_PROMPT = """You analyze search results from Johnny Harris's video archive.
+
+Given matching transcript excerpts, provide a clear summary of:
+1. Which videos covered this topic (with titles)
+2. Key points and perspectives from each relevant video
+3. How thoroughly the topic was explored
+
+Be concise but informative. Help the user understand what content already exists on this topic."""
+
+
+TOPIC_SEARCH_PROMPT_TEMPLATE = """USER'S QUESTION: {query}
+
+MATCHING CONTENT FROM JOHNNY'S ARCHIVE:
+{context}
+
+Based on these search results, summarize:
+1. Which videos address this topic
+2. Key points covered in each
+3. Overall coverage assessment - has Johnny covered this thoroughly, partially, or not at all?
+
+Keep your response concise and actionable."""
+
+
+# =============================================================================
+# TAB 2: SCRIPT PRODUCTION PROMPTS
+# =============================================================================
+
+SCRIPT_SYSTEM_PROMPT = """You are a script writing assistant that has deeply studied Johnny Harris's style.
+
+JOHNNY'S VOICE CHARACTERISTICS (derived from extensive analysis of his work):
+
+**Narrative Structure:**
+- Opens with a hook - a provocative question, surprising fact, or personal moment
+- Builds tension through questions: "But here's the thing...", "So why does this matter?"
+- Uses the "zoom out" technique - starts specific, expands to bigger picture
+- Weaves between personal story and broader research/data
+- Ends with reflection or call to think differently
+
+**Language Patterns:**
+- Direct address: "I want to show you something", "Let me explain"
+- Conversational markers: "the thing is...", "here's what's interesting...", "and this is where it gets wild"
+- Short punchy sentences followed by longer explanatory ones
+- Rhetorical questions that pull the viewer in
+- Admits uncertainty: "I don't fully understand this yet", "I'm still wrestling with this"
+
+**Tone:**
+- Curious and genuinely excited about learning
+- Slightly irreverent but deeply researched
+- Personal without being self-indulgent
+- Acknowledges complexity without being academic
+- Finds the human story in geopolitics/data
+
+Your job is to transform the user's bullet points and notes into a script draft that authentically sounds like Johnny wrote it. Study the provided transcript excerpts carefully - they are your primary style reference. Do not include visual cues, bracketed notes, or stage directions—return narrative script text only.
+
+**FORMAT: YouTube Short (under 3 minutes)**
+- Target length: 400-500 words (roughly 2-3 minutes when spoken)
+- Must hook immediately - no slow buildup
+- Punchier pacing than long-form content
+- One core idea, explored quickly but compellingly
+- End with a memorable takeaway or question"""
+
+
+SCRIPT_PROMPT_TEMPLATE = """USER'S NOTES AND BULLET POINTS:
+{user_input}
+
+JOHNNY'S STYLE REFERENCE (transcript excerpts from his videos):
+{context}
+
+INSTRUCTIONS:
+Transform the user's notes into a YouTube Short script (under 3 minutes) in Johnny Harris's voice.
+
+Requirements:
+1. HOOK IMMEDIATELY - first sentence must grab attention (no "hey guys" or slow intros)
+2. Keep it to ONE core idea - shorts don't have time for tangents
+3. Use Johnny's characteristic phrases and energy from the excerpts
+4. Punchier pacing - short sentences, quick reveals, maintain momentum
+5. End with a memorable line - a surprising fact, provocative question, or reframe
+6. Do not include any visual cues, bracketed notes, or stage directions—return only the spoken script text.
+
+Target: 400-500 words (2-3 minutes when spoken at YouTube pace).
+Write a script that sounds like Johnny but optimized for the short-form vertical format."""
+
+
+# =============================================================================
+# UTILITY CLASSES AND FUNCTIONS
+# =============================================================================
+
+class SimplePromptTemplate:
+    """Simple prompt template using string formatting"""
+
+    def __init__(self, template: str, input_variables: list):
+        self.template = template
+        self.input_variables = input_variables
+
+    def format(self, **kwargs) -> str:
+        """Format the template with provided variables"""
+        return self.template.format(**kwargs)
+
+
+TOPIC_SEARCH_PROMPT = SimplePromptTemplate(
+    template=TOPIC_SEARCH_PROMPT_TEMPLATE,
+    input_variables=["query", "context"]
+)
+
+SCRIPT_PROMPT = SimplePromptTemplate(
+    template=SCRIPT_PROMPT_TEMPLATE,
+    input_variables=["user_input", "context"]
+)
+
+
+def get_topic_search_prompt() -> SimplePromptTemplate:
+    """Get the topic search prompt template"""
+    return TOPIC_SEARCH_PROMPT
+
+
+def get_script_prompt() -> SimplePromptTemplate:
+    """Get the script generation prompt template"""
+    return SCRIPT_PROMPT

src/vectorstore.py

@@ -0,0 +1,418 @@
+"""Supabase PGVector connection for Johnny Harris transcript embeddings"""
+
+import os
+import random
+from typing import List, Dict, Any, Optional
+from supabase import create_client, Client
+import requests
+
+
+class TranscriptChunk:
+    """Represents a transcript chunk from the database"""
+
+    def __init__(self, chunk_text: str, metadata: dict):
+        self.chunk_text = chunk_text
+        self.metadata = metadata
+
+    @property
+    def video_id(self) -> str:
+        return self.metadata.get('video_id', '')
+
+    @property
+    def video_url(self) -> str:
+        return self.metadata.get('video_url', '')
+
+    @property
+    def title(self) -> str:
+        return self.metadata.get('title', '')
+
+    @property
+    def chunk_index(self) -> int:
+        return self.metadata.get('chunk_index', 0)
+
+    @property
+    def total_chunks(self) -> int:
+        return self.metadata.get('total_chunks', 0)
+
+    @property
+    def similarity(self) -> float:
+        return self.metadata.get('similarity', 0.0)
+
+
+class TranscriptVectorStore:
+    """Manages connection to Supabase PGVector database with Johnny Harris transcript embeddings"""
+
+    def __init__(
+        self,
+        supabase_url: Optional[str] = None,
+        supabase_key: Optional[str] = None,
+        jina_api_key: Optional[str] = None,
+        embedding_model: str = "jina-embeddings-v3"
+    ):
+        """
+        Initialize the vector store connection
+
+        Args:
+            supabase_url: Supabase project URL (defaults to SUPABASE_URL env var)
+            supabase_key: Supabase anon key (defaults to SUPABASE_KEY env var)
+            jina_api_key: Jina AI API key (defaults to JINA_API_KEY env var)
+            embedding_model: Embedding model to use (default: jina-embeddings-v3)
+        """
+        self.supabase_url = supabase_url or os.getenv("SUPABASE_URL")
+        self.supabase_key = supabase_key or os.getenv("SUPABASE_KEY")
+        self.jina_api_key = jina_api_key or os.getenv("JINA_API_KEY")
+        self.embedding_model = embedding_model
+
+        if not self.supabase_url or not self.supabase_key:
+            raise ValueError("SUPABASE_URL and SUPABASE_KEY environment variables must be set")
+
+        if not self.jina_api_key:
+            raise ValueError("JINA_API_KEY environment variable must be set")
+
+        # Initialize Supabase client
+        self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
+
+    def _generate_embedding(self, text: str, task: str = "retrieval.query") -> List[float]:
+        """
+        Generate embedding for text using Jina AI API
+
+        Args:
+            text: Text to embed
+            task: Task type - 'retrieval.query' for queries, 'retrieval.passage' for documents
+
+        Returns:
+            List of floats representing the embedding vector (1024 dimensions)
+        """
+        try:
+            api_url = "https://api.jina.ai/v1/embeddings"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.jina_api_key}"
+            }
+            payload = {
+                "model": self.embedding_model,
+                "task": task,
+                "input": [text]
+            }
+
+            response = requests.post(api_url, headers=headers, json=payload, timeout=30)
+
+            if response.status_code != 200:
+                raise Exception(f"Jina API returned status {response.status_code}: {response.text}")
+
+            result = response.json()
+
+            if isinstance(result, dict) and 'data' in result:
+                return result['data'][0]['embedding']
+
+            raise Exception("Unexpected response format from Jina API")
+
+        except Exception as e:
+            raise Exception(f"Error generating embedding: {str(e)}")
+
+    def similarity_search(
+        self,
+        query: str,
+        k: int = 10,
+        match_threshold: float = 0.7
+    ) -> List[TranscriptChunk]:
+        """
+        Perform similarity search on the transcript database (Tab 1: Topic Search)
+
+        Args:
+            query: Search query
+            k: Number of results to return
+            match_threshold: Minimum similarity threshold (0.0 to 1.0)
+
+        Returns:
+            List of TranscriptChunk objects with relevant transcript chunks
+        """
+        query_embedding = self._generate_embedding(query, task="retrieval.query")
+
+        try:
+            response = self.supabase.rpc(
+                'match_transcripts',
+                {
+                    'query_embedding': query_embedding,
+                    'match_threshold': match_threshold,
+                    'match_count': k
+                }
+            ).execute()
+
+            chunks = []
+            for item in response.data:
+                chunk = TranscriptChunk(
+                    chunk_text=item.get('chunk_text') or '',
+                    metadata={
+                        'video_id': item.get('video_id'),
+                        'video_url': item.get('video_url'),
+                        'title': item.get('title', ''),
+                        'chunk_index': item.get('chunk_index'),
+                        'total_chunks': item.get('total_chunks'),
+                        'similarity': item.get('similarity', 0.0)
+                    }
+                )
+                chunks.append(chunk)
+
+            return chunks
+
+        except Exception as e:
+            raise Exception(f"Error performing similarity search: {str(e)}")
+
+    def get_video_chunks(self, video_id: str) -> List[TranscriptChunk]:
+        """
+        Fetch all chunks for a specific video
+
+        Args:
+            video_id: YouTube video ID
+
+        Returns:
+            List of TranscriptChunk objects ordered by chunk_index
+        """
+        try:
+            response = self.supabase.from_('johnny_transcripts') \
+                .select('video_id, video_url, title, chunk_text, chunk_index, total_chunks') \
+                .eq('video_id', video_id) \
+                .order('chunk_index') \
+                .execute()
+
+            chunks = []
+            for item in response.data:
+                chunk = TranscriptChunk(
+                    chunk_text=item.get('chunk_text') or '',
+                    metadata={
+                        'video_id': item.get('video_id'),
+                        'video_url': item.get('video_url'),
+                        'title': item.get('title', ''),
+                        'chunk_index': item.get('chunk_index'),
+                        'total_chunks': item.get('total_chunks'),
+                        'similarity': 1.0
+                    }
+                )
+                chunks.append(chunk)
+
+            return chunks
+
+        except Exception as e:
+            raise Exception(f"Error fetching video chunks: {str(e)}")
+
+    def get_random_diverse_chunks(self, n: int = 50) -> List[TranscriptChunk]:
+        """
+        Fetch random chunks from different videos for style variety
+
+        Args:
+            n: Number of random chunks to fetch
+
+        Returns:
+            List of TranscriptChunk objects from diverse videos
+        """
+        try:
+            # Get all unique video IDs first
+            response = self.supabase.from_('johnny_transcripts') \
+                .select('video_id') \
+                .execute()
+
+            video_ids = list(set(item['video_id'] for item in response.data if item.get('video_id')))
+
+            if not video_ids:
+                return []
+
+            # Sample from different videos to ensure diversity
+            chunks = []
+            chunks_per_video = max(1, n // len(video_ids)) if video_ids else n
+
+            # Shuffle video IDs for randomness
+            random.shuffle(video_ids)
+
+            for video_id in video_ids[:min(len(video_ids), n)]:
+                try:
+                    # Get random chunks from this video
+                    video_response = self.supabase.from_('johnny_transcripts') \
+                        .select('video_id, video_url, title, chunk_text, chunk_index, total_chunks') \
+                        .eq('video_id', video_id) \
+                        .limit(chunks_per_video) \
+                        .execute()
+
+                    for item in video_response.data:
+                        chunk = TranscriptChunk(
+                            chunk_text=item.get('chunk_text') or '',
+                            metadata={
+                                'video_id': item.get('video_id'),
+                                'video_url': item.get('video_url'),
+                                'title': item.get('title', ''),
+                                'chunk_index': item.get('chunk_index'),
+                                'total_chunks': item.get('total_chunks'),
+                                'similarity': 0.0  # Random selection, no similarity score
+                            }
+                        )
+                        chunks.append(chunk)
+
+                    if len(chunks) >= n:
+                        break
+
+                except Exception:
+                    continue
+
+            return chunks[:n]
+
+        except Exception as e:
+            raise Exception(f"Error fetching random chunks: {str(e)}")
+
+    def get_bulk_style_context(
+        self,
+        topic_query: str,
+        max_chunks: int = 100,
+        topic_relevant_ratio: float = 0.3
+    ) -> List[TranscriptChunk]:
+        """
+        Retrieve maximum context from knowledge base for script generation (Tab 2)
+
+        This method combines:
+        1. Topic-relevant chunks (found via similarity search)
+        2. Diverse random samples from across the archive
+
+        The entire knowledge base serves as the style reference.
+
+        Args:
+            topic_query: User's topic/bullet points to find relevant content
+            max_chunks: Maximum number of chunks to retrieve
+            topic_relevant_ratio: Ratio of chunks that should be topic-relevant (0.0 to 1.0)
+
+        Returns:
+            List of TranscriptChunk objects (topic-relevant + diverse samples)
+        """
+        topic_relevant_count = int(max_chunks * topic_relevant_ratio)
+        diverse_count = max_chunks - topic_relevant_count
+
+        # Get topic-relevant chunks
+        topic_chunks = self.similarity_search(
+            query=topic_query,
+            k=topic_relevant_count,
+            match_threshold=0.3  # Lower threshold to get more results
+        )
+
+        # Get diverse random chunks for style variety
+        diverse_chunks = self.get_random_diverse_chunks(n=diverse_count)
+
+        # Combine and deduplicate by video_id + chunk_index
+        seen = set()
+        combined = []
+
+        for chunk in topic_chunks + diverse_chunks:
+            key = (chunk.video_id, chunk.chunk_index)
+            if key not in seen:
+                seen.add(key)
+                combined.append(chunk)
+
+        return combined[:max_chunks]
+
+    def get_all_chunks(self, limit: int = 500) -> List[TranscriptChunk]:
+        """
+        Fetch all chunks from the database (up to limit)
+
+        Args:
+            limit: Maximum number of chunks to fetch
+
+        Returns:
+            List of TranscriptChunk objects
+        """
+        try:
+            response = self.supabase.from_('johnny_transcripts') \
+                .select('video_id, video_url, title, chunk_text, chunk_index, total_chunks') \
+                .limit(limit) \
+                .execute()
+
+            chunks = []
+            for item in response.data:
+                chunk = TranscriptChunk(
+                    chunk_text=item.get('chunk_text') or '',
+                    metadata={
+                        'video_id': item.get('video_id'),
+                        'video_url': item.get('video_url'),
+                        'title': item.get('title', ''),
+                        'chunk_index': item.get('chunk_index'),
+                        'total_chunks': item.get('total_chunks'),
+                        'similarity': 0.0
+                    }
+                )
+                chunks.append(chunk)
+
+            return chunks
+
+        except Exception as e:
+            raise Exception(f"Error fetching all chunks: {str(e)}")
+
+    def format_results_for_display(self, chunks: List[TranscriptChunk]) -> str:
+        """
+        Format search results for Tab 1 display
+
+        Args:
+            chunks: List of TranscriptChunk objects
+
+        Returns:
+            Formatted markdown string for display
+        """
+        if not chunks:
+            return "No matching content found."
+
+        # Group by video
+        videos = {}
+        for chunk in chunks:
+            video_id = chunk.video_id
+            if video_id not in videos:
+                videos[video_id] = {
+                    'title': chunk.title,
+                    'url': chunk.video_url,
+                    'chunks': [],
+                    'max_similarity': 0.0
+                }
+            videos[video_id]['chunks'].append(chunk)
+            videos[video_id]['max_similarity'] = max(
+                videos[video_id]['max_similarity'],
+                chunk.similarity
+            )
+
+        # Sort by max similarity
+        sorted_videos = sorted(
+            videos.items(),
+            key=lambda x: x[1]['max_similarity'],
+            reverse=True
+        )
+
+        # Format output
+        output = []
+        for video_id, data in sorted_videos:
+            similarity_pct = int(data['max_similarity'] * 100)
+            output.append(f"### [{data['title']}]({data['url']})")
+            output.append(f"**Relevance:** {similarity_pct}%\n")
+
+            # Show top excerpt
+            top_chunk = max(data['chunks'], key=lambda c: c.similarity)
+            excerpt = top_chunk.chunk_text[:500] + "..." if len(top_chunk.chunk_text) > 500 else top_chunk.chunk_text
+            output.append(f"> {excerpt}\n")
+
+        return "\n".join(output)
+
+    def format_context_for_llm(self, chunks: List[TranscriptChunk]) -> str:
+        """
+        Format chunks as context for LLM script generation (Tab 2)
+
+        Args:
+            chunks: List of TranscriptChunk objects
+
+        Returns:
+            Formatted string with transcript excerpts for LLM context
+        """
+        if not chunks:
+            return ""
+
+        formatted = []
+        for i, chunk in enumerate(chunks, 1):
+            formatted.append(f"[Excerpt {i} - {chunk.title}]\n{chunk.chunk_text}")
+
+        return "\n\n---\n\n".join(formatted)
+
+
+def create_vectorstore() -> TranscriptVectorStore:
+    """Factory function to create and return a configured vector store"""
+    return TranscriptVectorStore()