Feat/enhance feature teacher (#6)

* lesson plan enhancement

* models agent

* education pptx

* test education wip

* wip memory gen

* wip fix model running

.cursor/plans/lesson_slides_search_rag_832c4077.plan.md

@@ -0,0 +1,282 @@
+---
+name: Lesson slides search RAG
+overview: Add source-mode dropdown (None / Web search / RAG), a search-workflow dropdown (Two-step vs Auto search) for web mode, optional URL/file inputs and session picker, and wire discover/ingest/retrieve into slide outline generation.
+todos:
+  - id: extend-models
+    content: Add source_mode, search_workflow, urls, files, session_id, doc_ids to EducationPptxInput
+    status: completed
+  - id: runner-sources
+    content: "Extend run_education_pptx: discover or ingest (web/rag) → retrieve → pass context to _generate_outline"
+    status: completed
+  - id: prompts-context
+    content: Update education_outline_user/system to inject retrieved source excerpts
+    status: completed
+  - id: gradio-ui
+    content: Add source mode + search workflow dropdowns, Discover button (two-step), URL/file/session/doc controls, visibility toggles, status output
+    status: completed
+  - id: tests-docs
+    content: Add agent tests for source modes and search workflows; update USAGE.md
+    status: completed
+isProject: false
+---
+
+# Lesson Slides — Web Search + RAG Integration
+
+## Goal
+
+Extend the **Lesson slides** tab so teachers can ground slide outlines on external sources.
+
+### Source mode dropdown
+
+| Mode | Behavior |
+|------|----------|
+| **None** | Current flow — local model only (no ingest/retrieve) |
+| **Web search** | Discover and ingest web sources for the lesson topic, then retrieve chunks and draft outline |
+| **RAG** | Use **existing ResearchMind session** and/or **URLs/files entered on this tab** — ingest if needed, retrieve, then draft outline |
+
+### Search workflow dropdown (Web search only)
+
+Mirrors ResearchMind [`INGEST_MODES`](apps/gradio-space/src/gradio_space/tabs/research_mind.py):
+
+| Workflow | Label in UI | Behavior |
+|----------|-------------|----------|
+| **Two-step** | `Two-step search (suggest & confirm)` | **Step 1:** **Discover sources** runs `run_researchmind_discover` → verified URLs in checkbox list. **Step 2:** User selects URLs → **Generate lesson slides** ingests selection, retrieves, builds outline. |
+| **Auto search** | `Auto search & ingest` | **Generate lesson slides** alone runs `run_researchmind_ingest(auto_search=True)` → retrieve → outline in one click. |
+
+All modes still produce the same outputs (preview, `.pptx`, `.docx`, `.html`, trace).
+
+## Architecture
+
+```mermaid
+flowchart TB
+  subgraph ui [education_pptx.py]
+    Topic[Lesson topic]
+    SourceMode[Source mode dropdown]
+    SearchFlow[Search workflow dropdown]
+    Discover[Discover sources button]
+    URLChoices[Suggested URLs checkbox]
+    URLs[URLs textarea]
+    Files[PDF/DOCX upload]
+    Session[Session dropdown]
+    Docs[Doc checkbox group]
+    Gen[Generate lesson slides]
+  end
+
+  subgraph runner [AgentRunner]
+    DiscoverFn[run_researchmind_discover]
+    Ingest[run_researchmind_ingest]
+    Retrieve[retrieve + format_context_block]
+    Outline[_generate_outline with context]
+    Export[create_pptx / docx / html]
+  end
+
+  SourceMode --> SearchFlow
+  Discover --> DiscoverFn
+  DiscoverFn --> URLChoices
+  Gen --> Ingest
+  URLChoices --> Ingest
+  URLs --> Ingest
+  Files --> Ingest
+  Session --> Retrieve
+  Docs --> Retrieve
+  Topic --> DiscoverFn
+  Topic --> Ingest
+  Topic --> Retrieve
+  Ingest --> Retrieve
+  Retrieve --> Outline
+  Outline --> Export
+```
+
+Reuse existing ResearchMind primitives — no new search/RAG library code required:
+
+- [`run_researchmind_discover`](libs/agent/src/agent/runner.py) — web search → verified URL list (two-step step 1)
+- [`run_researchmind_ingest`](libs/agent/src/agent/runner.py) — ingest URLs/files; `auto_search=True` for auto workflow
+- [`retrieve`](libs/researchmind/src/researchmind/retrieve.py) + [`format_context_block`](libs/researchmind/src/researchmind/citations.py) — context for LLM
+- [`research_helpers.py`](apps/gradio-space/src/gradio_space/research_helpers.py) — session/doc dropdown helpers
+
+## 1. UI changes — [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py)
+
+Add a **Research sources** block between the topic row and **Generate lesson slides**:
+
+```python
+SOURCE_MODES = [
+    ("None (model only)", "none"),
+    ("Web search", "web"),
+    ("RAG (indexed sources)", "rag"),
+]
+
+SEARCH_WORKFLOWS = [
+    ("Two-step search (suggest & confirm)", "two_step"),
+    ("Auto search & ingest", "auto"),
+]
+```
+
+**Controls:**
+
+| Control | When visible | Purpose |
+|---------|--------------|---------|
+| `source_mode` | always | None / Web search / RAG |
+| `search_workflow` | `source_mode == web` | Two-step vs Auto search |
+| `discover_btn` | `source_mode == web` and `search_workflow == two_step` | Runs discover only |
+| `url_choices` | `source_mode == web` and `search_workflow == two_step` | CheckboxGroup of suggested URLs |
+| `urls_text` | `source_mode` is `web` or `rag` | Manual URLs (merged with selected checkboxes on generate) |
+| `upload_files` | `source_mode` is `web` or `rag` | PDF/DOCX upload |
+| `session_dd` | `source_mode == rag` | Existing ResearchMind session |
+| `doc_dd` | `source_mode == rag` | Limit retrieve to specific docs |
+| `source_status` | always (below generate) | Discover / ingest / retrieve summary |
+
+**Visibility rules** (`source_mode.change` + `search_workflow.change`):
+
+- **None:** hide all source controls except `source_status`
+- **Web + Two-step:** show `search_workflow`, `discover_btn`, `url_choices`, `urls_text`, `upload_files`; hide session/doc
+- **Web + Auto:** show `search_workflow`, `urls_text`, `upload_files`; hide `discover_btn`, `url_choices`, session/doc
+- **RAG:** show `urls_text`, `upload_files`, `session_dd`, `doc_dd`; hide `search_workflow`, discover, url_choices
+
+**Handlers:**
+
+1. **`discover_lesson_sources(topic, session_id)`** — mirrors ResearchMind `discover_sources` with `ingest_mode="suggest"`:
+   - `run_researchmind_discover(topic, auto_search=False, ...)`
+   - Updates `url_choices`, `source_status`, `session_dd` (lesson session id)
+2. **`generate_lesson_slides(...)`** — extended signature; behavior by mode:
+   - **none:** current path
+   - **web + two_step:** ingest merged URLs (selected checkboxes + pasted lines + files), `auto_search=False`; error if nothing selected and no files
+   - **web + auto:** ingest with `auto_search=True` (+ optional pasted URLs/files)
+   - **rag:** ingest pasted URLs/files if any; use session + doc scope; error if no indexed docs after ingest
+
+**Allowed paths:** extend `gradio_allowed_paths()` to include ResearchMind data dir (mirror [`research_mind.py`](apps/gradio-space/src/gradio_space/tabs/research_mind.py)), merged in [`app.py`](apps/gradio-space/src/gradio_space/app.py) if not already.
+
+## 2. Agent model — [`models.py`](libs/agent/src/agent/models.py)
+
+Extend `EducationPptxInput`:
+
+```python
+class EducationPptxInput(BaseModel):
+    topic: str
+    grade: str
+    slide_count: int = Field(ge=3, le=8)
+    source_mode: Literal["none", "web", "rag"] = "none"
+    search_workflow: Literal["two_step", "auto"] = "two_step"  # only used when source_mode == "web"
+    urls: list[str] = Field(default_factory=list)
+    files: list[Path] = Field(default_factory=list)
+    session_id: str | None = None
+    doc_ids: list[str] = Field(default_factory=list)
+```
+
+Add `source_summary: str` on `AgentResult` for UI status line.
+
+## 3. Runner orchestration — [`runner.py`](libs/agent/src/agent/runner.py)
+
+Extend `run_education_pptx()`:
+
+**Phase A — Gather sources (when `source_mode != "none"`):**
+
+- **`web` + `auto`:** `run_researchmind_ingest(topic, urls, files, auto_search=True, session_id=...)`
+- **`web` + `two_step`:** `run_researchmind_ingest(topic, urls, files, auto_search=False, ...)` — caller must pass URLs from discover selection + manual paste; runner does not auto-discover on generate
+- **`rag`:** if URLs/files provided → `run_researchmind_ingest(..., auto_search=False)`. Resolve `session_id` via `_ensure_session()`. Validate session has docs (or ingest succeeded) before retrieve
+
+Optional: add `discover_lesson_urls()` thin wrapper on runner that only calls `run_researchmind_discover` (used by Discover button, not by generate in two-step mode).
+
+**Phase B — Retrieve context:**
+
+```python
+chunks = retrieve(req.topic, store, session_id=..., doc_ids=...)
+context, citations = format_context_block(chunks)
+```
+
+Log retrieve + citation count in `TraceRecorder`.
+
+**Phase C — Outline with context:**
+
+Pass `context` into `_generate_outline()` when non-empty.
+
+**Graceful fallback:** if discover/ingest finds nothing or retrieve returns 0 chunks, log trace note and continue with model-only outline plus UI warning in `source_status`.
+
+## 4. Prompt changes — [`prompts.py`](libs/agent/src/agent/prompts.py)
+
+Add optional context block to user prompt:
+
+```python
+def education_outline_user(req: EducationPptxInput, *, source_context: str = "") -> str:
+    ...
+    if source_context.strip():
+        base += (
+            "\n\nUse the following retrieved source excerpts as factual grounding. "
+            "Prefer these over general knowledge when they apply. "
+            "Do not invent citations in the JSON output.\n\n"
+            f"{source_context}\n"
+        )
+    return base + "\nReturn JSON only."
+```
+
+Update `education_outline_system()` rules for age-appropriate bullets consistent with sources when context is present.
+
+## 5. Helper extraction (minimal)
+
+Add thin helpers in [`research_helpers.py`](apps/gradio-space/src/gradio_space/research_helpers.py):
+
+- `parse_urls_text(text: str) -> list[str]`
+- `merge_lesson_urls(pasted: str, selected: list[str]) -> list[str]` — dedupe like ResearchMind `ingest_selected`
+
+Reuse existing `list_session_choices`, `refresh_doc_choices`, `format_ingest_status`, `memory_summary`.
+
+## 6. Tests
+
+Add [`libs/agent/tests/test_education_sources.py`](libs/agent/tests/test_education_sources.py):
+
+- `none` — skips ingest/retrieve
+- `web` + `auto` — ingest with `auto_search=True`
+- `web` + `two_step` — ingest with `auto_search=False`, URLs from caller only
+- `rag` — session + doc_ids, no auto-search
+- Context injected into outline prompt when chunks exist
+- Two-step generate with empty URL selection returns clear error (no silent auto-search)
+
+Follow patterns in [`test_research_runner.py`](libs/agent/tests/test_research_runner.py).
+
+## 7. Docs
+
+Update [`USAGE.md`](USAGE.md) Lesson slides section:
+
+- Three source modes
+- **Web search:** Two-step (Discover → select → Generate) vs Auto (Generate only)
+- Network required for discover/auto web search
+- RAG combines ResearchMind sessions with pasted URLs/uploads
+
+## Key files to change
+
+| File | Change |
+|------|--------|
+| [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py) | Source mode + search workflow UI, Discover handler, generate wiring |
+| [`runner.py`](libs/agent/src/agent/runner.py) | Branch on `search_workflow`; ingest → retrieve → grounded outline |
+| [`models.py`](libs/agent/src/agent/models.py) | `search_workflow` + source fields on `EducationPptxInput` |
+| [`prompts.py`](libs/agent/src/agent/prompts.py) | Context-aware user prompt |
+| [`research_helpers.py`](apps/gradio-space/src/gradio_space/research_helpers.py) | URL parse/merge helpers |
+| [`app.py`](apps/gradio-space/src/gradio_space/app.py) | Merge ResearchMind allowed paths if needed |
+| [`USAGE.md`](USAGE.md) | User-facing docs |
+
+## UX summary
+
+```
+[Lesson topic] [Grade] [Content slides]
+
+[Source mode ▼]  None | Web search | RAG
+
+  (when Web search)
+  [Search workflow ▼]  Two-step search | Auto search & ingest
+
+  (when Web + Two-step)
+  [Discover sources]  → populates checkbox list
+  [☑ Suggested URLs]
+
+  (when Web or RAG)
+  [URLs textarea]
+  [Upload PDF/DOCX]
+
+  (when RAG)
+  [Session ▼] [Documents ☑]
+
+[Generate lesson slides]
+Source status: "Found 5 URLs" / "Ingested 2 sources; 4 passages used"
+[Slide preview | Outline] ...
+```
+
+**Two-step** gives teachers control over which sources feed the lesson (same UX as ResearchMind Suggest mode). **Auto search** optimizes for speed when confirmation is not needed.

USAGE.md

@@ -2,7 +2,7 @@
 
 How to run the **Lesson Agent** Gradio app locally, test it in Docker, and deploy to a Hugging Face Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).
 
-The primary UI is the **Lesson slides** tab (topic → local model outline → downloadable `.pptx`). The **Chat (debug)** tab tests the underlying model.
+The primary UI is the **Lesson slides** tab (topic → local model outline → downloadable `.pptx`). Use **ResearchMind** for corpus Q&A, or ground lessons directly from the Lesson tab. The **Chat (debug)** tab tests the underlying model.
 
 ## Prerequisites
 
@@ -51,6 +51,27 @@ Open [http://localhost:7860](http://localhost:7860).
 
 The model loads on the **first Generate** (Lesson slides) or chat message. Agent traces are written to `outputs/traces/`. After code changes, restart the process to pick up updates.
 
+### Lesson slides — research sources
+
+The **Lesson slides** tab can ground outlines on external sources before building the deck:
+
+| Source mode | What it does |
+| ----------- | ------------ |
+| **None (model only)** | Default — outline from the local model only |
+| **Web search** | Search the web for the lesson topic, ingest pages, retrieve passages, then draft slides |
+| **RAG (indexed sources)** | Use a **ResearchMind session** and/or URLs/files you provide on this tab |
+
+When **Web search** is selected, choose a **search workflow**:
+
+| Workflow | Steps |
+| -------- | ----- |
+| **Two-step search (suggest & confirm)** | Click **Discover sources** → select URLs → **Generate lesson slides** |
+| **Auto search & ingest** | Click **Generate lesson slides** only — search, ingest, and outline in one step |
+
+**RAG** mode accepts an optional ResearchMind session, document checkboxes (scope), pasted URLs, and PDF/DOCX uploads. Indexed content is retrieved and passed to the outline step.
+
+Web discover/auto search requires network access. MemRAG data is stored under `RESEARCHMIND_DATA_DIR` (default `outputs/researchmind`).
+
 ### 5. Upload agent trace (Sharing is Caring badge)
 
 ```bash

apps/gradio-space/src/gradio_space/research_helpers.py

@@ -121,6 +121,15 @@ def memory_summary(session_id: str) -> str:
     return "\n".join(lines)
 
 
+def parse_urls_text(text: str) -> list[str]:
+    return [line.strip() for line in (text or "").splitlines() if line.strip()]
+
+
+def merge_lesson_urls(pasted: str, selected: list[str] | None) -> list[str]:
+    direct = parse_urls_text(pasted)
+    return list(dict.fromkeys([*direct, *(selected or [])]))
+
+
 def rag_scope_hint(session_id: str, doc_ids: list[str] | None) -> str:
     if doc_ids:
         return f"RAG scope: **{len(doc_ids)}** selected document(s)."

apps/gradio-space/src/gradio_space/tabs/education_pptx.py

@@ -5,7 +5,37 @@ import gradio as gr
 from agent.runner import AgentRunner
 from agent.tools.pptx import get_outputs_dir
 from gradio_space.model_loading import ensure_model_loaded, get_active_model_key, model_status
+from gradio_space.research_helpers import (
+    list_session_choices,
+    merge_lesson_urls,
+    refresh_doc_choices,
+    refresh_sessions,
+)
 from inference.factory import get_backend
+from researchmind.config import get_config
+
+SOURCE_MODES = [
+    ("None (model only)", "none"),
+    ("Web search", "web"),
+    ("RAG (indexed sources)", "rag"),
+]
+
+SEARCH_WORKFLOWS = [
+    ("Two-step search (suggest & confirm)", "two_step"),
+    ("Auto search & ingest", "auto"),
+]
+
+_SOURCE_LABEL_TO_VALUE = {label: value for label, value in SOURCE_MODES}
+_WORKFLOW_LABEL_TO_VALUE = {label: value for label, value in SEARCH_WORKFLOWS}
+
+
+def _source_mode_value(label: str) -> str:
+    return _SOURCE_LABEL_TO_VALUE.get(label, "none")
+
+
+def _search_workflow_value(label: str) -> str:
+    return _WORKFLOW_LABEL_TO_VALUE.get(label, "two_step")
+
 
 def _error_html(message: str) -> str:
     safe = (
@@ -19,19 +49,106 @@ def _error_html(message: str) -> str:
     )
 
 
+def _empty_outputs(message: str) -> tuple:
+    return (
+        message,
+        _error_html(message),
+        [],
+        None,
+        None,
+        None,
+        message,
+        message,
+        message,
+    )
+
+
+def update_source_visibility(source_mode_label: str, search_workflow_label: str):
+    mode = _source_mode_value(source_mode_label)
+    workflow = _search_workflow_value(search_workflow_label)
+    is_web = mode == "web"
+    is_rag = mode == "rag"
+    is_sources = is_web or is_rag
+    is_two_step = is_web and workflow == "two_step"
+    return (
+        gr.update(visible=is_web),
+        gr.update(visible=is_two_step),
+        gr.update(visible=is_two_step),
+        gr.update(visible=is_sources),
+        gr.update(visible=is_sources),
+        gr.update(visible=is_rag),
+        gr.update(visible=is_rag),
+    )
+
+
+def discover_lesson_sources(
+    topic: str,
+    session_id: str,
+) -> tuple[str, object, object]:
+    model_key = get_active_model_key()
+    load_error = ensure_model_loaded(model_key)
+    if load_error:
+        return load_error, gr.update(choices=[], value=[]), refresh_sessions(session_id)
+
+    if not topic.strip():
+        msg = "Enter a lesson topic to discover sources."
+        return msg, gr.update(choices=[], value=[]), refresh_sessions(session_id)
+
+    try:
+        runner = AgentRunner()
+        discover = runner.run_researchmind_discover(
+            topic=topic,
+            auto_search=False,
+            session_id=session_id or None,
+            model_key=model_key,
+            backend=get_backend(model_key),
+        )
+        choices = discover.suggested_urls
+        if not choices:
+            summary = (
+                "No verified URLs found. Try a more specific topic, paste URLs manually, "
+                "or switch to **Auto search & ingest**."
+            )
+        else:
+            summary = (
+                f"Found **{len(choices)}** verified URL(s). Select sources, then click "
+                "**Generate lesson slides**."
+            )
+        return (
+            summary,
+            gr.update(choices=choices, value=choices),
+            refresh_sessions(discover.session_id),
+        )
+    except Exception as exc:  # noqa: BLE001
+        msg = f"Discover error: {exc}"
+        return msg, gr.update(choices=[], value=[]), refresh_sessions(session_id)
+
+
 def generate_lesson_slides(
     topic: str,
     grade: str,
     slide_count: int,
-) -> tuple[str, str, list[str], str | None, str | None, str | None, str, str]:
+    source_mode_label: str,
+    search_workflow_label: str,
+    urls_text: str,
+    selected_urls: list[str],
+    upload_files: list[str] | None,
+    session_id: str,
+    doc_ids: list[str] | None,
+) -> tuple[str, str, list[str], str | None, str | None, str | None, str, str, str]:
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
     if load_error:
-        return load_error, _error_html(load_error), [], None, None, None, load_error, load_error
+        return _empty_outputs(load_error)
 
     if not topic.strip():
         message = "Please enter a lesson topic."
-        return message, _error_html(message), [], None, None, None, message, message
+        return _empty_outputs(message)
+
+    source_mode = _source_mode_value(source_mode_label)
+    search_workflow = _search_workflow_value(search_workflow_label)
+    merged_urls = merge_lesson_urls(urls_text, selected_urls)
+    files = [Path(p) for p in (upload_files or [])]
 
     try:
         runner = AgentRunner()
@@ -41,10 +158,16 @@ def generate_lesson_slides(
             slide_count=int(slide_count),
             model_key=model_key,
             backend=get_backend(model_key),
+            source_mode=source_mode,  # type: ignore[arg-type]
+            search_workflow=search_workflow,  # type: ignore[arg-type]
+            urls=merged_urls,
+            files=files,
+            session_id=session_id or None,
+            doc_ids=doc_ids or [],
         )
     except Exception as exc:  # noqa: BLE001 — show agent errors in UI
         message = f"Agent error: {exc}"
-        return message, _error_html(message), [], None, None, None, message, message
+        return _empty_outputs(message)
 
     gallery = [str(Path(p).resolve()) for p in result.preview_images]
     trace_summary = (
@@ -52,6 +175,7 @@ def generate_lesson_slides(
         f"model `{result.trace.model}`\n\n"
         f"Trace saved: `{result.trace_path}`"
     )
+    source_status = result.source_summary or "_No external sources used (model only)._"
     return (
         result.markdown_preview,
         result.html_preview,
@@ -61,6 +185,7 @@ def generate_lesson_slides(
         str(Path(result.html_export_path).resolve()),
         trace_summary,
         result.trace.to_json(),
+        source_status,
     )
 
 
@@ -72,7 +197,7 @@ def build_education_pptx_tab() -> None:
 ### Lesson slide builder
 
 Enter a topic and grade level. A **local small model** drafts the outline;
-the agent then builds a downloadable PowerPoint — no cloud LLM API.
+optionally ground it with **web search** or **RAG** from indexed sources.
 """
     )
     gr.Markdown(model_status(model_key))
@@ -95,7 +220,55 @@ the agent then builds a downloadable PowerPoint — no cloud LLM API.
             label="Content slides",
         )
 
+    gr.Markdown("#### Research sources (optional)")
+    with gr.Row():
+        source_mode = gr.Dropdown(
+            label="Source mode",
+            choices=[m[0] for m in SOURCE_MODES],
+            value=SOURCE_MODES[0][0],
+        )
+        search_workflow = gr.Dropdown(
+            label="Search workflow",
+            choices=[m[0] for m in SEARCH_WORKFLOWS],
+            value=SEARCH_WORKFLOWS[0][0],
+            visible=False,
+        )
+
+    with gr.Row():
+        discover_btn = gr.Button("Discover sources", variant="secondary", visible=False)
+        session_dd = gr.Dropdown(
+            label="ResearchMind session",
+            choices=list_session_choices(),
+            value="",
+            visible=False,
+        )
+
+    url_choices = gr.CheckboxGroup(
+        label="Suggested URLs to use",
+        choices=[],
+        visible=False,
+    )
+    urls_text = gr.Textbox(
+        label="URLs (one per line, optional)",
+        lines=3,
+        placeholder="https://en.wikipedia.org/wiki/...",
+        visible=False,
+    )
+    upload_files = gr.File(
+        label="Upload PDF or DOCX",
+        file_count="multiple",
+        file_types=[".pdf", ".docx"],
+        visible=False,
+    )
+    doc_dd = gr.CheckboxGroup(
+        label="Documents in session (RAG scope)",
+        choices=[],
+        value=[],
+        visible=False,
+    )
+
     generate_btn = gr.Button("Generate lesson slides", variant="primary")
+    source_status = gr.Markdown(value="_No sources gathered yet._")
 
     with gr.Tabs():
         with gr.Tab("Slide preview"):
@@ -139,9 +312,56 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
     with gr.Accordion("Trace summary", open=False):
         trace_summary = gr.Markdown()
 
+    source_controls = [
+        search_workflow,
+        discover_btn,
+        url_choices,
+        urls_text,
+        upload_files,
+        session_dd,
+        doc_dd,
+    ]
+
+    def _refresh_visibility(mode_label: str, workflow_label: str):
+        return update_source_visibility(mode_label, workflow_label)
+
+    source_mode.change(
+        fn=_refresh_visibility,
+        inputs=[source_mode, search_workflow],
+        outputs=source_controls,
+    )
+    search_workflow.change(
+        fn=_refresh_visibility,
+        inputs=[source_mode, search_workflow],
+        outputs=source_controls,
+    )
+
+    session_dd.change(
+        fn=refresh_doc_choices,
+        inputs=[session_dd, doc_dd],
+        outputs=[doc_dd],
+    )
+
+    discover_btn.click(
+        fn=discover_lesson_sources,
+        inputs=[topic, session_dd],
+        outputs=[source_status, url_choices, session_dd],
+    )
+
     generate_btn.click(
         fn=generate_lesson_slides,
-        inputs=[topic, grade, slide_count],
+        inputs=[
+            topic,
+            grade,
+            slide_count,
+            source_mode,
+            search_workflow,
+            urls_text,
+            url_choices,
+            upload_files,
+            session_dd,
+            doc_dd,
+        ],
         outputs=[
             outline_preview,
             slide_preview,
@@ -151,6 +371,7 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
             html_file,
             trace_summary,
             trace_box,
+            source_status,
         ],
     )
 
@@ -158,4 +379,7 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
 def gradio_allowed_paths() -> list[str]:
     """Paths Gradio must be allowed to read for previews and downloads."""
     root = get_outputs_dir().resolve()
-    return [str(root)]
+    cfg = get_config()
+    rm_root = cfg.data_dir.resolve()
+    rm_root.mkdir(parents=True, exist_ok=True)
+    return [str(root), str(rm_root)]

libs/agent/src/agent/models.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from pathlib import Path
+from typing import Literal
+
 from pydantic import BaseModel, Field
 
 
@@ -18,6 +21,12 @@ class EducationPptxInput(BaseModel):
     topic: str
     grade: str
     slide_count: int = Field(ge=3, le=8)
+    source_mode: Literal["none", "web", "rag"] = "none"
+    search_workflow: Literal["two_step", "auto"] = "two_step"
+    urls: list[str] = Field(default_factory=list)
+    files: list[Path] = Field(default_factory=list)
+    session_id: str | None = None
+    doc_ids: list[str] = Field(default_factory=list)
 
 
 class Citation(BaseModel):
@@ -57,6 +66,7 @@ class ResearchIngestResult(BaseModel):
     session_id: str
     ingested: list[str]
     skipped: list[str]
+    doc_ids: list[str] = Field(default_factory=list)
     failures: list[IngestFailure] = Field(default_factory=list)
     doc_count: int
     chunk_count: int

libs/agent/src/agent/prompts.py

@@ -27,17 +27,25 @@ JSON schema:
 Rules:
 - Use exactly the requested number of content slides (title slide is added separately by the tool).
 - Bullets should be short, age-appropriate, and factual.
+- When source excerpts are provided, prefer them over general knowledge and keep bullets consistent with those sources.
 - speaker_note is optional but helpful for each slide.
 """
 
 
-def education_outline_user(req: EducationPptxInput) -> str:
-    return (
+def education_outline_user(req: EducationPptxInput, *, source_context: str = "") -> str:
+    base = (
         f"Topic: {req.topic}\n"
         f"Grade level: {req.grade}\n"
         f"Number of content slides: {req.slide_count}\n"
-        "Return JSON only."
     )
+    if source_context.strip():
+        base += (
+            "\nUse the following retrieved source excerpts as factual grounding. "
+            "Prefer these over general knowledge when they apply. "
+            "Do not invent citations in the JSON output.\n\n"
+            f"{source_context}\n"
+        )
+    return base + "\nReturn JSON only."
 
 
 def education_outline_repair(

libs/agent/src/agent/runner.py

@@ -4,11 +4,13 @@ import json
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 from inference.base import InferenceBackend
+from researchmind.citations import format_context_block
 from researchmind.extract import extract_docx
 from researchmind.ingest import IngestPipeline
+from researchmind.retrieve import retrieve
 
 from agent.models import (
     Citation,
@@ -47,6 +49,7 @@ class AgentResult:
     trace: TraceRecorder
     trace_path: str
     outline: SlideOutline
+    source_summary: str = ""
 
 
 class AgentRunner:
@@ -66,18 +69,42 @@ class AgentRunner:
         slide_count: int,
         model_key: str,
         backend: InferenceBackend,
+        source_mode: Literal["none", "web", "rag"] = "none",
+        search_workflow: Literal["two_step", "auto"] = "two_step",
+        urls: list[str] | None = None,
+        files: list[Path] | None = None,
+        session_id: str | None = None,
+        doc_ids: list[str] | None = None,
     ) -> AgentResult:
         skill = self._skills.get(EDUCATION_PPTX_SKILL)
-        req = EducationPptxInput(topic=topic.strip(), grade=grade, slide_count=slide_count)
+        req = EducationPptxInput(
+            topic=topic.strip(),
+            grade=grade,
+            slide_count=slide_count,
+            source_mode=source_mode,
+            search_workflow=search_workflow,
+            urls=urls or [],
+            files=files or [],
+            session_id=session_id or None,
+            doc_ids=doc_ids or [],
+        )
 
         trace = TraceRecorder(
             skill=skill.name,
             model=model_key,
-            user_input=req.model_dump(),
+            user_input=req.model_dump(mode="json"),
         )
 
         backend.load()
-        outline = self._generate_outline(skill, req, backend, trace)
+        source_context, source_summary, active_session = self._gather_lesson_source_context(
+            req, backend, model_key, trace
+        )
+        if active_session:
+            req = req.model_copy(update={"session_id": active_session})
+
+        outline = self._generate_outline(
+            skill, req, backend, trace, source_context=source_context
+        )
         tool = self._tools.get("create_pptx")
         pptx_path = tool.handler(outline, run_id=trace.run_id)
         trace.log_tool(
@@ -118,7 +145,102 @@ class AgentRunner:
             trace=trace,
             trace_path=str(trace_path),
             outline=outline,
+            source_summary=source_summary,
+        )
+
+    def _gather_lesson_source_context(
+        self,
+        req: EducationPptxInput,
+        backend: InferenceBackend,
+        model_key: str,
+        trace: TraceRecorder,
+    ) -> tuple[str, str, str | None]:
+        if req.source_mode == "none":
+            return "", "", None
+
+        pipeline = IngestPipeline()
+        store = pipeline.store
+        session_id = req.session_id
+        ingest_summary = ""
+        ingest: ResearchIngestResult | None = None
+
+        if req.source_mode == "web":
+            if req.search_workflow == "two_step" and not req.urls and not req.files:
+                raise ValueError(
+                    "Two-step web search requires selected URLs, pasted URLs, or uploaded files. "
+                    "Click **Discover sources** first, then select sources before generating."
+                )
+            auto_search = req.search_workflow == "auto"
+            ingest = self.run_researchmind_ingest(
+                topic=req.topic,
+                urls=req.urls,
+                files=req.files,
+                auto_search=auto_search,
+                session_id=session_id,
+                model_key=model_key,
+                backend=backend,
+            )
+            session_id = ingest.session_id
+            ingest_summary = ingest.message
+            trace.log_note(ingest.message, phase="lesson_ingest", session_id=session_id)
+        elif req.source_mode == "rag":
+            session_id = self._ensure_session(store, session_id, topic=req.topic)
+            if req.urls or req.files:
+                ingest = self.run_researchmind_ingest(
+                    topic=req.topic,
+                    urls=req.urls,
+                    files=req.files,
+                    auto_search=False,
+                    session_id=session_id,
+                    model_key=model_key,
+                    backend=backend,
+                )
+                session_id = ingest.session_id
+                ingest_summary = ingest.message
+                trace.log_note(ingest.message, phase="lesson_ingest", session_id=session_id)
+
+            doc_count = len(store.list_documents(session_id=session_id))
+            resolved = self._lesson_doc_ids(store, session_id, req, ingest)
+            if doc_count == 0 and not resolved:
+                raise ValueError(
+                    "RAG mode requires indexed sources. Select a ResearchMind session with "
+                    "documents, or paste URLs / upload files on this tab."
+                )
+
+        scope_session, scope_docs = self._lesson_retrieve_scope(
+            store, session_id, req, ingest
+        )
+        chunks = retrieve(
+            req.topic,
+            store,
+            session_id=scope_session,
+            doc_ids=scope_docs,
+        )
+        if not chunks:
+            warning = (
+                "No passages retrieved from indexed sources; outline uses model knowledge only."
+            )
+            trace.log_note(warning, session_id=session_id, doc_ids=req.doc_ids)
+            summary = ingest_summary or warning
+            if ingest_summary:
+                summary = f"{ingest_summary}\n\n_{warning}_"
+            return "", summary, session_id
+
+        context, citations = format_context_block(chunks)
+        trace.log_note(
+            f"Retrieved {len(chunks)} passage(s) from {len(citations)} source(s)",
+            phase="lesson_retrieve",
+            passage_count=len(chunks),
+            citation_count=len(citations),
+            session_id=session_id,
+            doc_ids=req.doc_ids,
+        )
+        retrieve_line = (
+            f"Retrieved **{len(chunks)}** passage(s) from **{len(citations)}** source(s) "
+            f"for outline grounding."
         )
+        summary = f"{ingest_summary}\n\n{retrieve_line}".strip() if ingest_summary else retrieve_line
+        return context, summary, session_id
 
     def _generate_outline(
         self,
@@ -126,9 +248,11 @@ class AgentRunner:
         req: EducationPptxInput,
         backend: InferenceBackend,
         trace: TraceRecorder,
+        *,
+        source_context: str = "",
     ) -> SlideOutline:
         system = education_outline_system(skill.body)
-        user = education_outline_user(req)
+        user = education_outline_user(req, source_context=source_context)
         messages = [
             {"role": "system", "content": system},
             {"role": "user", "content": user},
@@ -229,16 +353,51 @@ class AgentRunner:
     @staticmethod
     def _extract_json(text: str) -> dict[str, Any]:
         cleaned = text.strip()
-        fence = re.search(r"```(?:json)?\s*(\{.*\})\s*```", cleaned, re.DOTALL)
+        fence = re.search(r"```(?:json)?\s*(.*?)\s*```", cleaned, re.DOTALL | re.IGNORECASE)
         if fence:
-            cleaned = fence.group(1)
-        else:
-            start = cleaned.find("{")
-            end = cleaned.rfind("}")
-            if start >= 0 and end > start:
-                cleaned = cleaned[start : end + 1]
+            cleaned = fence.group(1).strip()
+
+        start = cleaned.find("{")
+        if start < 0:
+            return json.loads(cleaned)
+
+        end = AgentRunner._matching_brace_end(cleaned, start)
+        if end is not None:
+            return json.loads(cleaned[start : end + 1])
+
+        fallback_end = cleaned.rfind("}")
+        if fallback_end > start:
+            return json.loads(cleaned[start : fallback_end + 1])
         return json.loads(cleaned)
 
+    @staticmethod
+    def _matching_brace_end(text: str, start: int) -> int | None:
+        """Return index of the closing brace that matches ``start`` (must be ``{``)."""
+        if start >= len(text) or text[start] != "{":
+            return None
+        depth = 0
+        in_string = False
+        escape = False
+        for index in range(start, len(text)):
+            char = text[index]
+            if in_string:
+                if escape:
+                    escape = False
+                elif char == "\\":
+                    escape = True
+                elif char == '"':
+                    in_string = False
+                continue
+            if char == '"':
+                in_string = True
+            elif char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+                if depth == 0:
+                    return index
+        return None
+
     def _research_skill(self) -> Any:
         return self._skills.get(RESEARCH_MIND_SKILL)
 
@@ -252,6 +411,56 @@ class AgentRunner:
             return session_id
         return store.create_session(topic=topic).id
 
+    @staticmethod
+    def _lesson_doc_ids(
+        store: Any,
+        session_id: str | None,
+        req: EducationPptxInput,
+        ingest: ResearchIngestResult | None,
+    ) -> list[str]:
+        if req.doc_ids:
+            return list(req.doc_ids)
+
+        resolved: list[str] = []
+        seen: set[str] = set()
+
+        def add(doc_id: str | None) -> None:
+            if doc_id and doc_id not in seen:
+                seen.add(doc_id)
+                resolved.append(doc_id)
+
+        if ingest:
+            for doc_id in ingest.doc_ids:
+                add(doc_id)
+
+        for doc in store.list_documents(session_id=session_id):
+            add(doc.id)
+
+        if ingest and not resolved:
+            from researchmind.url_validate import validate_url
+
+            for label in (*ingest.ingested, *ingest.skipped):
+                ok, _, normalized = validate_url(label, check_reachable=False)
+                if ok:
+                    add(store.find_document_id_by_uri(normalized))
+                add(store.find_document_id_by_uri(label))
+
+        return resolved
+
+    @staticmethod
+    def _lesson_retrieve_scope(
+        store: Any,
+        session_id: str | None,
+        req: EducationPptxInput,
+        ingest: ResearchIngestResult | None,
+    ) -> tuple[str | None, list[str] | None]:
+        doc_ids = AgentRunner._lesson_doc_ids(store, session_id, req, ingest)
+        if doc_ids:
+            return None, doc_ids
+        if session_id:
+            return session_id, None
+        return None, None
+
     def run_researchmind_discover(
         self,
         *,
@@ -339,6 +548,8 @@ class AgentRunner:
 
         ingested: list[str] = []
         skipped: list[str] = []
+        doc_ids: list[str] = []
+        seen_doc_ids: set[str] = set()
         failures: list[IngestFailure] = []
 
         scrape_web = self._tools.get("scrape_web")
@@ -360,6 +571,9 @@ class AgentRunner:
                     failures.append(IngestFailure(url=url, reason=msg, stage="scrape"))
                     continue
                 doc_id, is_new = extract_index.handler(doc, session_id=sid)
+                if doc_id not in seen_doc_ids:
+                    seen_doc_ids.add(doc_id)
+                    doc_ids.append(doc_id)
                 trace.log_tool("scrape_web", {"url": url}, doc.title)
                 trace.log_tool(
                     "extract_and_index",
@@ -389,6 +603,9 @@ class AgentRunner:
                         text=text,
                     )
                 doc_id, is_new = extract_index.handler(doc, session_id=sid)
+                if doc_id not in seen_doc_ids:
+                    seen_doc_ids.add(doc_id)
+                    doc_ids.append(doc_id)
                 trace.log_tool("extract_and_index", {"file": str(path)}, f"{doc_id} new={is_new}")
                 label = path.name
                 (ingested if is_new else skipped).append(label)
@@ -411,6 +628,7 @@ class AgentRunner:
             session_id=sid,
             ingested=ingested,
             skipped=skipped,
+            doc_ids=doc_ids,
             failures=failures,
             doc_count=doc_count,
             chunk_count=chunk_count,

libs/agent/tests/test_education_sources.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import json
+import numpy as np
+import pytest
+
+from agent.models import EducationPptxInput, ResearchIngestResult
+from agent.prompts import education_outline_user
+from agent.runner import AgentRunner
+from researchmind.config import ResearchMindConfig
+from researchmind.extract import ExtractedDocument
+
+
+def _outline_json(slide_count: int = 3) -> str:
+    slides = [
+        {
+            "title": f"Slide {i}",
+            "bullets": ["Key point"],
+            "speaker_note": "Note",
+        }
+        for i in range(1, slide_count + 1)
+    ]
+    return json.dumps({"title": "Test Lesson", "slides": slides})
+
+
+class OutlineBackend:
+    def load(self) -> None:
+        return None
+
+    def chat(self, messages, *, max_tokens=2048, temperature=0.3):
+        return _outline_json(3)
+
+    def generate(self, prompt, *, max_tokens=512, temperature=0.7):
+        return self.chat([{"role": "user", "content": prompt}], max_tokens=max_tokens)
+
+
+@pytest.fixture
+def research_env(tmp_path, monkeypatch):
+    cfg = ResearchMindConfig(
+        data_dir=tmp_path / "rm",
+        embed_model="test",
+        auto_search=False,
+        top_k=2,
+        max_context_chunks=8,
+        chunk_size=50,
+        chunk_overlap=10,
+    )
+    monkeypatch.setenv("RESEARCHMIND_DATA_DIR", str(cfg.data_dir))
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path / "outputs"))
+
+    def fake_embed(texts, *, model_name):
+        vecs = [np.array([1.0, 0.0, 0.0], dtype=np.float32) for _ in texts]
+        return np.stack(vecs) if vecs else np.zeros((0, 3), dtype=np.float32)
+
+    monkeypatch.setattr("researchmind.ingest.embed_texts", fake_embed)
+    monkeypatch.setattr("researchmind.retrieve.embed_texts", fake_embed)
+
+    def fake_scrape(url: str):
+        return ExtractedDocument(
+            source_type="web",
+            uri=url,
+            title="Example",
+            text="Photosynthesis converts light to energy in plants.",
+        )
+
+    monkeypatch.setattr("agent.tools.research_tools.fetch_and_extract", fake_scrape)
+
+    def fake_search(topic, *, n=5, check_reachable=True):
+        return [f"https://example.com/{topic.replace(' ', '-')}"]
+
+    monkeypatch.setattr("agent.tools.research_tools.search_urls", fake_search)
+
+    def fake_validate(url, *, check_reachable=True):
+        normalized = url if url.startswith("http") else f"https://{url}"
+        return True, "ok", normalized
+
+    monkeypatch.setattr("researchmind.url_validate.validate_url", fake_validate)
+    return cfg
+
+
+def test_education_outline_user_includes_source_context():
+    req = EducationPptxInput(topic="Photosynthesis", grade="6", slide_count=3)
+    user = education_outline_user(req, source_context="[1] Plants use chlorophyll.")
+    assert "retrieved source excerpts" in user
+    assert "chlorophyll" in user
+
+
+def test_none_mode_skips_source_summary(research_env):
+    runner = AgentRunner()
+    result = runner.run_education_pptx(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        model_key="test",
+        backend=OutlineBackend(),
+        source_mode="none",
+    )
+    assert result.outline.title == "Test Lesson"
+    assert result.source_summary == ""
+
+
+def test_web_auto_calls_ingest_with_auto_search(research_env, monkeypatch):
+    calls: list[dict] = []
+
+    def fake_ingest(self, **kwargs):
+        calls.append(kwargs)
+        return ResearchIngestResult(
+            session_id="sess-auto",
+            ingested=["https://example.com/photosynthesis"],
+            skipped=[],
+            failures=[],
+            doc_count=1,
+            chunk_count=1,
+            trace_path="/tmp/trace.json",
+            message="Ingested 1 source(s)",
+        )
+
+    monkeypatch.setattr(AgentRunner, "run_researchmind_ingest", fake_ingest)
+
+    runner = AgentRunner()
+    result = runner.run_education_pptx(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        model_key="test",
+        backend=OutlineBackend(),
+        source_mode="web",
+        search_workflow="auto",
+    )
+    assert len(calls) == 1
+    assert calls[0]["auto_search"] is True
+    assert "Ingested 1 source(s)" in result.source_summary
+
+
+def test_web_two_step_requires_urls(research_env):
+    runner = AgentRunner()
+    with pytest.raises(ValueError, match="Two-step web search requires"):
+        runner.run_education_pptx(
+            topic="Photosynthesis",
+            grade="6",
+            slide_count=3,
+            model_key="test",
+            backend=OutlineBackend(),
+            source_mode="web",
+            search_workflow="two_step",
+            urls=[],
+            files=[],
+        )
+
+
+def test_web_two_step_ingests_without_auto_search(research_env, monkeypatch):
+    calls: list[dict] = []
+
+    def fake_ingest(self, **kwargs):
+        calls.append(kwargs)
+        return ResearchIngestResult(
+            session_id="sess-two",
+            ingested=["https://example.com/a"],
+            skipped=[],
+            failures=[],
+            doc_count=1,
+            chunk_count=1,
+            trace_path="/tmp/trace.json",
+            message="Ingested 1 source(s)",
+        )
+
+    monkeypatch.setattr(AgentRunner, "run_researchmind_ingest", fake_ingest)
+
+    runner = AgentRunner()
+    runner.run_education_pptx(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        model_key="test",
+        backend=OutlineBackend(),
+        source_mode="web",
+        search_workflow="two_step",
+        urls=["https://example.com/a"],
+    )
+    assert calls[0]["auto_search"] is False
+
+
+def test_rag_requires_indexed_sources(research_env):
+    runner = AgentRunner()
+    with pytest.raises(ValueError, match="RAG mode requires indexed sources"):
+        runner.run_education_pptx(
+            topic="Photosynthesis",
+            grade="6",
+            slide_count=3,
+            model_key="test",
+            backend=OutlineBackend(),
+            source_mode="rag",
+            session_id="",
+            urls=[],
+            files=[],
+        )
+
+
+def test_web_two_step_uses_duplicate_doc_ids(research_env):
+    runner = AgentRunner()
+    first = runner.run_researchmind_ingest(
+        topic="Photosynthesis",
+        urls=["https://example.com/a"],
+        files=[],
+        auto_search=False,
+        session_id=None,
+        model_key="test",
+        backend=OutlineBackend(),
+    )
+    assert first.doc_ids
+
+    new_session = runner.run_researchmind_discover(
+        topic="Photosynthesis",
+        auto_search=False,
+        session_id=None,
+        model_key="test",
+        backend=OutlineBackend(),
+    ).session_id
+
+    second = runner.run_researchmind_ingest(
+        topic="Photosynthesis",
+        urls=["https://example.com/a"],
+        files=[],
+        auto_search=False,
+        session_id=new_session,
+        model_key="test",
+        backend=OutlineBackend(),
+    )
+    assert second.ingested == []
+    assert len(second.skipped) == 1
+    assert second.doc_ids == first.doc_ids
+
+    result = runner.run_education_pptx(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        model_key="test",
+        backend=OutlineBackend(),
+        source_mode="web",
+        search_workflow="two_step",
+        urls=["https://example.com/a"],
+        session_id=new_session,
+    )
+    assert "Retrieved" in result.source_summary
+    assert result.source_summary.count("model knowledge only") == 0
+
+
+def test_rag_uses_session_without_auto_search(research_env, monkeypatch):
+    ingest = AgentRunner().run_researchmind_ingest(
+        topic="Photosynthesis",
+        urls=["https://example.com/a"],
+        files=[],
+        auto_search=False,
+        session_id=None,
+        model_key="test",
+        backend=OutlineBackend(),
+    )
+
+    calls: list[dict] = []
+
+    def fake_ingest(self, **kwargs):
+        calls.append(kwargs)
+        return ingest
+
+    monkeypatch.setattr(AgentRunner, "run_researchmind_ingest", fake_ingest)
+
+    runner = AgentRunner()
+    result = runner.run_education_pptx(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        model_key="test",
+        backend=OutlineBackend(),
+        source_mode="rag",
+        session_id=ingest.session_id,
+    )
+    assert calls == []
+    assert "Retrieved" in result.source_summary

libs/agent/tests/test_runner.py

@@ -38,6 +38,22 @@ def test_extract_json_from_fenced_block():
     assert data["title"] == "T"
 
 
+def test_extract_json_ignores_trailing_text():
+    raw = (
+        '{"title": "AI Agents", "slides": [{"title": "Intro", "bullets": ["a"]}]}\n'
+        "Here is a short explanation of the lesson outline."
+    )
+    data = AgentRunner._extract_json(raw)
+    assert data["title"] == "AI Agents"
+
+
+def test_extract_json_ignores_duplicate_object():
+    first = '{"title": "First", "slides": [{"title": "A", "bullets": ["a"]}]}'
+    second = '{"title": "Second", "slides": [{"title": "B", "bullets": ["b"]}]}'
+    data = AgentRunner._extract_json(f"{first}\n{second}")
+    assert data["title"] == "First"
+
+
 def test_create_pptx_writes_file(tmp_path, monkeypatch):
     monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
     outline = SlideOutline(

libs/researchmind/src/researchmind/store.py

@@ -165,6 +165,23 @@ class MemRAGStore:
             ).fetchone()
         return row["id"] if row else None
 
+    def find_document_id_by_uri(self, uri: str) -> str | None:
+        from researchmind.url_validate import normalize_url
+
+        candidates = [uri.strip()]
+        normalized = normalize_url(uri)
+        if normalized and normalized not in candidates:
+            candidates.append(normalized)
+        with self._conn() as conn:
+            for candidate in candidates:
+                row = conn.execute(
+                    "SELECT id FROM documents WHERE uri = ?",
+                    (candidate,),
+                ).fetchone()
+                if row:
+                    return str(row["id"])
+        return None
+
     def add_document(
         self,
         *,