Refactor project structure and update dependencies

- Introduced a new `config.py` file to centralize configuration and source management, replacing references to `setup.py`.
- Updated AGENTS.md to reflect changes in source configuration and clarify the single source of truth for sources.
- Removed `ipykernel` from main dependencies and added it to the development group in `pyproject.toml` and `uv.lock`.
- Adjusted import statements across various modules to utilize the new `config.py`.
- Enhanced logging practices in the application for improved clarity and reduced noise.

AGENTS.md

@@ -23,9 +23,9 @@ ChromaDB for vectors; Cohere for embeddings/rerank; chat model is provider-confi
 | Hybrid retrieval | `app/chroma_rag.py` |
 | KB browsing sandbox + citation resolution | `app/kb_shell.py`, `app/kb_manifest.py` |
 | FastAPI server (`/api/chat`, `/api/tools`, `/healthz`) | `app/api.py` |
-| Paths, models, startup downloads | `app/setup.py` |
+| Paths, models, startup downloads | `app/config.py` |
 | **Sources — single source of truth** | `data/scraping_scripts/source_registry.py` |
-| Agent tracing (LangSmith) + server logging (stdlib `logging` → stdout) | `app/agent_tracing.py`, `app/setup.py` |
+| Agent tracing (LangSmith) + server logging (stdlib `logging` → stdout) | `app/agent_tracing.py`, `app/config.py` |
 | Data pipeline / workflows (deep guide) | `data/scraping_scripts/README.md` |
 | KB design + wiki maintainer workflow (deep guide) | `data/kb/MAINTAINER.md` |
 
@@ -59,7 +59,7 @@ Runtime guidance the agent follows is in `data/kb/AGENTS.md` (injected into the
 
 ## Sources & config
 
-`data/scraping_scripts/source_registry.py` is the **single source of truth** for sources (`SOURCE_CONFIGS`, key groupings, UI labels, defaults); `app/setup.py` re-exports them and the frontend derives the picker from it (via `/api/tools`). Docs sources ingest via the GitHub API or `llms.txt`; course sources are Notion exports. To add a source: add it to the registry (+ the relevant grouping tuples), then run the matching workflow — no separate UI edit needed. Models live in `setup.AVAILABLE_MODELS` (default `google-genai:gemini-3.5-flash`; also Claude Haiku 4.5; OpenAI supported in code).
+`data/scraping_scripts/source_registry.py` is the **single source of truth** for sources (`SOURCE_CONFIGS`, key groupings, UI labels, defaults); `app/config.py` re-exports them and the frontend derives the picker from it (via `/api/tools`). Docs sources ingest via the GitHub API or `llms.txt`; course sources are Notion exports. To add a source: add it to the registry (+ the relevant grouping tuples), then run the matching workflow — no separate UI edit needed. Models live in `config.AVAILABLE_MODELS` (default `google-genai:gemini-3.5-flash`; also Claude Haiku 4.5; OpenAI supported in code).
 
 ## Running locally
 
@@ -109,4 +109,4 @@ Both Spaces need the same runtime secrets (`COHERE_API_KEY`, model provider key,
 - **Context generation uses Gemini**; embeddings/rerank use **Cohere**; the chat model is provider-configurable. OpenAI is required only when explicitly selected.
 - `data/kb/` and `data/chroma-db-all_sources/` are build artifacts — never commit or hand-edit; regenerate or re-download.
 - Two `AGENTS.md` files: this root one (repo dev guidance) vs `data/kb/AGENTS.md` (generated runtime KB rules).
-- Source config lives in `source_registry.py`, not `setup.py` / `process_md_files.py` (older docs were wrong).
+- Source config lives in `source_registry.py`, not `app/config.py` / `process_md_files.py` (older docs were wrong).

app/api.py

@@ -23,7 +23,7 @@ from .chat_service import (
     warm_up_retriever,
 )
 from .chat_types import ChatEvent, ChatRequest, ChatTurn
-from .setup import (
+from .config import (
     AVAILABLE_MODELS,
     AVAILABLE_SOURCES,
     AVAILABLE_SOURCES_UI,

app/chat_service.py

@@ -44,7 +44,12 @@ from .kb_manifest import (
     source_match_payload,
 )
 from .prompts import build_system_prompt
-from .setup import (
+from .provider_events import (
+    GoogleSearchActivity,
+    extract_anthropic_source_matches,
+    extract_thought_summaries,
+)
+from .config import (
     BM25_INDEX_PATH,
     COURSE_SOURCE_KEYS,
     DEFAULT_SELECTED_SOURCE_KEYS,
@@ -513,28 +518,6 @@ def is_anthropic_model(model_name: str) -> bool:
     return provider == "anthropic"
 
 
-def extract_thought_summaries(content: Any) -> list[str]:
-    if not isinstance(content, list):
-        return []
-
-    thoughts: list[str] = []
-    for item in content:
-        if not hasattr(item, "get"):
-            continue
-
-        item_type = item.get("type")
-        if item_type == "thinking":
-            thought = str(item.get("thinking", "")).strip()
-        elif item_type == "reasoning":
-            thought = str(item.get("reasoning", "")).strip()
-        else:
-            continue
-
-        if thought:
-            thoughts.append(thought)
-    return thoughts
-
-
 def format_tool_args(args: Any) -> str:
     if isinstance(args, dict):
         query = str(args.get("query", "")).strip()
@@ -795,251 +778,6 @@ def agent_run_config(
     return config
 
 
-def extract_web_search_queries(response_metadata: Any) -> list[str]:
-    """Pull the queries Gemini ran against google_search from grounding metadata."""
-    if not isinstance(response_metadata, dict):
-        return []
-    grounding = response_metadata.get("grounding_metadata") or {}
-    queries = grounding.get("web_search_queries") or []
-    return [str(q).strip() for q in queries if isinstance(q, str) and str(q).strip()]
-
-
-def extract_grounding_source_matches(
-    response_metadata: Any,
-    matches_by_doc_id: dict[str, SourceMatch],
-) -> list[SourceMatch]:
-    """Turn Gemini grounding metadata into source matches (deduped by URI)."""
-    if not isinstance(response_metadata, dict):
-        return []
-    grounding = response_metadata.get("grounding_metadata") or {}
-    chunks = grounding.get("grounding_chunks") or []
-    if not chunks:
-        return []
-
-    confidence_by_index: dict[int, float] = {}
-    for support in grounding.get("grounding_supports") or []:
-        indices = support.get("grounding_chunk_indices") or []
-        scores = support.get("confidence_scores") or []
-        for idx, score in zip(indices, scores):
-            if not isinstance(idx, int):
-                continue
-            numeric = float(score) if isinstance(score, (int, float)) else 0.0
-            if numeric > confidence_by_index.get(idx, 0.0):
-                confidence_by_index[idx] = numeric
-
-    updated: list[SourceMatch] = []
-    for idx, chunk in enumerate(chunks):
-        web = (chunk or {}).get("web") or {}
-        uri = str(web.get("uri") or "").strip()
-        if not uri:
-            continue
-        title = str(web.get("title") or uri).strip()
-        doc_id = f"google_search::{uri}"
-        if doc_id in matches_by_doc_id:
-            continue
-        score = confidence_by_index.get(idx, 1.0)
-        source_match = SourceMatch(
-            doc_id=doc_id,
-            title=title,
-            url=uri,
-            source_key="google_search",
-            source_label="Web",
-            score=score,
-            group="web",
-        )
-        matches_by_doc_id[doc_id] = source_match
-        updated.append(source_match)
-    return updated
-
-
-GOOGLE_SEARCH_TOOL_NAME = "google_search"
-
-
-class GoogleSearchActivity:
-    """Surface Gemini's server-side google_search activity as tool events.
-
-    Gemini reports search grounding via response metadata instead of tool
-    messages, so queries and grounding results are accumulated from every
-    metadata payload and exposed as a single synthetic tool call per turn.
-    """
-
-    def __init__(self, message_id: str, web_evidence: dict[str, SourceMatch]) -> None:
-        self._message_id = message_id
-        self._web_evidence = web_evidence
-        self._call_id = ""
-        self._queries: list[str] = []
-        self._match_count = 0
-
-    def observe(self, response_metadata: Any) -> ChatEvent | None:
-        """Record metadata; return a tool_call_started event on first activity."""
-        new_queries = [
-            q
-            for q in extract_web_search_queries(response_metadata)
-            if q not in self._queries
-        ]
-        new_grounding = extract_grounding_source_matches(
-            response_metadata,
-            self._web_evidence,
-        )
-        started: ChatEvent | None = None
-        if (new_queries or new_grounding) and not self._call_id:
-            self._call_id = uuid4().hex
-            joined = "; ".join(new_queries)
-            started = ChatEvent(
-                "tool_call_started",
-                {
-                    "message_id": self._message_id,
-                    "call_id": self._call_id,
-                    "tool_name": GOOGLE_SEARCH_TOOL_NAME,
-                    "args": {"query": joined},
-                    "args_text": joined,
-                },
-            )
-        self._queries.extend(new_queries)
-        self._match_count += len(new_grounding)
-        return started
-
-    def completed_event(self) -> ChatEvent | None:
-        if not self._call_id:
-            return None
-        joined = "; ".join(self._queries)
-        if self._match_count == 0:
-            output_text = "Google search ran but returned no grounding results."
-        else:
-            plural = "" if self._match_count == 1 else "s"
-            output_text = (
-                f"Google search returned {self._match_count} web result{plural}."
-            )
-        return ChatEvent(
-            "tool_call_completed",
-            {
-                "message_id": self._message_id,
-                "call_id": self._call_id,
-                "tool_name": GOOGLE_SEARCH_TOOL_NAME,
-                "args": {"query": joined},
-                "args_text": joined,
-                "output_text": output_text,
-            },
-        )
-
-
-ANTHROPIC_SERVER_TOOL_NAMES = frozenset({"web_search", "web_fetch"})
-ANTHROPIC_RESULT_BLOCK_TYPES = {
-    "web_search_tool_result": ("web_search", "Web"),
-    "web_fetch_tool_result": ("web_fetch", "Web page"),
-}
-
-
-def extract_anthropic_source_matches(
-    content: Any,
-    matches_by_doc_id: dict[str, SourceMatch],
-) -> tuple[dict[str, list[SourceMatch]], dict[str, dict[str, Any]]]:
-    """Parse Claude's server-side web tool invocations and their results.
-
-    Scans ``message.content`` for three kinds of blocks emitted when Claude
-    runs the built-in ``web_search`` / ``web_fetch`` tools:
-
-    * ``tool_use`` — the model's call (id, name, input args)
-    * ``web_search_tool_result`` / ``web_fetch_tool_result`` — the server's
-      response, keyed by ``tool_use_id``
-    * ``text`` blocks with ``citations`` — fallback for citations without a
-      matching result block
-
-    Returns ``(matches_by_tool_use_id, tool_use_index)`` where
-    ``tool_use_index`` maps tool_use id → ``{"name", "args"}`` so the caller
-    can emit ``tool_call_started`` events with the right metadata.
-    ``langchain-anthropic`` does not always surface server-side tool_use in
-    ``AIMessage.tool_calls``, so we read them off the content blocks directly.
-    """
-    if not isinstance(content, list):
-        return {}, {}
-
-    updates: dict[str, list[SourceMatch]] = {}
-    tool_use_index: dict[str, dict[str, Any]] = {}
-
-    for block in content:
-        if not hasattr(block, "get"):
-            continue
-
-        block_type = block.get("type")
-
-        if block_type in ("server_tool_use", "tool_use"):
-            tool_use_id = str(block.get("id") or "")
-            tool_name = str(block.get("name") or "")
-            if tool_use_id and tool_name in ANTHROPIC_SERVER_TOOL_NAMES:
-                args = block.get("input") or {}
-                if not args:
-                    partial = block.get("partial_json")
-                    if isinstance(partial, str) and partial.strip():
-                        try:
-                            parsed = json.loads(partial)
-                        except json.JSONDecodeError:
-                            parsed = None
-                        if isinstance(parsed, dict):
-                            args = parsed
-                tool_use_index[tool_use_id] = {
-                    "id": tool_use_id,
-                    "name": tool_name,
-                    "args": args,
-                }
-            continue
-
-        mapping = ANTHROPIC_RESULT_BLOCK_TYPES.get(block_type)
-        if mapping:
-            source_key, source_label = mapping
-            tool_use_id = str(block.get("tool_use_id") or "")
-            results = block.get("content") or []
-            if not isinstance(results, list):
-                continue
-            for result in results:
-                if not hasattr(result, "get"):
-                    continue
-                url = str(result.get("url") or "").strip()
-                if not url:
-                    continue
-                title = str(result.get("title") or url).strip()
-                doc_id = f"{source_key}::{url}"
-                if doc_id in matches_by_doc_id:
-                    continue
-                source_match = SourceMatch(
-                    doc_id=doc_id,
-                    title=title,
-                    url=url,
-                    source_key=source_key,
-                    source_label=source_label,
-                    score=1.0,
-                    group="web",
-                )
-                matches_by_doc_id[doc_id] = source_match
-                updates.setdefault(tool_use_id, []).append(source_match)
-            continue
-
-        if block_type == "text":
-            for citation in block.get("citations") or []:
-                if not hasattr(citation, "get"):
-                    continue
-                url = str(citation.get("url") or "").strip()
-                if not url:
-                    continue
-                title = str(citation.get("title") or url).strip()
-                doc_id = f"web_search::{url}"
-                if doc_id in matches_by_doc_id:
-                    continue
-                source_match = SourceMatch(
-                    doc_id=doc_id,
-                    title=title,
-                    url=url,
-                    source_key="web_search",
-                    source_label="Web",
-                    score=1.0,
-                    group="web",
-                )
-                matches_by_doc_id[doc_id] = source_match
-                updates.setdefault("", []).append(source_match)
-
-    return updates, tool_use_index
-
-
 async def stream_chat(request: ChatRequest) -> AsyncIterator[ChatEvent]:
     normalized_history = normalize_history(request.history)
     retrieval_evidence: dict[str, SourceMatch] = {}

app/kb_manifest.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from .chat_types import SourceMatch
-from .setup import COURSE_SOURCE_KEYS, KB_DIR, SOURCE_KEY_TO_LABEL
+from .config import COURSE_SOURCE_KEYS, KB_DIR, SOURCE_KEY_TO_LABEL
 
 KB_DOC_SCHEME_RE = re.compile(r"^kb://doc/(?P<doc_id>[^)\]\s]+)$")
 RAW_PATH_RE = re.compile(r"(?:data/kb/)?raw/[^\s)\]>,:]+?\.(?:mdx|md)")

app/provider_events.py

@@ -0,0 +1,283 @@
+"""Provider-specific response parsing for the chat stream.
+
+Gemini and Anthropic surface server-side tool activity (web search, URL
+fetch) and reasoning through provider-shaped response metadata and content
+blocks rather than regular tool messages. This module turns those payloads
+into the app's neutral `ChatEvent` / `SourceMatch` shapes so
+`chat_service.stream_chat` stays provider-agnostic.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from uuid import uuid4
+
+from .chat_types import ChatEvent, SourceMatch
+
+
+def extract_thought_summaries(content: Any) -> list[str]:
+    if not isinstance(content, list):
+        return []
+
+    thoughts: list[str] = []
+    for item in content:
+        if not hasattr(item, "get"):
+            continue
+
+        item_type = item.get("type")
+        if item_type == "thinking":
+            thought = str(item.get("thinking", "")).strip()
+        elif item_type == "reasoning":
+            thought = str(item.get("reasoning", "")).strip()
+        else:
+            continue
+
+        if thought:
+            thoughts.append(thought)
+    return thoughts
+
+
+def extract_web_search_queries(response_metadata: Any) -> list[str]:
+    """Pull the queries Gemini ran against google_search from grounding metadata."""
+    if not isinstance(response_metadata, dict):
+        return []
+    grounding = response_metadata.get("grounding_metadata") or {}
+    queries = grounding.get("web_search_queries") or []
+    return [str(q).strip() for q in queries if isinstance(q, str) and str(q).strip()]
+
+
+def extract_grounding_source_matches(
+    response_metadata: Any,
+    matches_by_doc_id: dict[str, SourceMatch],
+) -> list[SourceMatch]:
+    """Turn Gemini grounding metadata into source matches (deduped by URI)."""
+    if not isinstance(response_metadata, dict):
+        return []
+    grounding = response_metadata.get("grounding_metadata") or {}
+    chunks = grounding.get("grounding_chunks") or []
+    if not chunks:
+        return []
+
+    confidence_by_index: dict[int, float] = {}
+    for support in grounding.get("grounding_supports") or []:
+        indices = support.get("grounding_chunk_indices") or []
+        scores = support.get("confidence_scores") or []
+        for idx, score in zip(indices, scores):
+            if not isinstance(idx, int):
+                continue
+            numeric = float(score) if isinstance(score, (int, float)) else 0.0
+            if numeric > confidence_by_index.get(idx, 0.0):
+                confidence_by_index[idx] = numeric
+
+    updated: list[SourceMatch] = []
+    for idx, chunk in enumerate(chunks):
+        web = (chunk or {}).get("web") or {}
+        uri = str(web.get("uri") or "").strip()
+        if not uri:
+            continue
+        title = str(web.get("title") or uri).strip()
+        doc_id = f"google_search::{uri}"
+        if doc_id in matches_by_doc_id:
+            continue
+        score = confidence_by_index.get(idx, 1.0)
+        source_match = SourceMatch(
+            doc_id=doc_id,
+            title=title,
+            url=uri,
+            source_key="google_search",
+            source_label="Web",
+            score=score,
+            group="web",
+        )
+        matches_by_doc_id[doc_id] = source_match
+        updated.append(source_match)
+    return updated
+
+
+GOOGLE_SEARCH_TOOL_NAME = "google_search"
+
+
+class GoogleSearchActivity:
+    """Surface Gemini's server-side google_search activity as tool events.
+
+    Gemini reports search grounding via response metadata instead of tool
+    messages, so queries and grounding results are accumulated from every
+    metadata payload and exposed as a single synthetic tool call per turn.
+    """
+
+    def __init__(self, message_id: str, web_evidence: dict[str, SourceMatch]) -> None:
+        self._message_id = message_id
+        self._web_evidence = web_evidence
+        self._call_id = ""
+        self._queries: list[str] = []
+        self._match_count = 0
+
+    def observe(self, response_metadata: Any) -> ChatEvent | None:
+        """Record metadata; return a tool_call_started event on first activity."""
+        new_queries = [
+            q
+            for q in extract_web_search_queries(response_metadata)
+            if q not in self._queries
+        ]
+        new_grounding = extract_grounding_source_matches(
+            response_metadata,
+            self._web_evidence,
+        )
+        started: ChatEvent | None = None
+        if (new_queries or new_grounding) and not self._call_id:
+            self._call_id = uuid4().hex
+            joined = "; ".join(new_queries)
+            started = ChatEvent(
+                "tool_call_started",
+                {
+                    "message_id": self._message_id,
+                    "call_id": self._call_id,
+                    "tool_name": GOOGLE_SEARCH_TOOL_NAME,
+                    "args": {"query": joined},
+                    "args_text": joined,
+                },
+            )
+        self._queries.extend(new_queries)
+        self._match_count += len(new_grounding)
+        return started
+
+    def completed_event(self) -> ChatEvent | None:
+        if not self._call_id:
+            return None
+        joined = "; ".join(self._queries)
+        if self._match_count == 0:
+            output_text = "Google search ran but returned no grounding results."
+        else:
+            plural = "" if self._match_count == 1 else "s"
+            output_text = (
+                f"Google search returned {self._match_count} web result{plural}."
+            )
+        return ChatEvent(
+            "tool_call_completed",
+            {
+                "message_id": self._message_id,
+                "call_id": self._call_id,
+                "tool_name": GOOGLE_SEARCH_TOOL_NAME,
+                "args": {"query": joined},
+                "args_text": joined,
+                "output_text": output_text,
+            },
+        )
+
+
+ANTHROPIC_SERVER_TOOL_NAMES = frozenset({"web_search", "web_fetch"})
+ANTHROPIC_RESULT_BLOCK_TYPES = {
+    "web_search_tool_result": ("web_search", "Web"),
+    "web_fetch_tool_result": ("web_fetch", "Web page"),
+}
+
+
+def extract_anthropic_source_matches(
+    content: Any,
+    matches_by_doc_id: dict[str, SourceMatch],
+) -> tuple[dict[str, list[SourceMatch]], dict[str, dict[str, Any]]]:
+    """Parse Claude's server-side web tool invocations and their results.
+
+    Scans ``message.content`` for three kinds of blocks emitted when Claude
+    runs the built-in ``web_search`` / ``web_fetch`` tools:
+
+    * ``tool_use`` — the model's call (id, name, input args)
+    * ``web_search_tool_result`` / ``web_fetch_tool_result`` — the server's
+      response, keyed by ``tool_use_id``
+    * ``text`` blocks with ``citations`` — fallback for citations without a
+      matching result block
+
+    Returns ``(matches_by_tool_use_id, tool_use_index)`` where
+    ``tool_use_index`` maps tool_use id → ``{"name", "args"}`` so the caller
+    can emit ``tool_call_started`` events with the right metadata.
+    ``langchain-anthropic`` does not always surface server-side tool_use in
+    ``AIMessage.tool_calls``, so we read them off the content blocks directly.
+    """
+    if not isinstance(content, list):
+        return {}, {}
+
+    updates: dict[str, list[SourceMatch]] = {}
+    tool_use_index: dict[str, dict[str, Any]] = {}
+
+    for block in content:
+        if not hasattr(block, "get"):
+            continue
+
+        block_type = block.get("type")
+
+        if block_type in ("server_tool_use", "tool_use"):
+            tool_use_id = str(block.get("id") or "")
+            tool_name = str(block.get("name") or "")
+            if tool_use_id and tool_name in ANTHROPIC_SERVER_TOOL_NAMES:
+                args = block.get("input") or {}
+                if not args:
+                    partial = block.get("partial_json")
+                    if isinstance(partial, str) and partial.strip():
+                        try:
+                            parsed = json.loads(partial)
+                        except json.JSONDecodeError:
+                            parsed = None
+                        if isinstance(parsed, dict):
+                            args = parsed
+                tool_use_index[tool_use_id] = {
+                    "id": tool_use_id,
+                    "name": tool_name,
+                    "args": args,
+                }
+            continue
+
+        mapping = ANTHROPIC_RESULT_BLOCK_TYPES.get(block_type)
+        if mapping:
+            source_key, source_label = mapping
+            tool_use_id = str(block.get("tool_use_id") or "")
+            results = block.get("content") or []
+            if not isinstance(results, list):
+                continue
+            for result in results:
+                if not hasattr(result, "get"):
+                    continue
+                url = str(result.get("url") or "").strip()
+                if not url:
+                    continue
+                title = str(result.get("title") or url).strip()
+                doc_id = f"{source_key}::{url}"
+                if doc_id in matches_by_doc_id:
+                    continue
+                source_match = SourceMatch(
+                    doc_id=doc_id,
+                    title=title,
+                    url=url,
+                    source_key=source_key,
+                    source_label=source_label,
+                    score=1.0,
+                    group="web",
+                )
+                matches_by_doc_id[doc_id] = source_match
+                updates.setdefault(tool_use_id, []).append(source_match)
+            continue
+
+        if block_type == "text":
+            for citation in block.get("citations") or []:
+                if not hasattr(citation, "get"):
+                    continue
+                url = str(citation.get("url") or "").strip()
+                if not url:
+                    continue
+                title = str(citation.get("title") or url).strip()
+                doc_id = f"web_search::{url}"
+                if doc_id in matches_by_doc_id:
+                    continue
+                source_match = SourceMatch(
+                    doc_id=doc_id,
+                    title=title,
+                    url=url,
+                    source_key="web_search",
+                    source_label="Web",
+                    score=1.0,
+                    group="web",
+                )
+                matches_by_doc_id[doc_id] = source_match
+                updates.setdefault("", []).append(source_match)
+
+    return updates, tool_use_index

data/scraping_scripts/README.md

@@ -189,7 +189,7 @@ places, both reading from the canonical template at
 
 - `data.scraping_scripts.update_kb_wiki.write_agents_md` — rewrites it during
   every `update_docs_workflow.py` run, before uploading to HuggingFace.
-- `app.setup.ensure_kb_agents_md` — rewrites it on every runtime startup,
+- `app.config.ensure_kb_agents_md` — rewrites it on every runtime startup,
   after `ensure_local_vector_db` downloads the snapshot. This catches the
   case where the HF snapshot has a stale AGENTS.md (e.g. uploaded before a
   template change landed in git) and ensures the live file always matches
@@ -207,7 +207,7 @@ place on startup either way).
   `data/all_sources_data.jsonl`) and `data.scraping_scripts.update_kb_wiki`.
 - **Uploaded** to `towardsai-tutors/ai-tutor-vector-db` by
   `data.scraping_scripts.upload_dbs_to_hf` (already includes `kb/**`).
-- **Downloaded** by `app.setup.ensure_local_vector_db` on the first
+- **Downloaded** by `app.config.ensure_local_vector_db` on the first
   chatbot start (or any start where the local KB is missing).
 
 Treat it the same way as `data/chroma-db-all_sources/`: never commit it,

data/scraping_scripts/add_course_workflow.py

@@ -435,7 +435,7 @@ def update_ui_files(course_name: str) -> None:
         return
 
     logger.info(
-        "%s is configured in source_registry.py; no setup.py/main.py edits needed.",
+        "%s is configured in source_registry.py; no app-code edits needed.",
         course_name,
     )
 

pyproject.toml

@@ -12,7 +12,6 @@ dependencies = [
     "google-genai",
     "hf-xet",
     "huggingface-hub",
-    "ipykernel",
     "langchain",
     "langchain-anthropic",
     "langchain-google-genai",
@@ -31,6 +30,7 @@ dependencies = [
 [dependency-groups]
 dev = [
     "httpx",
+    "ipykernel",
     "pre-commit",
     "pytest>=9.0.3",
     "ruff>=0.15.10",

uv.lock

@@ -22,7 +22,6 @@ dependencies = [
     { name = "google-genai" },
     { name = "hf-xet" },
     { name = "huggingface-hub" },
-    { name = "ipykernel" },
     { name = "langchain" },
     { name = "langchain-anthropic" },
     { name = "langchain-google-genai" },
@@ -41,6 +40,7 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "httpx" },
+    { name = "ipykernel" },
     { name = "pre-commit" },
     { name = "pytest" },
     { name = "ruff" },
@@ -55,7 +55,6 @@ requires-dist = [
     { name = "google-genai" },
     { name = "hf-xet" },
     { name = "huggingface-hub" },
-    { name = "ipykernel" },
     { name = "langchain" },
     { name = "langchain-anthropic" },
     { name = "langchain-google-genai" },
@@ -74,6 +73,7 @@ requires-dist = [
 [package.metadata.requires-dev]
 dev = [
     { name = "httpx" },
+    { name = "ipykernel" },
     { name = "pre-commit" },
     { name = "pytest", specifier = ">=9.0.3" },
     { name = "ruff", specifier = ">=0.15.10" },