Gemini Notebook (formerly NotebookLM) as Memory for Claude

Every new chat starts the same way. You paste the brief again, re-explain the project, remind the AI which decision you made last Tuesday, and it still guesses at the parts you forgot to mention. Meanwhile, the real answers sit in your Gemini Notebook (formerly NotebookLM) library, cited and organised, in a browser tab your assistant can’t see. This guide turns that library into long-term memory that Claude, ChatGPT or a coding agent consults on its own, so it answers from your sources instead of from vibes.

Key Takeaways

• 83 of 776 Kortex MCP waitlist respondents asked to use notebooks as memory for their AI (Kortex MCP waitlist survey, Sep-Oct 2026).
• Map the library once with semantic_library_metadata, then recall with search_everything, ask_question and ask_library.
• Write back decisions with save_chat_to_note, add_text_source and save_kortex_note.
• Kortex MCP is a Kortex Pro feature in private beta, for invited members only.

Why does Claude keep forgetting your work?

Because chat memory was built to remember you, not your library. “Each Claude Code session begins with a fresh context window,” Anthropic’s docs say, and what carries over is a short instruction file plus notes (Claude Code docs, 2026). Similarly, Claude’s chat memory stores your role, projects and preferences as individual topics (Claude Help Center, 2026). That’s useful; however, it won’t hold a 40-page spec. Can’t you just paste everything in? Not well. Anthropic’s engineering team puts it bluntly: “As the number of tokens in the context window increases, the model’s ability to accurately recall information from that context decreases” (Anthropic, 2025). The instruction files are short by design, too. For example, Claude Code suggests keeping each CLAUDE.md under 200 lines, and Codex stops reading AGENTS.md files at 32 KiB by default (OpenAI Codex docs, 2026).

People feel this. When we analyzed what the 776 people on the Kortex MCP waitlist wanted their assistant to do in their notebooks, we found 83 asking for notebooks that work as memory or a knowledge base for their AI. Across the whole list, in addition, 67 people named a coding or agent tool such as Codex, Claude Code or Antigravity (Kortex MCP waitlist survey, 776 respondents, Sep-Oct 2026). In other words, their agents write code against docs the agent can’t see. Notably, Claude came first among the assistants they named, named by 126 respondents, ahead of ChatGPT at 69. Codex (23) and Claude Code (15) led the coding agents.

So split memory in two. Preference memory is who you are and how you like things done. Built-in memory, CLAUDE.md and custom instructions handle it fine. Source memory is different: it’s what you know, such as specs, research, meeting notes and decisions. Consequently, it belongs somewhere built to hold hundreds of documents and cite them, fetched only when a question needs it.

Why can’t Gemini Notebook be your AI’s knowledge base on its own?

It has the right shape for memory, but your assistant can’t get in. The shape first: Gemini Notebook answers from your sources and shows its work. In a 2025 study on a 300-document corpus, NotebookLM hallucinated in 13% of outputs, against about 40% for ChatGPT and Gemini chat (Hagar, Agustianto & Diakopoulos, 2025). A free notebook holds 50 sources, and Google AI Pro raises that to 300 (Gemini Notebook Help, 2026). Each source can run to 500,000 words (Gemini Notebook Help, 2026). That’s what a knowledge base for AI needs: lots of room, answers tied to passages, and a refusal to invent things it can’t find. Anthropic recommends the same pattern for agents. Specifically, keep “lightweight identifiers” in context and load the real data “just in time” with tools (Anthropic, 2025). A notebook ID in your instructions is exactly that kind of identifier.

The catch is reach. Google publishes no public consumer API for Gemini Notebook, so Claude, ChatGPT and Codex can’t open your notebooks by themselves. As a result, you become the go-between: ask the notebook, copy the answer, paste it into the chat, and do it all again next session. In our waitlist survey we found 244 of 776 people (31%) describing a manual copy-paste workaround they use today.

Kortex MCP is the bridge we built to take you out of that loop. Your AI client calls the Kortex server, which relays the call to the Kortex extension in your own Chrome. The extension then asks Gemini Notebook with the Google session you’re already signed into, and Kortex never stores your Google password or cookies. For the bigger picture, read our Gemini Notebook MCP overview. Meanwhile, you can start on the notebook side today, for free.

What do you need before you start?

Three things: a Kortex Pro plan, an invite to the Kortex MCP private beta, and Chrome open with the Kortex extension signed in. Pro costs $9.99 a month, or $4.92 a month billed yearly (Kortex pricing, 2026). Once you’re in, connecting takes a minute. In Claude Code it’s one command:

claude mcp add --transport http kortex https://mcp.kortex-notebooklm.com/mcp

Other clients either sign in with OAuth or send an API key as Authorization: Bearer kx_mcp_.... The client setup docs cover Claude Desktop and claude.ai, ChatGPT, Cursor, VS Code, Antigravity, Windsurf, Cline, Codex CLI and Zed.

One choice matters for memory: the key profile. New keys default to Read-only, which can search and ask but can’t write (API key docs, 2026). However, mapping your library and saving things back are writes, so give the assistant a Standard key, which creates and edits but never deletes. Expect a pause on the first call after Chrome has been idle, too: up to 30 seconds while the extension wakes.

How do you turn Gemini Notebook into long-term AI memory?

Map the library, find the right notebook, ask it with citations, then write back what you decide. Steps 2 and 3 only read. Steps 1 and 4 write, hence the Standard key.

Step 1: Map your library so the AI knows what’s where

semantic_library_metadata builds a searchable description of every notebook, and that map is what your assistant reads before it picks one. With discover, it asks a notebook for a description, topics, use cases and tags. With upsert, you save corrections. In contrast, get, list, search and stats only read the stored index, and no Kortex credits are charged (Kortex tools docs, 2026).

Why bother, when the assistant could read notebook titles? Because titles lie. “Q3 stuff” tells an AI nothing, and “Project Atlas” could be a client, a codebase or a holiday. A one-line description with topics, however, turns a vague question like “what did we decide about refunds?” into a confident pick.

Map my Gemini Notebook library. List my notebooks, then run semantic_library_metadata with action "discover" on each one, starting with the 15 newest if there are more. Show me a table with notebook, one-line description, topics and tags. I'll correct anything wrong, and you save my fixes with action "upsert". Then set "Work wiki" as my default notebook.

Two tips. First, discover asks each notebook a question, so it draws on your Google allowance; map in batches, and see our guide to Gemini Notebook usage limits for how the five-hour refresh works. Second, correct the descriptions. The AI reads that map before every pick, so one wrong line sends questions to the wrong notebook for months. If your library is a flat list of 80 untitled notebooks, tidy it first with our guide to organizing Gemini Notebooks.

Step 2: Find the right notebook with search_everything

search_everything searches the whole library in one read-only call: notebooks, sources, notes, artifacts, collections, tags and podcasts (Kortex tools docs, 2026). The map answers “which notebook is about this?” Search, in other words, answers “where does this exact phrase appear?” Use both, in that order. The map handles meaning, while search catches what a description would never mention, for example a customer name or an error code.

Which of my notebooks covers the Q3 pricing change? Check the library map first. If it isn't clear, search_everything for "annual plan". Tell me which notebook you picked and why before you ask it anything.

Keep that last sentence. A wrong pick then costs you two seconds, not a confidently wrong answer.

Step 3: Ask with citations, not guesses

Recall happens in two tools. ask_question asks one notebook and returns the answer, its citations and a session_id, so follow-ups keep their context. ask_library asks the same question across up to three notebooks and returns each answer with its own citations (Kortex tools docs, 2026). As a result, your assistant can point out where they disagree. For memory, the habit that matters is “check before you answer.” The assistant asks a notebook first and falls back to its own knowledge only when the notebook comes up empty, saying so when it does.

Before you answer: ask the best-matching notebook what we decided about refunds on annual plans and why, with inline citations. If two notebooks look relevant, use ask_library on both and tell me where they disagree. If neither covers it, say "not in my notebooks" before you add anything of your own.

Our guide to getting cited answers in Claude and ChatGPT covers sessions, panels and citation formats in detail.

Step 4: Write back what the AI learns

Memory that only reads goes stale. Kortex gives your assistant three ways to write back, and each lands somewhere different (Kortex tools docs, 2026):

What you want to keep	Tool	Where it goes	Good for
A cited answer from this chat	save_chat_to_note	A native note in that notebook, with a citation appendix	Answers you’ll reread or share
A decision the notebook should answer from later	add_text_source	A new text source in the notebook	Decision logs, meeting outcomes, specs drafted in chat
The assistant’s working notes	save_kortex_note	A Kortex note on the notebook, outside Gemini Notebook	Open questions, to-dos, a running summary

The middle row is the real memory. Gemini Notebook answers from sources, so a decision saved with add_text_source is something a future question can find and cite. Want a saved note to count the same way? convert_note_to_source copies its text into the notebook as a source. The bottom row, by comparison, is the scratchpad. Kortex notes live in Kortex, so Gemini Notebook never sees them and they won’t show up as citations. Pass an existing note_id and save_kortex_note replaces the note’s content, so one running note stays one note.

Before we wrap up: save the refund answer from that notebook session with save_chat_to_note, titled "Refund rule, checked 2026-10-01". Then add a text source to "Design decisions" called "Decision 2026-10-01: refunds on annual plans", with the decision, the reason and the citation it rests on. Show me both before you save.

One rule keeps this honest. A source the AI wrote is only as good as the answer behind it, and next month it will get cited like any other source. Therefore, keep the original citation inside every decision you save, put a date in the title, and use one source per decision rather than one per chat. A free notebook caps at 50 sources, so a source per chat fills it fast.

What should you paste into Claude or ChatGPT to make it automatic?

Paste a short memory routine into your assistant’s standing instructions, and “check the notebooks first, save what matters” happens without you asking. In Claude, paste it into a project’s instructions, which Anthropic describes as a way to “further tailor Claude’s responses” (Claude Help Center, 2026). In ChatGPT, paste it into custom instructions, which apply to all chats (OpenAI Help Center, 2026).

Memory routine (Gemini Notebook via Kortex):
1. Before answering anything about my work, projects, clients or docs, check my notebooks. Use semantic_library_metadata (action "search") or search_everything to pick the notebook, and tell me which one you picked.
2. Ask it with ask_question, or ask_library for up to 3 notebooks. Answer from what comes back and keep the citations.
3. If the notebooks don't cover it, say "not in my notebooks" before using your own knowledge.
4. Don't ask me to re-explain anything a notebook already holds.
5. When we settle something worth keeping, offer to save it: save_chat_to_note for a cited answer, add_text_source for a decision titled "Decision YYYY-MM-DD: topic". Show me the text first.
6. Never delete or rename anything in my library.

It’s under 900 characters, so it fits comfortably in either box. That said, it has two limits. The routine only works in chats where Kortex is connected. In addition, each Claude project keeps its own separate memory space (Claude Help Center, 2026), so put the routine in the project where this work lives.

Here’s what the routine buys you. A week from now, you open a new chat in that project. You ask whether a customer on an annual plan can get a refund after 60 days, and you don’t mention notebooks. The routine does. The assistant picks “Design decisions” from the map and asks it, and the answer cites “Decision 2026-10-01: refunds on annual plans”, the source you saved in Step 4. You re-explained nothing, and that moment is one invite away.

How do you use notebook memory from Claude Code, Codex or Cursor?

Point the agent at your notebooks from its instruction file, then let it ask on demand. Builders are a real slice of the demand: 67 of the 776 waitlist respondents named a coding or agent tool. It also matters most for code. In fact, 66% of developers name “AI solutions that are almost right, but not quite” as their biggest frustration, and 46% distrust AI accuracy (Stack Overflow Developer Survey, 2025). Thus, an agent that checks the spec before it codes guesses a lot less. Each agent has a file it reads at the start of every session. Claude Code reads CLAUDE.md, and can also read AGENTS.md (Claude Code docs, 2026). Codex reads AGENTS.md “before doing any work” (OpenAI Codex docs, 2026). Cursor, meanwhile, keeps project rules in .cursor/rules (Cursor docs, 2026). Don’t paste specs into these files. Instead, add a few lines that say where the specs live:

## Docs and specs (Gemini Notebook via Kortex MCP)
- Specs, API docs and past decisions live in Gemini Notebook, not in this repo.
- "Billing API spec" notebook id: <notebook-id>
- "Design decisions" notebook id: <notebook-id>
- Before changing billing code, ask the spec notebook with ask_question and follow its cited answer. Quote the citation in the PR description.
- If the notebook and the code disagree, stop and tell me. Don't pick one.
- After we agree on a decision, add it to "Design decisions" with add_text_source, titled "Decision YYYY-MM-DD: topic".

Those IDs are the lightweight identifiers Anthropic describes: a few lines of context that point to hundreds of documents. Then, in the session:

Before you write any code: ask my "Billing API spec" notebook how refunds on annual plans are calculated, with inline citations. Summarise the rule in three bullets with the citations, then plan the change. If the spec doesn't cover partial refunds, say so and stop.

Specs change, and a stale spec is worse than none. If the spec is a Google Doc, add_google_doc links it as a live source, and sync_google_docs asks Gemini Notebook to re-read it after edits (Kortex tools docs, 2026). Alternatively, for a chain you repeat, such as sync, ask, then save, Kortex can keep it as a saved workflow, and every step is checked against your key’s profile before anything runs. As for connection config, Codex CLI uses ~/.codex/config.toml and Cursor uses .cursor/mcp.json; both are copy-paste in the client setup docs. Importantly, treat the API key like a password and keep it out of the repo.

What should stay out of notebook memory?

Three things, mostly: secrets, untrusted imports and the delete button (Kortex MCP security docs, 2026).

• Secrets. Kortex’s docs warn never to commit a key, paste it into a shared document or send it in chat. Likewise, passwords and tokens don’t belong there, even saved as a “fact.” A notebook is a knowledge base, not a vault.
• Untrusted imports. A web page can hide text written to instruct your assistant, which is called prompt injection. The docs call a read-only key “the cheapest defence against it.” Once your assistant reads notebooks on its own, a poisoned source becomes a poisoned memory, so keep web clippings apart from the notebooks your coding agent trusts.
• The delete button. Deleting is a Full-profile job in Kortex, and a Standard key never deletes. Memory tidying, like merging duplicate decisions, is better done by you, with the assistant drafting the list.

Which notebook should you start with?

The one you re-explain most often, usually a spec or a client brief. You don’t need to wire up the whole library on day one. Run Steps 1 to 4 on that notebook, then paste the memory routine into that Claude project or your ChatGPT custom instructions. After a week, check what got saved and fix the map. Once that works, put it on a timer: Kortex schedules can ask a notebook and save the answer hourly, daily or weekly while Chrome is open, and our guide to a daily briefing from your notebooks sets one up. The short version: built-in memory keeps who you are, your notebooks keep what you know, and Kortex MCP lets your assistant read and write the second one with citations.

Frequently asked questions

Can Claude use NotebookLM as memory?

Yes, through Kortex MCP. Claude can search your Gemini Notebook (formerly NotebookLM) library, ask the right notebook, get answers back with citations, and save what it learns as notes or sources. Kortex MCP is a Kortex Pro feature in private beta, and invites go out from the waitlist. Chrome has to stay open with the extension signed in.

Does NotebookLM have memory?

Inside a notebook, yes. Google said in October 2025 that Gemini Notebook (formerly NotebookLM) saves chats automatically, so you can close a session and resume it later, and that it raised multiturn capacity more than sixfold. However, Claude and ChatGPT can’t see that history. To let them ask your notebooks, you need a bridge such as Kortex MCP, a private beta for invited Kortex Pro members.

How is this different from Claude’s or ChatGPT’s built-in memory?

Built-in memory remembers you: your role, projects and preferences, saved as short topics. A notebook, in contrast, remembers your sources, up to 50 per notebook on the free plan and 300 on Google AI Pro, at up to 500,000 words each, and its answers cite the passage they used. Use built-in memory for who you are and notebooks for what you know.

Will the AI write into my notebooks without asking?

Only if you let it. New Kortex API keys default to Read-only, which can search and ask but can’t create, change or delete anything. Writing back needs a key that allows writes, such as Standard, which never deletes. In addition, the memory routine in this guide tells your assistant to show you every save before it happens.

Does this work in Claude Code, Codex and Cursor?

Yes. Kortex MCP has documented setup for Claude Code, Codex CLI, Cursor, VS Code, Antigravity, Windsurf, Cline and Zed, plus Claude Desktop, claude.ai and ChatGPT. Claude Code takes one command. Then add a short block to CLAUDE.md or AGENTS.md that names your spec notebooks, and the agent asks them before it writes code.

Does asking notebooks count against my Gemini Notebook limits?

Yes. Kortex runs every question through your own Google account, so Google’s usage limits apply. Since September 2, 2026 they refresh every five hours until you hit a weekly cap. Because ask_library asks up to three notebooks separately, ask a single notebook whenever you already know which one holds the answer.

---

Editorial note: fact-checked against the official help pages and docs linked above on October 1, 2026. Spotted something out of date? Contact us and we will fix it, or read more about Kortex.