Claude Code gets unlimited free memory

You already know Claude is powerful.

But Claude has a problem: amnesia.

Every new session, it starts from close to zero. Feed it a huge PDF or a folder of research and it can read it, sure, but that costs tokens, fills up your context window, and disappears the second the chat ends.

The old way?

Re-upload the same files. Re-explain the same project. Watch your context window fill up before you’ve even started the real work.

Now there’s a free tool that flips this.

Enter Gemini Notebook (formerly NotebookLM). You dump your sources into it once, and it becomes a permanent, searchable knowledge base that answers questions with citations, straight from those sources.

Connect it to Claude Code or Codex, and you split the work properly:

Gemini Notebook holds and interrogates the source material. Claude does the reasoning, coding, and execution.

That’s the real unlock. Not “stop switching tabs.” Stop making Claude be both the brain and the library.

What you need before you start:

• A Mac or Windows computer.
• Claude Code or Codex, already installed and working.
• A Google account (any account that can sign into Gemini Notebook works)

The tool doing the heavy lifting here is notebooklm-py, an open-source library that gives AI agents full programmatic access to Gemini Notebook.

One thing worth knowing upfront: it’s unofficial. It works by driving Gemini Notebook through undocumented Google APIs, not a public developer API. That means it’s genuinely powerful (it can do things the Gemini Notebook web app can’t, like bulk downloads and scriptable exports), but it can also break if Google changes something on their end. Keep that in mind before you build anything mission-critical on top of it.

Setup is one sentence. Open Claude Code (or Codex) and type:

Ask Claude to install https://github.com/teng-lin/notebooklm-py

Claude will pull the repo and install the skill for you. Partway through, it’ll ask you to sign into Gemini Notebook through a browser window it opens. Sign in like you normally would, and Claude grabs the login token it needs behind the scenes.

Once that’s done, Claude will confirm it can see your notebooks. That’s it. You’re connected.

Let’s start from scratch, no existing notebook required.

Say you just landed a new client. Normally that means an hour of reading their brand guide, old reports, and call notes before you’re actually useful to them.

Here’s a prompt you can copy:

Create a new Gemini Notebook notebook called “Acme Co Onboarding.” Add these sources: [their website], [brand guidelines PDF], [last quarter’s campaign report], [discovery call transcript]. Once they’re loaded, give me a one-page brief: who this client is, what they’ve already tried, and what worked or fell flat.

Claude creates the notebook, adds each source, waits for Gemini Notebook to process them, then hands you a brief with citations back to exactly which document each point came from.

Notice what didn’t happen: you didn’t spend an hour reading, and you didn’t paste four documents’ worth of text into your chat window. That’s billable prep time you get back.

Here’s where the ROI gets obvious.

Gemini Notebook can generate, from the same source material: a slide deck (as an actual editable PPTX or PDF), a written report (blog post, study guide, or briefing doc format), an infographic, a data table, and more. All from sources you already loaded.

Say you’re prepping a pitch or a quarterly review. One prompt fans it out across every deliverable at once:

Using my Acme Co Onboarding notebook, generate a slide deck for the pitch, a one-page PDF summary I can email ahead of the call, and a briefing-doc report covering what we’d recommend and why. Download all three to my desktop.

That’s a deck, a leave-behind, and a written recommendation, grounded in the client’s own history, generated on Google’s infrastructure, at no extra cost beyond your existing plan. What used to be an afternoon of formatting is now the time it takes Gemini Notebook to render three files.

Everything so far still depends on you remembering to feed sources into the notebook after the fact. Fine for a one-time onboarding. It breaks down the moment you’re juggling several accounts, because forgetting to log a call is exactly how details slip through the cracks.

Fix that by connecting an AI notetaker to Claude directly, so transcripts land in the notebook without you exporting or copy-pasting anything.

A few meeting tools now ship their own MCP connector for this. Granola is one of the more established options right now (it captures bot-free, and its MCP connector plugs straight into Claude Code), and others like Fathom offer something similar. Worth checking Claude’s current connector directory before you commit to one, since this space moves fast and the field will likely look different in a few months.

Once it’s connected, here’s the workflow after any client call:

Pull the transcript from my last call with Acme Co, and add it as a new source in the Acme Co Onboarding notebook in Gemini Notebook.

Claude fetches the transcript from the notetaker, hands it to Gemini Notebook as a source, and it’s filed. No exporting, no dragging a file into a browser tab, no “I’ll upload that later” that quietly never happens.

Now you can ask:

What did we actually agree to on the last call with Acme?

And get a cited answer pulled from the real transcript, not from the three bullet points you managed to scribble down mid-call.

One thing worth doing before you wire this up: check the data-sharing setting inside whatever notetaker you use. Most have a separate toggle for “use my recordings to train your models” versus simply letting you pipe your own transcript into Claude. Turn it off if you’re handling anything client-confidential. And if you or your client are in a two-party consent state, make sure whoever’s on the call still knows it’s being recorded, same as with any notetaker.

This is the part that solves Claude’s amnesia problem for real, and it’s the one with the clearest ROI for client work, especially once it’s running on the notetaker feed from the last step instead of on your memory.

The idea: keep one running notebook per client, a “Client Brain,” and have every call file itself into it automatically. No more re-explaining the account to Claude, or to yourself, every time you pick it back up.

Here’s the pattern:

Step 1. After a client call, or on a schedule so you don’t have to remember, tell Claude:

Check for any new call transcripts with Acme Co, pull them in, and save the key decisions, action items, and anything they flagged as a concern, as a note in my Acme Co Brain notebook.

Step 2. Add one line to your project instructions (in Claude Code, this lives in your CLAUDE.md file):

Whenever working on anything for Acme Co, first check the Acme Co Brain notebook in Gemini Notebook before asking me something I’ve likely already answered.

Now every call gets captured automatically, every decision gets logged automatically, and every new chat checks in with all of it automatically. That’s the difference between accidentally re-pitching a client on something they already rejected in March, and not, without it depending on you being the one who remembers.

One accuracy note here: this isn’t the same as saying “Claude now has permanent memory.” Claude still forgets everything at the end of a chat. What persists is the notebook, sitting outside Claude, that Claude and the notetaker both know how to reach. Small distinction, but it’s the honest one.

Here’s the part people miss.

The old way to give Claude context on a big topic was to paste it all in, or have Claude read every file directly. Every one of those tokens counts against your context window and your usage.

The Gemini Notebook pattern is different. Claude sends a small request (create a notebook, add a source, ask a question), Gemini Notebook does the expensive reading and reasoning on Google’s servers, and Claude only spends tokens on the final answer it gets back.

It’s a jab, not a haul. Claude asks a focused question, Gemini Notebook does the heavy lifting elsewhere, and only the useful result comes back into your context.

Here’s what that looks like in practice. Say a client’s 40-page master service agreement is sitting in a notebook. Instead of pasting the whole contract into Claude every time a question comes up, you just ask:

What does the Acme MSA say about the termination notice period?

Claude checks the notebook, gets a cited answer, done. No re-uploading a 40-page PDF to answer a one-line question, and no burning your context window on legal boilerplate you didn’t need this time. That adds up fast across a client roster, both in tokens and in the minutes you’d otherwise spend digging through the actual document yourself.

Not on Claude Code? The same library works with Codex too.

Setup is identical: ask your agent to install the same GitHub link. The main difference is how you trigger it; check the notebooklm-py docs for the exact Codex command syntax, since agent conventions vary and this is the kind of detail worth confirming against the current docs rather than memorizing.

Everything else, creating notebooks, generating content, the Master Brain pattern, works the same regardless of which agent is driving it.

Once this is set up, you’ve got a research assistant that never forgets, backed by citations, that costs you nothing beyond your existing Claude plan.