problem/solution statement

demo/app.py

@@ -59,6 +59,10 @@ Think of this interface as a lightweight Jupyter notebook: instead of code cells
                 """
             )
 
+        render_problem_cell()
+
+        render_solution_cell()
+
         gemini_key_box = render_setup_cell()
 
         with cell("👩🏻‍⚕️ Health check"):

demo/problem_cell.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+import gradio as gr
+
+try:
+    from yt_dlp import YoutubeDL
+except ImportError:  # pragma: no cover - yt-dlp is in requirements, but guard for clarity
+    YoutubeDL = None  # type: ignore[assignment]
+
+from layout import cell
+
+DEFAULT_VIDEO_URL = "https://www.youtube.com/watch?v=Dvjg8R0jUAk"
+SEARCH_TERM = "Notstaatsvertrag"
+CORRECT_TERM = "NOOTS-Staatsvertrag"
+SEARCH_LANGUAGES = ["de"]
+
+HERE = Path(__file__).parent
+ASSETS_DIR = HERE / "assets"
+DIGITALGIPFEL_IMG = ASSETS_DIR / "digitalgipfel.jpeg"
+
+
+def render_status_box(message: str, tone: str = "placeholder") -> str:
+    tone_class = {
+        "success": "health-success",
+        "fail": "health-fail",
+        "placeholder": "health-placeholder",
+    }.get(tone, "health-placeholder")
+    return f"<div class='health-box {tone_class}'>{message}</div>"
+
+
+def _extract_video_id(video_url: str) -> str | None:
+    parsed = urlparse(video_url.strip())
+    if parsed.netloc.endswith("youtu.be"):
+        return parsed.path.lstrip("/") or None
+    if parsed.netloc.endswith("youtube.com"):
+        query = parse_qs(parsed.query)
+        if "v" in query and query["v"]:
+            return query["v"][0]
+    return None
+
+
+def _fetch_transcript(video_url: str) -> tuple[str | None, str | None]:
+    if YoutubeDL is None:  # pragma: no cover - dependency should always be present
+        return None, "yt-dlp is not installed in this environment."
+    video_id = _extract_video_id(video_url)
+    if not video_id:
+        return None, "That does not look like a valid YouTube URL with a video id."
+    with tempfile.TemporaryDirectory() as tmpdir:
+        output_template = str(Path(tmpdir) / "%(id)s.%(ext)s")
+        ydl_opts = {
+            "skip_download": True,
+            "writeautomaticsub": True,
+            "writesubtitles": False,
+            "subtitleslangs": SEARCH_LANGUAGES,
+            "subtitlesformat": "vtt",
+            "quiet": True,
+            "no_warnings": True,
+            "outtmpl": output_template,
+            "allow_playlist": False,
+        }
+        try:
+            with YoutubeDL(ydl_opts) as ydl:
+                ydl.download([video_url])
+        except Exception as exc:  # noqa: BLE001 - expose yt-dlp failures to the UI
+            return None, f"Could not download auto captions via yt-dlp: {exc}"
+
+        caption_files = sorted(Path(tmpdir).glob("*.vtt"))
+        if not caption_files:
+            return None, (
+                "No German or English automatic captions were available for this video. "
+                "Try providing a different language variant or another clip."
+            )
+        text_chunks = []
+        for file in caption_files:
+            payload = file.read_text(encoding="utf-8", errors="replace")
+            cleaned = _vtt_to_text(payload)
+            if cleaned:
+                text_chunks.append(cleaned)
+
+    readable = " ".join(text_chunks).strip()
+    if not readable:
+        return None, "Transcript was empty. Try again or choose another video."
+    return readable, None
+
+
+def _vtt_to_text(vtt_payload: str) -> str:
+    """Strip timestamps/cue indices from VTT so we can search plain text."""
+    cleaned_lines = []
+    for raw_line in vtt_payload.splitlines():
+        line = raw_line.strip()
+        if not line or line.upper().startswith("WEBVTT"):
+            continue
+        if "-->" in line:  # timestamp cue
+            continue
+        if line.isdigit():  # cue index
+            continue
+        cleaned_lines.append(line)
+    return " ".join(cleaned_lines)
+
+
+def analyze_transcript(video_url: str | None = None) -> tuple[str, str]:
+    transcript_text, error = _fetch_transcript(video_url or DEFAULT_VIDEO_URL)
+    if error:
+        return render_status_box(error, "fail"), ""
+
+    normalized = transcript_text.lower()
+    found_term = SEARCH_TERM.lower() in normalized
+
+    if found_term:
+        headline = (
+            f"🚨 We spotted “{SEARCH_TERM}” in this transcript — a hallucinated emergency-state framing."
+        )
+        tone = "fail"
+    else:
+        headline = (
+            f"✅ “{SEARCH_TERM}” does **not** show up in the transcript. "
+            f"The speaker consistently references {CORRECT_TERM}."
+        )
+        tone = "success"
+
+    result_line = (
+        "Result: the ASR output hallucinated an emergency-state treaty reference."
+        if found_term
+        else "Result: the captions stay with NOOTS – no emergency-state treaty was mentioned."
+    )
+    body = [
+        f"**Search term**: “{SEARCH_TERM}”.",
+        f"**{result_line}**",
+        "",
+        f"- **{SEARCH_TERM}** → “emergency state treaty” – suggests constitutional crisis powers.",
+        f"- **{CORRECT_TERM}** → “National Once-Only Technical System treaty” – "
+        "a data-sharing infrastructure for German public administrations.",
+        "",
+        "Mishearing “NOOTS” as “Not” is an *ASR hallucination*. When an LLM then riffs on "
+        "that wrong token, it creates a second-layer hallucination that falsely claims an emergency "
+        "law was debated. In reality, the Smart Country convention session discussed register modernisation and once-only data exchange.",
+    ]
+    return render_status_box(headline, tone), "\n".join(body)
+
+
+def render_problem_cell() -> None:
+    with cell("ℹ️ Problem: ASR hallucinations"):
+        gr.Markdown(
+            f"""### 👩🏻‍🏫 Background
+Automatically generated transcripts and subtitles provided by video or podcast distribution sites may appear as a straightforward
+source to ground summaries or chat-with-your-video use cases in. With YouTube in particular, however, there is a systemic hallucination risk:
+the anti-money laundering directive "NIS2" may become "these two", the IT concept of "interoperability" may become the unrelated quality of
+"endurability"... and the data sharing treaty for public administration 🇩🇪 "NOOTS-Staatsvertrag" may become emergency state powers
+🇩🇪 "Notstaatsvertrag". Particularly with non-English languages or non-native speakers of the English language, the hallucination risk
+from Automatic Speech Recognition (ASR) and the hallucination risk from chatbot Large Language Models compound - rendering e.g. ChatGPT Atlas
+a brittle tool for such tasks.
+            """,
+        )
+
+        gr.Image(
+            value=DIGITALGIPFEL_IMG,
+            show_label=True,
+            interactive=False,            
+            elem_id="digitalgipfel-photo",
+            label='ASR trip: "asset" turns into "acid"'
+        )
+
+        gr.Markdown("""### 💁🏻‍♀️ Demo
+                    We're going to download the YouTube subtitles of a panel discussion
+                    recorded at the Smart Country Convention 2025 - and check if the ASR hallucinated emergency state powers (❌) or got
+                    the German language term "NOOTS-Staatsvertrag" right (✅). The goal is to make it visible how ASR recognition could
+                    cause faulty LLM interpretation built on top of them.
+                    """)
+
+        url_box = gr.Textbox(
+            label="YouTube video URL",
+            value=DEFAULT_VIDEO_URL,
+            interactive=False,
+        )
+        check_button = gr.Button("Check transcript for “Notstaatsvertrag”", variant="primary")
+        result_panel = gr.HTML(
+            value=render_status_box(
+                "👉 Click “Check transcript…” to fetch the captions and verify what was actually said.",
+                "placeholder",
+            )
+        )
+        result_details = gr.Markdown(visible=True)
+        check_button.click(
+            fn=analyze_transcript,
+            inputs=url_box,
+            outputs=[result_panel, result_details],
+            queue=False,
+        )

demo/solution_cell.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import gradio as gr
+
+from layout import cell
+
+
+def render_solution_cell() -> None:
+    with cell("✅ Solution: contextual biasing through priors"):
+        gr.Markdown(
+            """
+### 👩🏻‍🏫 Background
+Automatic speech recognition systems can be steered by giving them *context* up front. OpenAI Whisper, for example, supports a **textual
+prompt** that lists likely names, abbreviations, product names, or domain terms. When the audio is ambiguous, the model can bias its
+choices toward those tokens instead of guessing from scratch. This works especially well in high-noise conference settings or niche domains
+where participant names and acronyms rarely appear in generic training data.
+
+In Aileen 3, we generalise this idea of “context” into **priors**: structured hints about the user, their expectations, prior knowledge, and
+the media itself (title, channel, description…). On a high level (Aileen 3 Agent), priors are not facts the model has to re-discover – they are the baseline
+that makes it easier to spot surprises, new actors, and genuinely novel claims later on. On a low level (Aileen 3 Core), this concept applies
+to transcription: spelling out how the 🇩🇪 “NOOTS-Staatsvertrag” (data sharing treaty) is supposed to look in writing gives the model a
+strong prior against hallucinating emergency state super powers (🇩🇪 “Notstaatsvertrag”).
+
+Multi-modal models such as Google Gemini go one step further than Whisper: they may even accept priors that are not plain text.
+Images of slides from a talk,
+agenda screenshots, or diagrams can be ingested alongside the audio to potentially provide a much richer prior. Internally, the Aileen MCP already
+extracts representative slide images from long-form talks so that this kind of multi-modal prior can be used in downstream analysis – we
+will lean on the same building blocks for transcription.
+
+### 💁🏻‍♀️ Demo
+In the demo below, we are going to treat the **YouTube video description** of the Smart Country Convention session as a prior. While the Aileen MCP
+server's transcription tool allows a user supplied text prior to be passed, we will rely on its internal extraction of the video
+metadata. That way, the Google Gemini model sees both the audio of the talk and a text prior that
+spells out the intended terminology.
+
+The goal is to see whether supplying the description as a prior helps the transcription stay anchored on the term of the
+data sharing treaty (NOOTS-Staatsvertrag) instead of hallucinating emergency state (“Notstaatsvertrag”) when the audio is noisy or ambiguous.
+
+Before running the demo, we will first run the health check cell to verify that ffmpeg, yt-dlp, the Aileen MCP server, and your Gemini API
+key are all wired up correctly.
+            """
+        )
+