📔 NotebookLM, and taking the research home · NotebookLM กับการพางานวิจัยกลับบ้าน · NotebookLM，把研究带回家

1 What is on the other machine · อีกเครื่องมีอะไรอยู่บ้าง · 另一台机器上有什么

📄 NEW FILE · spark1.py

"""spark1.py — is the box there, and what is loaded on it right now?"""
import json
import sys
import urllib.error
import urllib.request

# The machine's name on the network. Yours will be different.
SPARK = "http://spark.local:11434"

sys.stdout.reconfigure(encoding="utf-8")


def ask_spark(path):
    """One GET to the Spark's Ollama, or a plain complaint if it is not there."""
    try:
        with urllib.request.urlopen(SPARK + path, timeout=10) as response:
            return json.load(response)
    except urllib.error.URLError as trouble:
        # A machine that is asleep, renamed or on another network all look
        # the same from here. Say so instead of raising a wall of red.
        print("cannot reach", SPARK)
        print("  ", trouble.reason)
        raise SystemExit(1)


def main():
    """List what the Spark has, and what it is holding in memory."""
    models = ask_spark("/api/tags")["models"]
    print(f"{len(models)} models on the Spark:")
    for model in sorted(models, key=lambda m: -m["size"]):
        print(f"  {model['name']:38} {model['size'] / 1e9:5.1f} GB")

    # /api/ps is different from /api/tags. tags is what is on the disk,
    # ps is what is loaded into memory and answering quickly right now.
    loaded = ask_spark("/api/ps")["models"]
    print()
    if not loaded:
        print("nothing loaded in memory. The first question will be slower.")
    for model in loaded:
        print(f"loaded now: {model['name']}  until {model['expires_at'][:19]}")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · against a real machine on the wifi

5 models on the Spark:
  qwen2.5:14b                              9.0 GB
  scb10x/typhoon2.1-gemma3-12b:latest      7.8 GB
  gemma2:9b                                5.4 GB
  llama3.1:8b                              4.9 GB
  llama3.2:3b                              2.0 GB

nothing loaded in memory. The first question will be slower.

2 Ask both of them the same thing · ถามทั้งสองเครื่องด้วยคำถามเดียวกัน · 同一个问题，问两台机器

📄 NEW FILE · ask1.py

"""ask1.py — the same question to this laptop and to the Spark, timed."""
import json
import sys
import time
import urllib.request

LAPTOP = "http://localhost:11434"
SPARK = "http://spark.local:11434"

QUESTION = "In one sentence, what is a GPU for?"

sys.stdout.reconfigure(encoding="utf-8")


def ask(host, model, question):
    """Send one question and time the whole round trip."""
    payload = json.dumps({
        "model": model,
        "stream": False,
        "options": {"temperature": 0},
        "messages": [{"role": "user", "content": question}],
    }).encode()
    request = urllib.request.Request(
        host + "/api/chat", data=payload,
        headers={"Content-Type": "application/json"})

    start = time.perf_counter()
    with urllib.request.urlopen(request, timeout=600) as response:
        answer = json.load(response)
    wall = time.perf_counter() - start

    # Ollama reports where its own time went, in nanoseconds.
    return {
        "said": answer["message"]["content"].strip(),
        "wall": wall,
        "thinking": answer.get("eval_duration", 0) / 1e9,
        "tokens": answer.get("eval_count", 0),
    }


def main():
    for label, host, model in [("this laptop", LAPTOP, "llama3.2"),
                               ("the Spark  ", SPARK, "qwen2.5:14b")]:
        got = ask(host, model, QUESTION)

        # wall includes the network. thinking is only the model writing.
        # The gap between them is what the wire cost you.
        print(f"{label}  {model:14} {got['wall']:6.2f}s total, "
              f"{got['thinking']:5.2f}s writing, {got['tokens']:3} tokens")
        print("   ", got["said"][:90])
        print()


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · warm, both models already loaded

this laptop  llama3.2         3.46s total,  3.34s writing,  55 tokens
the Spark    qwen2.5:14b      5.34s total,  2.38s writing,  59 tokens

3 So when is sending it away worth it · แล้วเมื่อไหร่ที่การส่งงานออกไปถึงจะคุ้ม · 那什么时候派出去才划算

📄 NEW FILE · when1.py

"""when1.py — when is sending the job to the Spark actually worth it?"""
import json
import sys
import time
import urllib.request

LAPTOP = "http://localhost:11434"
SPARK = "http://spark.local:11434"

JOBS = [("a short answer", "In one sentence, what is a GPU for?"),
        ("a long answer",
         "Write 500 words about why Chiang Mai has a burning season.")]

sys.stdout.reconfigure(encoding="utf-8")


def ask(host, model, question):
    payload = json.dumps({"model": model, "stream": False,
                          "options": {"temperature": 0},
                          "messages": [{"role": "user", "content": question}]}).encode()
    request = urllib.request.Request(host + "/api/chat", data=payload,
                                     headers={"Content-Type": "application/json"})
    start = time.perf_counter()
    with urllib.request.urlopen(request, timeout=1800) as response:
        answer = json.load(response)
    wall = time.perf_counter() - start
    tokens = answer.get("eval_count", 0)
    writing = answer.get("eval_duration", 0) / 1e9
    return wall, tokens, writing


def main():
    print(f"{'job':16} {'where':12} {'model':14} {'total':>8} {'writing':>9} "
          f"{'tokens':>7} {'tok/s':>7}")
    print("-" * 80)
    for label, question in JOBS:
        for where, host, model in [("laptop", LAPTOP, "llama3.2"),
                                   ("Spark", SPARK, "qwen2.5:14b")]:
            wall, tokens, writing = ask(host, model, question)
            rate = tokens / writing if writing else 0

            # wall minus writing is everything that was not the model:
            # the network, the queue, and reading the question back.
            print(f"{label:16} {where:12} {model:14} {wall:7.2f}s "
                  f"{writing:8.2f}s {tokens:7} {rate:7.1f}")
        print()


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · the whole argument, in four rows

job              where     model           total   writing  tokens   tok/s
a short answer   laptop    llama3.2        3.36s     3.27s      55    16.8
a short answer   Spark     qwen2.5:14b     5.40s     2.38s      59    24.8

a long answer    laptop    llama3.2       51.48s    51.25s     724    14.1
a long answer    Spark     qwen2.5:14b    29.01s    25.69s     623    24.3

4 Connecting, and the async surprise · การเชื่อมต่อ กับเซอร์ไพรส์เรื่อง async · 连接，以及异步这个意外

📄 NEW FILE · nb1.py

"""nb1.py — connect to NotebookLM from Python, and see what is there.

Every call in this library is asynchronous, so the whole file is written
with async and await. That is three extra words, and nothing else changes.
"""
import asyncio
import sys

from notebooklm import AuthTokens
from notebooklm.client import NotebookLMClient

sys.stdout.reconfigure(encoding="utf-8")


async def main():
    """List the notebooks in the account this computer is logged in to."""
    # There is no API key for NotebookLM. You log in once at the terminal,
    #     python -m notebooklm login
    # which saves a file, and from_storage reads it back.
    auth = await AuthTokens.from_storage()

    # async with, not with. The client opens a connection and must close it.
    async with NotebookLMClient(auth) as client:
        # A property, not a method. It is already a True or False.
        print("connected:", client.is_connected)

        notebooks = await client.notebooks.list()
        print(f"{len(notebooks)} notebooks:")
        for notebook in notebooks[:8]:
            print(f"  {notebook.id[:8]}  {notebook.title[:52]}")


if __name__ == "__main__":
    # asyncio.run starts the loop, runs main to the end, and stops the loop.
    asyncio.run(main())

🖥️ WHAT IT PRINTED · against a real account

connected: True
84 notebooks:
  0c276440  auth probe
  59c83b7b  Homework: Why Chiang Mai burns every March
  44b9c845  smolagents — Hugging Face's Tiny Python Agent Librar
  9de4b9ed  PostgreSQL & SQL Basics — Beginner Lab

5 Give it documents, then ask · ป้อนเอกสารให้มัน แล้วถาม · 给它文档，然后问

📄 NEW FILE · nb2.py

"""nb2.py — make a notebook, give it pages to read, and ask it a question."""
import asyncio
import sys

from notebooklm import AuthTokens
from notebooklm.client import NotebookLMClient

TITLE = "krueng.ai tutorials"
PAGES = ["https://krueng.ai/mailbot.html",
         "https://krueng.ai/gradio.html",
         "https://krueng.ai/python_classes.html"]

sys.stdout.reconfigure(encoding="utf-8")


async def find_or_make(client, title):
    """Use the notebook if it exists, otherwise make it. Run twice, safely."""
    for notebook in await client.notebooks.list():
        if notebook.title == title:
            print("using the notebook that is already there:", notebook.id[:8])
            return notebook
    notebook = await client.notebooks.create(title)
    print("made a new notebook:", notebook.id[:8])
    return notebook


async def main():
    auth = await AuthTokens.from_storage()
    async with NotebookLMClient(auth) as client:
        notebook = await find_or_make(client, TITLE)

        # Compare the addresses, not the titles. NotebookLM renames a source
        # to the page's own title, so matching on the file name never hits
        # and you quietly add everything a second time.
        already = {source.url for source in
                   await client.sources.list(notebook.id) if source.url}
        for url in PAGES:
            if url in already:
                print("  already has", url.rsplit("/", 1)[-1])
                continue

            # wait=True holds here until NotebookLM has fetched and read the
            # page. Without it you get a source id for something not ready,
            # and the first question comes back with nothing to cite.
            source = await client.sources.add_url(notebook.id, url, wait=True,
                                                  wait_timeout=300)
            print("  added", source.title[:48])

        sources = await client.sources.list(notebook.id)
        print(f"{len(sources)} sources in the notebook")

        # This is the part worth paying for. The answer comes only from the
        # sources, and it says which one each claim came from.
        answer = await client.chat.ask(
            notebook.id,
            "What does the mail bot use to decide whether to reply, "
            "and why was the earlier hidden watermark dropped?")
        print()
        print(answer.answer[:600])
        print()

        # The numbers in the answer, like [1-3], point at these. Each one
        # names the source it came from and quotes the exact sentence.
        by_source = {source.id: source.title for source in sources}
        print(f"{len(answer.references)} references behind that answer.")

        # Not every reference quotes a whole sentence. A page has headings,
        # table cells and navigation in it, and those get cited too. Show
        # the ones long enough to read.
        useful = [r for r in answer.references
                  if r.cited_text and len(r.cited_text.strip()) > 40]
        print(f"{len(useful)} of them quote a real sentence:")
        for reference in useful[:3]:
            where = (by_source.get(reference.source_id) or "?")[:30]
            quoted = " ".join(reference.cited_text.split())[:70]
            print(f"  [{reference.citation_number}] {where:32} {quoted}")


if __name__ == "__main__":
    asyncio.run(main())

🖥️ WHAT IT PRINTED · three pages in, one grounded answer out

using the notebook that is already there: ab9fda9b
  already has mailbot.html
  already has gradio.html
  already has python_classes.html
3 sources in the notebook

1. Loop Guard Check ([horoscope-bot] tag): The bot first checks if the
subject line contains its explicit tag [1, 4, 5]. Because email replies,
forwards, and out-of-office auto-responses quote the original subject
line back, finding this tag means the email is a response to the bot
itself [1, 4].

12 references behind that answer.
8 of them quote a real sentence.

6 Take the text and the briefing · เอาทั้งตัวข้อความและบทสรุปออกมา · 把正文和简报都取出来

📄 NEW FILE · bring1.py

"""bring1.py — ask NotebookLM to write a briefing, then bring it home.

NotebookLM does the reading and the synthesis. This takes the result out
of Google and puts it in a folder on your disk, where the rest of the
page can use it without asking anybody's permission again.
"""
import asyncio
import sys
from pathlib import Path

from notebooklm import AuthTokens
from notebooklm.client import NotebookLMClient

TITLE = "krueng.ai tutorials"
HOME = Path("research")

sys.stdout.reconfigure(encoding="utf-8")


async def main():
    HOME.mkdir(exist_ok=True)
    auth = await AuthTokens.from_storage()

    async with NotebookLMClient(auth) as client:
        notebook = next(n for n in await client.notebooks.list()
                        if n.title == TITLE)
        sources = await client.sources.list(notebook.id)

        # 1. The sources themselves, as plain text. This is what NotebookLM
        #    read, with the HTML stripped off for you.
        for source in sources:
            fulltext = await client.sources.get_fulltext(notebook.id, source.id)
            name = (source.url or source.title or source.id).rsplit("/", 1)[-1]
            target = HOME / (name.replace(".html", "") + ".txt")
            target.write_text(fulltext.content, encoding="utf-8")
            print(f"  {target.name:22} {len(fulltext.content):>7,} characters")

        # 2. The briefing NotebookLM writes itself. Generating one is slow,
        #    so reuse the last one rather than making a new one every run.
        reports = await client.artifacts.list_reports(notebook.id)
        if reports:
            print("reusing the briefing already there")
        else:
            print("asking for a briefing, this takes a minute")
            task = await client.artifacts.generate_report(notebook.id)
            await client.artifacts.wait_for_completion(notebook.id, task.task_id,
                                                       timeout=600)

        target = HOME / "briefing.md"
        await client.artifacts.download_report(notebook.id, str(target))
        print(f"  {target.name:22} {len(target.read_text(encoding='utf-8')):>7,} characters")


if __name__ == "__main__":
    asyncio.run(main())

🖥️ WHAT IT PRINTED · 163,000 characters in, 7,925 out

  mailbot.txt             44,052 characters
  python_classes.txt      67,756 characters
  gradio.txt              51,711 characters
asking for a briefing, this takes a minute
  briefing.md              7,925 characters

7 A local model answers from it · โมเดลในเครื่องตอบจากมัน · 本地模型从里面回答

📄 NEW FILE · index1.py

"""index1.py — the research goes in, a local model answers out of it.

Nothing here talks to Google. NotebookLM did its part in bring1.py and
left the text in a folder. From this point on the whole thing runs on
machines you can touch.
"""
import sys
import time
from pathlib import Path

from llama_index.core import Settings, SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.ollama import Ollama

HOME = Path("research")

# The Spark, from step 2. Long answers are where it wins.
OLLAMA = "http://spark.local:11434"
MODEL = "qwen2.5:14b"

# The sources are in English, Thai and Chinese, so the English-only
# embedding model would score a Thai paragraph the same as any other.
EMBEDDINGS = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

QUESTIONS = ["Why was the hidden white-text watermark dropped from the mail bot?",
             "What does gr.State do, and why not a plain variable?"]

sys.stdout.reconfigure(encoding="utf-8")


def build():
    """Read the folder, cut it into chunks, and embed every chunk."""
    # Settings is LlamaIndex's box of defaults. Set these two and every
    # other call in the library uses them.
    Settings.llm = Ollama(model=MODEL, base_url=OLLAMA, request_timeout=900)
    Settings.embed_model = HuggingFaceEmbedding(model_name=EMBEDDINGS)

    documents = SimpleDirectoryReader(str(HOME)).load_data()
    print(f"{len(documents)} documents read from {HOME}/")

    started = time.perf_counter()
    index = VectorStoreIndex.from_documents(documents)
    print(f"indexed in {time.perf_counter() - started:.1f}s")
    return index


def main():
    index = build()

    # top_k=3 means three chunks go to the model, not the whole folder.
    # That is the point: the model only reads what the search found.
    engine = index.as_query_engine(similarity_top_k=3)

    for question in QUESTIONS:
        started = time.perf_counter()
        answer = engine.query(question)
        print()
        print("Q:", question)
        print("  ", str(answer).strip()[:320])
        print(f"   ({time.perf_counter() - started:.1f}s, "
              f"{len(answer.source_nodes)} chunks used)")
        for node in answer.source_nodes:
            where = Path(node.metadata.get("file_name", "?")).name
            print(f"     {node.score:.3f}  {where}")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · the answer, and where it came from

4 documents read from research/
indexed in 6.7s

Q: Why was the hidden white-text watermark dropped from the mail bot?
   The hidden white-text watermark was dropped because it caused issues
   with SpamAssassin scoring hidden text, leading the bot's own emails
   to be flagged as spam.
   (6.8s, 3 chunks used)
     0.547  mailbot.txt
     0.499  mailbot.txt
     0.441  mailbot.txt

8 Try first. The answers are folded away. · ลองเองก่อน เฉลยพับซ่อนไว้ · 先自己试。答案折起来放着。

"""keep1.py — challenge 1: stop embedding the same text every single run."""
import sys
import time
from pathlib import Path

from llama_index.core import (Settings, SimpleDirectoryReader,
                              StorageContext, VectorStoreIndex,
                              load_index_from_storage)
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.ollama import Ollama

HOME = Path("research")
SAVED = Path("index_store")

OLLAMA = "http://spark.local:11434"
MODEL = "qwen2.5:14b"
EMBEDDINGS = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

sys.stdout.reconfigure(encoding="utf-8")


def settings():
    """The same two defaults as index1.py, in one place."""
    Settings.llm = Ollama(model=MODEL, base_url=OLLAMA, request_timeout=900)
    Settings.embed_model = HuggingFaceEmbedding(model_name=EMBEDDINGS)


def load_or_build():
    """Read the saved index if it is there, otherwise build and save it."""
    settings()
    started = time.perf_counter()

    if SAVED.exists():
        # The embeddings are already computed and written down. This reads
        # numbers off the disk instead of running the model again.
        storage = StorageContext.from_defaults(persist_dir=str(SAVED))
        index = load_index_from_storage(storage)
        how = "loaded from " + SAVED.name
    else:
        documents = SimpleDirectoryReader(str(HOME)).load_data()
        index = VectorStoreIndex.from_documents(documents)
        index.storage_context.persist(persist_dir=str(SAVED))
        how = "built and saved"

    print(f"{how} in {time.perf_counter() - started:.2f}s")
    return index


def main():
    index = load_or_build()
    engine = index.as_query_engine(similarity_top_k=3)
    answer = engine.query("What is the loop guard in the mail bot?")
    print(str(answer).strip()[:220])


if __name__ == "__main__":
    main()

built and saved in 2.34s
loaded from index_store in 0.29s

"""both1.py — challenge 2: ask NotebookLM and your own copy the same thing."""
import asyncio
import sys
import time
from pathlib import Path

from llama_index.core import Settings, StorageContext, load_index_from_storage
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.ollama import Ollama
from notebooklm import AuthTokens
from notebooklm.client import NotebookLMClient

TITLE = "krueng.ai tutorials"
SAVED = Path("index_store")
OLLAMA = "http://spark.local:11434"
MODEL = "qwen2.5:14b"
EMBEDDINGS = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

QUESTION = "Why was the hidden white-text watermark dropped from the mail bot?"

sys.stdout.reconfigure(encoding="utf-8")


async def ask_notebooklm(question):
    """Google reads the sources and answers, with citations."""
    auth = await AuthTokens.from_storage()
    async with NotebookLMClient(auth) as client:
        notebook = next(n for n in await client.notebooks.list()
                        if n.title == TITLE)
        started = time.perf_counter()
        answer = await client.chat.ask(notebook.id, question)
        return answer.answer, len(answer.references), time.perf_counter() - started


def ask_local(question):
    """Your machine reads its own copy and answers, with scores."""
    Settings.llm = Ollama(model=MODEL, base_url=OLLAMA, request_timeout=900)
    Settings.embed_model = HuggingFaceEmbedding(model_name=EMBEDDINGS)
    index = load_index_from_storage(
        StorageContext.from_defaults(persist_dir=str(SAVED)))
    started = time.perf_counter()
    answer = index.as_query_engine(similarity_top_k=3).query(question)
    return str(answer), len(answer.source_nodes), time.perf_counter() - started


def main():
    print("Q:", QUESTION)
    print()

    said, refs, spent = asyncio.run(ask_notebooklm(QUESTION))
    print(f"NotebookLM   {spent:5.1f}s, {refs} references, needs the internet")
    print("  ", " ".join(said.split())[:260])
    print()

    said, chunks, spent = ask_local(QUESTION)
    print(f"your machine {spent:5.1f}s, {chunks} chunks, needs nothing")
    print("  ", " ".join(said.split())[:260])


if __name__ == "__main__":
    main()

Q: Why was the hidden white-text watermark dropped from the mail bot?

NotebookLM    15.0s, 3 references, needs the internet
   ...SpamAssassin score hidden text as suspicious, which caused the
   mail bot's outgoing messages to land in rec

your machine   7.9s, 3 chunks, needs nothing
   ...it caused issues with SpamAssassin scoring hidden text, which
   led to the bot's own emails being flagged as spam

pip install smolagents openai

"""agent1.py — challenge 3: give the research to an agent as a tool.

The query engine answers when you call it. A tool is the same engine,
handed to a model that decides for itself whether the question needs it.
"""
import os
import sys
from pathlib import Path

from llama_index.core import Settings, StorageContext, load_index_from_storage
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.ollama import Ollama
from smolagents import OpenAIServerModel, ToolCallingAgent, tool

SAVED = Path("index_store")
OLLAMA = "http://spark.local:11434"
MODEL = "qwen2.5:14b"
EMBEDDINGS = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

# smolagents talks the OpenAI dialect, which Ollama also speaks.
LLM_URL = os.environ.get("LLM_URL", OLLAMA + "/v1")
LLM_KEY = os.environ.get("LLM_KEY", "ollama")

sys.stdout.reconfigure(encoding="utf-8")

Settings.llm = Ollama(model=MODEL, base_url=OLLAMA, request_timeout=900)
Settings.embed_model = HuggingFaceEmbedding(model_name=EMBEDDINGS)
index = load_index_from_storage(
    StorageContext.from_defaults(persist_dir=str(SAVED)))
engine = index.as_query_engine(similarity_top_k=3)


@tool
def search_the_tutorials(question: str) -> str:
    """Look something up in the krueng.ai tutorials and answer from them.

    Args:
        question: a question about the mail bot, Gradio or Python classes
    """
    return str(engine.query(question))


def main():
    llm = OpenAIServerModel(model_id=MODEL, api_base=LLM_URL, api_key=LLM_KEY)
    agent = ToolCallingAgent(tools=[search_the_tutorials], model=llm)

    for question in ["What stops the mail bot replying to itself?",
                     "What is the capital of Thailand?"]:
        print()
        print("Q:", question)
        print("A:", str(agent.run(question))[:260])


if __name__ == "__main__":
    main()

Q: What stops the mail bot replying to itself?
   Calling tool: 'search_the_tutorials'
A: The mail bot checks the subject of incoming emails for a specific
   tag [horoscope-bot]. If it sees that an email already has this
   tag, it won't send another horoscope.

Q: What is the capital of Thailand?
   Calling tool: 'search_the_tutorials'
   Observations: Bangkok
A: Bangkok

"""ask_app.py — challenge 4: the research, as a page you can ask.

Also does the thing index1.py did not: refuse to answer when the search
did not actually find anything.
"""
import sys
from pathlib import Path

import gradio as gr
from llama_index.core import Settings, StorageContext, load_index_from_storage
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.ollama import Ollama

SAVED = Path("index_store")
OLLAMA = "http://spark.local:11434"
MODEL = "qwen2.5:14b"
EMBEDDINGS = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

# Below this, the search found nothing worth answering from. Measured on
# this folder: a real question scores about 0.5, nonsense about 0.07.
ENOUGH = 0.25

sys.stdout.reconfigure(encoding="utf-8")

Settings.llm = Ollama(model=MODEL, base_url=OLLAMA, request_timeout=900)
Settings.embed_model = HuggingFaceEmbedding(model_name=EMBEDDINGS)
engine = load_index_from_storage(
    StorageContext.from_defaults(persist_dir=str(SAVED))
).as_query_engine(similarity_top_k=3)


def answer(question):
    """Answer from the research, or say plainly that it is not in there."""
    if not question.strip():
        return "", []

    found = engine.query(question)
    rows = [[round(node.score, 3), Path(node.metadata.get("file_name", "?")).name,
             " ".join(node.text.split())[:90]] for node in found.source_nodes]

    best = found.source_nodes[0].score if found.source_nodes else 0
    if best < ENOUGH:
        return (f"Not in the research. The closest thing scored {best:.3f}, "
                f"and anything under {ENOUGH} is noise."), rows
    return str(found).strip(), rows


with gr.Blocks(title="Ask the research") as demo:
    gr.Markdown("## Ask the research\nAnswered only from the notebook, on this network.")
    question = gr.Textbox(label="Your question", scale=3)
    said = gr.Markdown(label="Answer")
    chunks = gr.Dataframe(headers=["score", "file", "what was found"],
                          label="What the search actually found", wrap=True)
    question.submit(fn=answer, inputs=question, outputs=[said, chunks])

    # The first two are the same question. The vague one scores 0.31 and
    # gets nothing; the specific one scores 0.547 and gets the answer.
    # Click both, and watch the score column rather than the text.
    gr.Examples(examples=["Why was the hidden watermark dropped?",
                          "Why was the hidden white-text watermark dropped "
                          "from the mail bot?",
                          "What does gr.State do?",
                          "How do I bake sourdough bread?"],
                inputs=question)

if __name__ == "__main__":
    demo.launch()

Q: Why was the hidden watermark dropped?
A: The context does not mention a specific reason...   top chunk 0.31

Q: How do I bake sourdough bread?
A: Not in the research. The closest thing scored 0.073,
   and anything under 0.25 is noise.            top chunk 0.073