NotebookLM: an AI that only knows your documents

General AI knows a little bit of everything — and when it doesn't, it sometimes fills the gap anyway. That's the price of answering from what it saw during training: an enormous pile of text that never included your lecture notes, your company's policy manual, or your contract. Google's NotebookLM goes the other way. You upload sources, it answers exclusively from them, and for every sentence it shows you which document and which passage it came from.

That difference sounds like a detail and is actually a change of genre. A regular chat is an expert talking off the top of its head. A notebook grounded in your own sources is a librarian who never recites from memory — it always fetches the book and points at the line. For studying from lecture notes, getting your bearings across thirty contracts, searching internal company documentation, or onboarding a new hire, that's exactly the mode you need: an answer you can verify in ten seconds.

This guide walks the whole path: when to use a notebook and when not to, how to pick and prepare sources (the most common mistake happens right here), how to ask questions, what to do with audio overviews, where the limits are — and how to combine the tool with Claude or ChatGPT. The prompts are ready to copy — just fill in the brackets.

A typical scenario

Adam is studying medicine, has three days until his exam, and three hundred pages of lecture notes he never properly opened all semester. The usual approach: read from the start, realize after twenty pages that nothing is sticking, and spend the rest of the night hunting through the PDF for terms he hopes will be on the test.

Instead, Adam creates a notebook and uploads exactly three things: the lecture notes, the slide decks from that specific professor's lectures, and the list of exam topics. Nothing else — no articles pulled from the internet, no borrowed notes from a different program. Then he asks the way he'd be asked at the exam: “explain mechanism X the way my lecture notes describe it,” “for every topic on the uploaded list, tell me where it's covered in the materials and how thoroughly,” “write me thirty practice questions from chapters 3 through 5.” Every answer comes with a citation, so when something sounds off, he clicks it and sees the original paragraph five seconds later.

The result after the first evening: a list of topics the materials don't cover at all (which he now has to look up elsewhere), a reading plan for what to read in full versus skim, and a set of practice questions. In three days he gets through material that would otherwise take a week — and, more importantly, he's studying what the examiner will actually ask, not what the internet thinks about the topic. The same mechanic works just as well for a sales director with thirty vendor contracts, or a new hire handed fifteen pages of internal wiki.

Phase 1: when to use the notebook, and when to use regular chat

The decision that saves the most disappointment comes first. NotebookLM is a specialized tool, not a better chat — and used on the wrong job it looks foolish.

What grounding in sources actually changes

A regular chat generates an answer from what it learned during training, plus whatever you pasted into the conversation. Ask it something that isn't in your document, and it usually answers just as fluently — purely from general knowledge — and you can't tell from the output. A notebook grounded in sources isn't supposed to do that: if the answer isn't in the sources, it should say so.

In practice that gives you three differences worth having:

• Answers are bounded by your material. Ask “what's the notice period” and you don't get a general answer about the law — you get what your actual contract says.
• Every answer carries a citation. The side panel shows the passage a claim came from — the only form of verification fast enough that you'll actually do it.
• Gaps are visible. Ask about something the sources don't cover and you'll find out — and “this isn't in my materials” is often worth more than an answer would have been.

When to use the notebook, and when to use chat

The notebook is the right choice when at least two of these are true: you have a lot of text (dozens to hundreds of pages), the text is yours or binding on you (lecture notes, policies, contracts, documentation, transcripts), and it matters that the answer comes from that text rather than general knowledge. Typically: exam prep, getting oriented in product documentation, searching a folder of contracts, research from articles you downloaded yourself, onboarding into internal procedures.

It's not worth opening the notebook, on the other hand, when you need to create something from nothing, work with data, or reach beyond your own material. Writing an email, running calculations over a spreadsheet, code, brainstorming, working with the live web, working with files on disk — all of that is work for Claude or ChatGPT.

Quick rule of thumb: asking about the content of documents you already have? Notebook. Want to produce, calculate, or arrange something? Chat.

Phase 2: setting up the notebook and preparing sources

Answer quality gets decided here, not in the prompts. A notebook is exactly as good as what's inside it — and the most common mistake is uploading “everything, just in case.”

One notebook, one topic

Organize notebooks by topic, not by file type. One notebook per exam, one per project, one for vendor contracts, one for onboarding into a role. Mix your thesis materials, a contract from a side gig, and notes from a family vacation into the same notebook, and answers will blend worlds that have nothing to do with each other.

The number of sources per notebook is capped (roughly dozens, more on paid tiers), and that's more of a feature than a limitation. It forces you to choose.

What to upload, and what not to

Upload what's relevant and authoritative: binding documents, the material you'll actually be tested on, current versions of policies, transcripts of meetings that really happened. Supported formats include PDFs, Google Docs, text files, links to web pages, YouTube videos, and in newer versions even audio recordings.

Don't upload:

• Duplicates and old versions. Two versions of the same policy turn the notebook into an unreliable source — you'll get an answer from whichever one it happened to find first.
• “For context” material nobody actually reads. A hundred sources with ten relevant ones will make the answers about those ten worse.
• Material of uncertain standing. Lecture notes from a different program, a contract draft that was never signed, a blog post about a law instead of the law itself.

Anonymize before you upload anything

Before you upload anything containing personal data — a contract with names, national ID numbers, and addresses; HR files; medical records; client data — remove the data or replace it with placeholder names. For an answer about the notice period, you don't need to know that the landlord is John Smith, born on such and such a date.

The rule that applies across this whole site applies here too: sensitive data only belongs in a paid account with a contractual data-protection agreement, never in the free tier of any service — and even there, without identifying combinations. When you're not sure whether you're allowed to upload something, ask whoever owns the document.

Check what's actually in the notebook

The first question in a new notebook shouldn't be about content — it should be an inventory. You want to know what you actually uploaded and what the notebook can actually see, especially with scanned PDFs, where a file can turn out to be nothing but an image of a page, and the machine reads back only half of it.

Give me an inventory of the uploaded sources. For each source list:
- the file name and, in one sentence, what it's about
- the document type (lecture notes, slides, contract, policy,
  transcript, article, web page)
- roughly how long it is and how detailed (overview vs. detail)
- text quality: is it fully readable, or are there passages
  that don't make sense, are missing, or look like a badly
  recognized scan

At the end, write two things:
1. Which sources overlap in content
2. Which sources are not actually related to [notebook topic]

It usually turns up one or two surprises: a document uploaded by mistake, a scan that's only half legible. Take passages flagged as unreadable seriously — badly recognized scans most often mangle numbers and diacritics, so the biggest risk is in dates, amounts, and deadlines.

A content map as the second step

Once you know what's in the notebook, you need to know what you'll find in it. This prompt builds a table of contents across all sources at once — something no single document has on its own.

Go through all uploaded sources and build a content map of the
whole notebook:

1. The main topics that appear across the sources — rank them
   by how much space the materials give each one
2. For each topic, which sources cover it and how thoroughly
   (one mention / a whole chapter)
3. Topics that appear in only one source
4. Topics where the sources reinforce each other — and topics
   where they appear to contradict each other

Don't add anything that isn't in the uploaded sources. Where
you're not sure, say so instead of guessing.

Point 4 is the reason to run this prompt. A contradiction between two sources is always a signal: either you have an old version of a document, or you've hit a genuine dispute you need to resolve — for contracts, by calling the other party; for academic sources, by citing both positions.

Phase 3: asking questions — prompts that get real work out of the notebook

The notebook answers better the more specific the question is. “Summarize this for me” is about the worst instruction you can give it — it returns generic filler. The prompts below are built so the output can be used directly.

A query on a single source

When you need to dig into one specific document, say so explicitly — otherwise the answer will blend material from all of them.

Take ONLY the source [file name] and turn it into a structured
breakdown:
- what the document is about, in 5 sentences
- the main claims or provisions, each with a reference to
  where it appears in the document
- passages that are ambiguously worded or contradict each other
- terms the document uses but doesn't define
- what's missing from the document by its own logic (refers to
  an appendix that isn't there, cites a clause it doesn't
  include, etc.)

Draw exclusively from this one source. Ignore everything else.

Returns a breakdown that's usable both as prep for a meeting and as a first read before detailed study. The last point is usually the most valuable one for contracts and policies: a document that refers to an appendix you don't have is a document you haven't actually read in full.

Comparison across sources

The notebook does this better than anything else, because it holds every document at once and doesn't have to keep them in memory.

Compare how [topic or term] is handled across all uploaded
sources.

Build a table: source | how it describes it | exact wording
(short quote) | how it differs from the others.

Below the table, write:
- where all the sources agree
- where they directly diverge, and on what exactly
- which source is the most detailed on this question
- which of these versions I should treat as authoritative,
  and why (if that's determinable from the sources — if not,
  say so)

For research you get a map of positions; for contracts, an overview of clauses that differ between vendors; for documentation, the discovery that three wiki pages describe the same process three different ways. Watch the last point closely: the notebook has no way of knowing which document takes precedence, and when it's asked to guess, it sometimes does.

Questions the sources don't answer

The most useful prompt in the whole guide. It flips the logic: instead of hunting for answers, you hunt for gaps.

I'm about to [take an exam in this subject / sign this
contract / take over this role / write a research paper on
this topic] — context: [one to three sentences about the
situation].

List 15 questions I'll need answered in this situation, and
split them into three groups:
A) the uploaded sources answer these clearly — for each, give
   the answer and its source
B) the sources answer these only partly or ambiguously — write
   what's there and what's missing
C) the sources don't answer these at all — write where I
   should look for the answer instead

Don't fill in group-C answers from general knowledge.

Group C is why this prompt should be one of the first ones you run. For an exam, it tells you what to go look up elsewhere. For a contract, it gives you a list of questions for the other party — right in the spirit of the tip a contract before you sign. For a role you're taking over, it gives you a list of questions for your predecessor while they're still around to answer.

Practice questions and drilling

For studying, this is the main output. The difference from general AI is fundamental: the questions come from what the examiner will actually ask, not from what's typically expected on the topic.

From chapters [3 through 5] of the uploaded lecture notes,
write me 30 practice exam questions.

Split them into three levels:
- 10 recall questions (definitions, lists, values)
- 10 comprehension questions (explain the mechanism, why it
  works this way)
- 10 application questions (a scenario where the material
  gets applied)

For each question, give: the correct answer per the lecture
notes, a reference to the page or chapter, and for application
questions, a typical mistake people make on it.

Word the questions the way an examiner would, not like a quiz.
Only ask about what's in the uploaded materials.

Returns a set you can work through for several days. Try answering the questions yourself first, and only then look at the answers — passively reading prepared answers is about the least effective way to study there is. The generated questions are good candidates to move into a spaced-repetition app — see spaced repetition for studying.

Explanations based on your own materials

When you don't understand the material, you want an explanation — but one that doesn't drift away from what you'll actually be asked.

Explain [topic / term / mechanism] to me the way my uploaded
materials present it. Go through it like this:

1. First, in one sentence, what it is
2. Then in detail, but in plain everyday language — as if
   explaining it to someone who just started the subject
3. Then exactly the way the lecture notes phrase it, with a
   citation
4. Finally: where my simplified explanation differs from the
   lecture notes' wording, and what I shouldn't say at the exam

If the materials only cover the topic superficially, say so
and don't add anything that isn't in them.

Point 4 is insurance against what you might call “I understood it, but said it wrong” — your own simplification is great for understanding and dangerous for reproducing.

Notes and summaries that stick around

The notebook can save an answer as a note right inside the workspace. It's worth using: a good answer you don't capture is one you'll be hunting for again in two days.

Build me a study summary of [topic] from the whole notebook,
structured like this:

## What I need to know
bullet points with key facts, each with a source reference

## How it all connects
relationships between concepts, not just a list of them

## Common mix-ups
pairs of concepts people confuse, and how to tell them apart

## Where it is in the sources
chapters and pages to return to for detail

Write it dense, no intros, no summaries. It should fit on two
pages.

Save the output as a note and leave it in the notebook — notes can be used as another source, so you can refer back to them in later questions. That way you gradually build a distilled layer on top of the original documents.

Phase 4: audio overviews — documents you can listen to

The feature that made NotebookLM famous even among people who've never used it for work: it turns your uploaded sources into a two-voice conversation that talks about your documents the way podcast hosts would. It sounds like a gimmick, and it partly is one — but it has a handful of uses nothing else covers as well.

When an audio overview actually helps

• A first pass through material. Before you dive into three hundred pages, spend twenty minutes listening to what's in them. You won't get details, you'll get a map — and reading is a different experience once you have one.
• Dead time. The commute, a walk, doing the dishes. Material you'd otherwise never read gets a chance to be heard.
• A second pass before an exam. Listening to material you already know works like a review — you hear connections between topics, not individual facts.
• Handing off context on a team. A colleague who doesn't have time to read a fifty-page brief can listen to an overview on the way to a meeting and show up at least roughly prepared.

Getting more out of the audio than entertainment

The default overview is conversational and sometimes a bit too breezy. The tool lets you steer the generation — specify what it should focus on and who it's for. The same instructions work as a text prompt too, if you want a script instead of audio:

Generate an audio overview focused like this:

Audience: [a student before an exam / a colleague taking over
a project / company leadership]
Goal of listening: [understand the main topics before reading
in detail / know what I might get asked / make a decision]

Focus on:
- [topic A], [topic B] — cover these in depth
- connections between topics, not lists of facts
- places where the sources disagree

Skip: [general intros, the history of the field, motivational
filler].
Keep the tone factual, no joking around. Length around
[15] minutes.

Returns an overview usable as prep, not as entertainment. Check the accuracy of a translated or localized overview by listening to the first two minutes — if the result is off, it's faster to generate a text script instead and read it.

A limit that applies doubly to audio

Audio has no citations. You can't click through and see where a claim came from, and you can't tell where the overview simplified something or invented a connection between topics. Treat it as orientation, never as a source. Anything you use further from the overview, go find in the text.

Phase 5: use cases — five situations, and what to do differently in each

The mechanics stay the same, but what you upload and what you ask differs a lot from one situation to the next.

Studying and exam prep

Upload the lecture notes, the slide decks from that specific professor, the list of exam topics, and your own class notes. Don't upload other people's worked answers you found online — they contain mistakes you'll only discover at the exam. A three-day plan: first evening, run the inventory, content map, and gap-finding prompt; second day, get explanations for topics you don't understand and generate practice questions; third day, drill and use the audio overview as review. The key thing: say the answers out loud before checking what the notebook returned.

Research and academic literature

Upload articles you found and downloaded yourself. Never let the model “add relevant literature” — the notebook can't do that anyway, which is a good thing, because general-purpose chat tools asked for this will invent titles that sound convincing and don't exist. The most useful prompts here are the cross-source comparison and a map of how a term is defined. A complete workflow for a thesis has its own guide: a bachelor's thesis with AI.

Company documentation

Upload internal policies, process descriptions, product documentation, and FAQs. The biggest payoff isn't search — plain full-text search handles that reasonably well too — it's questions full-text search can't answer: “does this process also apply to clients abroad?”, “who approves an exception, and based on what?”

The essential condition: one version of each document. Company wikis typically hold three to five versions of the same procedure from different years. Before you start uploading, go through and upload only the current wording — otherwise you build a tool that confidently answers from the oldest document in the pile.

Go through the uploaded documentation and find inconsistencies
in it:

1. Places where two documents describe the same thing
   differently — for each, give both versions and their sources
2. Procedures that reference a document, form, or system that
   isn't among the uploaded sources
3. Steps where it's not stated who does them or who approves
   them
4. Passages that look outdated (reference tools, roles, or
   deadlines that don't hold elsewhere)

For each finding, note what it's about and where in the
documentation it is. Don't fix it, just list it.

The output is a documentation audit that would take days to do by hand. Run it periodically — say, twice a year — and route the findings to whoever owns each document.

Legal documents and contracts

Upload contracts, terms and conditions, and any appendices they reference. Anonymize names and identifiers. And above all: the output is not a legal opinion. The notebook shows you what the contract says, not whether it's sound or will hold up.

The uploaded documents are [vendor contracts / terms and
conditions]. Build a comparison table from them.

Table: document | term length | notice period | how automatic
renewal works | penalties and their amounts | who can
unilaterally change terms | governing law and jurisdiction.

Where a term is missing from the contract, write “not
specified” — don't fill it in from general legal knowledge.

Below the table, list:
- the contracts that differ most from the others, to our
  disadvantage
- clauses I don't understand even after reading them and
  need a lawyer for
- deadlines these contracts create for the next 12 months

The last point is the practical one: an automatic renewal nobody caught is the most expensive mistake in this category. Put the deadlines straight into your calendar with a reminder a month ahead. And for anything with financial consequences: AI proposes, a human approves — signing, terminating, and paying are always a human decision.

Onboarding and handing off a role

Upload internal procedures, templates, FAQs, and meeting notes related to the role. A new hire can then ask the notebook instead of interrupting colleagues fifteen times a day — and, importantly, they can ask things they'd be embarrassed to ask for the fourth time.

I'm new in the role of [role] and was given these materials.
Build me an orientation plan for the first two weeks:

1. What to read, in what order, and why (reference specific
   sources)
2. 10 things I need to know on day one
3. Processes my role is part of — for each, my role in it and
   who it hands off to
4. Abbreviations, internal terms, and system names that appear
   in the materials without explanation
5. Questions the materials don't answer and I need to ask a
   person — ranked by urgency

Draw only from the uploaded materials.

Point 4 is something nobody at the company notices, because everyone already knows those abbreviations. Point 5 is a list a new hire can take straight to their manager — once, with everything at once, instead of fifteen separate interruptions. It also pairs well with a persistent-context Project as described in onboarding a new hire, which, unlike the notebook, can also write and draft things.

Phase 6: limits, and combining it with Claude or ChatGPT

The notebook is a single-purpose tool, and single-purpose is its strength. The moment you want something else out of it, you need a second tool.

What the notebook can't do

• It knows nothing outside the sources. It won't add context, compare your contract against standard market practice, or tell you what's typical in the industry.
• It doesn't calculate. Like any language model, it doesn't run a computation, it generates text that looks like one. Let a script handle numbers pulled from tables — don't ask the notebook to.
• It doesn't touch files on disk and doesn't run anything. It won't rename, convert, or generate a chart.
• It has no connectors into your apps. It can't reach into mail, a calendar, or Notion.
• It's not an author. It can summarize and structure, but writing text in your own voice, drafting an email, or building a presentation is work for a chat tool.
• Citations aren't infallible. They point to the passage a claim came from, but the wording of the answer can be stronger than the original. Open the original for anything that matters.

A division of labor that works

The best results come from a workflow where the notebook does the grounding and the chat tool does the producing: you ask questions in the notebook and pull out verified material with citations, then let Claude or ChatGPT turn it into an output — text, a presentation, an email, a spreadsheet, a script. The key word is “verified”: what goes into the chat is what you clicked through and confirmed against citations, not the raw answer.

I'm attaching a verified excerpt from source material. Every
claim in it is backed by a citation from sources I have access
to.

[paste the excerpt including citations]

Turn this into [a meeting brief / a chapter / an email to a
client / a 10-slide presentation] for the audience [who] with
the goal [what the audience should do or understand].

Rules:
- use only claims from the attached excerpt
- don't add anything from your own knowledge, even things that
  are common knowledge
- keep citations attached to the claims they belong to
- where you're missing material for a smooth transition, write
  TODO: [what's needed] on its own line instead of filling
  the gap

The TODO rule is the essential part. Without it, the model fills the gap with a sentence that sounds fine and has no support behind it — and you won't be able to tell in the finished text.

Which tool, when

• NotebookLM — when the question is “what do my documents say about this,” and traceability matters.
• Claude — when you need to work with files in a folder (Claude Cowork), write and run scripts (Claude Code), connect to mail, a calendar, or Notion through connectors, spin up a small app as an artifact, or hold persistent context in a Project. It also handles reading scans and handwriting, and in-depth research with citations from the live web.
• ChatGPT — when you're already working in it, need everyday text work, and don't want to switch tools; it can handle uploaded files too, but source traceability isn't as clear as in the notebook.

A practical note on peer review: when you have material assessed, use a different tool than the one you used to produce it. A model that helped write the text judges it leniently.

Verification is still on you

Grounding in sources lowers the risk of invented claims — it doesn't eliminate it. The notebook can misread a scan, merge two passages into one sentence, or phrase a source's cautious claim as a certainty. The baseline stays the same as with any AI: for anything with consequences — at an exam, on a signature, in an email to a client — open the citation and read the original. The full process is in the tip fact-checking with AI.

Common mistakes

• Uploading everything “just in case.” A hundred sources with ten relevant ones makes the answers about those ten worse. The notebook gets better the more strictly you curate what belongs in it.
• Leaving old versions of documents in the notebook. Two versions of the same policy turn the tool into an unreliable advisor that confidently answers from the wrong one. Clean up before you upload.
• Trusting a citation without clicking it. A citation is an invitation to verify, not proof. The wording of an answer tends to be stronger than the original text — especially with cautiously worded academic sources.
• Uploading un-anonymized personal data. Names, national ID numbers, addresses, medical or HR data belong only in a paid account with a contractual data-protection agreement, and even there without identifying combinations.
• Using the audio overview as a source. It has no citations and it simplifies. It's orientation before reading, not a replacement for reading.
• Asking the notebook to do a chat tool's job. Writing, calculations, working with files, and app connections aren't what it's for — force it anyway and you'll get a worse result than a regular chat would have given you.

The best tools

• NotebookLM — the core of the whole approach: answers exclusively from uploaded sources, citations down to the exact passage, audio overviews, and notes that can be used as another source.
• Claude — the other half of the pair: producing text and presentations from a verified excerpt, working across a folder of files in Cowork, scripts and calculations in Claude Code, connectors into mail and calendar, persistent context in Projects.
• ChatGPT with uploaded files — an alternative if you're already working in it and don't want to switch; also handy as a second opinion on material produced elsewhere.
• A spaced-repetition app — Anki and similar tools: where generated practice questions belong, so they turn into long-term memory.
• A tool for cleaning up PDFs and scans — before uploading scanned lecture notes, confirm the file has a text layer; reading from an image of a page is noticeably worse, and numbers suffer the most.

What you get out of it

• Time: instead of searching through three hundred pages, you ask a question and get an answer in seconds. For exam prep, typically several hours per subject; for company documentation, tens of minutes a week; for taking over someone else's role, easily two full days.
• Money: a contract comparison table surfaces automatic renewals and penalties that would otherwise slide by unnoticed — one caught renewal pays for all the time you put in.
• Peace of mind: answers come from what you're actually being asked for. The doubt over whether you're studying the right thing disappears.
• Quality: citations mean verification takes ten seconds instead of ten minutes — which is why you'll actually do it. That's the difference between “it should be like this” and “I know exactly where it says so.”

Pro tip

The best question to ask a notebook isn't about content — it's about the edges of the content. Ask “what's not answered in the sources” — for an exam it tells you what you still need to look up elsewhere, for a contract it generates a list of questions for the other party, for documentation it exposes processes nobody ever wrote down. Most tools are good at finding what's there; the value of this one is that it can reliably show you what isn't.

And the closing rule: the notebook changes where the answer comes from, not who's responsible for it. A citation cuts verification down to ten seconds — but you're the one who still has to do those ten seconds.