--- title: "Deep research report writer with follow-up questions" kind: "Kit" category: "Productivity" price: "Free" seller: "Mindket" version: "2" url: "https://mindket.com/p/f754d2f8-5f5d-427e-8922-da8bbc6ab4c2" updated: "2026-11-09" --- # Deep research report writer with follow-up questions > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that researches a technical question on the web and writes a cited report. It asks follow-up questions, searches with Tavily in up to three passes, has OpenAI write each answer, and sends the reports to a converter that makes Google Docs. Deep research report writer with follow-up questions is an n8n workflow in the Productivity category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n. ## About ### What it is This n8n workflow researches a question on the web and writes a cited report. Its prompts are tuned for technical questions, such as which tool fits a set of limits, so they ask for tutorials, code examples and implementation steps. A form takes the question, and an OpenAI model asks up to three follow-up questions, one form page each. Your answers join the question into one brief. gpt-4.1 turns the brief into a search phrase. Tavily returns up to ten pages with their full text, and a model keeps up to five of the most useful. One call reads them and writes an answer with numbered citations. A check then decides whether the question is answered. If not, a second search on a new phrase follows, and a third after that. Markdown reports then go to a converter you supply, which makes the Google Docs. ### Who it suits Developers, tech leads and automation builders who want a cited first answer to a how-do-I or which-tool question, with sources to check. It fits questions that end in something to build, because the page filter favors tutorials and implementation guides. Skip it for news, market sizing or opinion research, whose best sources are not guides. Skip it for quick facts too. A run makes roughly six to thirteen model calls and up to three Tavily searches. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Software development | Developers and tech leads | Ask which library, API or open-source tool meets a set of limits, and read the cited report before choosing | A developer asks for a self-hosted way to turn meeting audio into text and gets sources to compare. | | Automation consulting | Freelancers who build automations | Research what a client asked for before quoting the job | A consultant runs a client’s request through the form and brings the report to the scoping call. | | Product teams | Product managers | Check which ready-made tools exist before the team builds its own | A product manager asks what already covers invoice reminders and what is missing. | | IT and operations | IT managers | Compare ways to meet a rule, such as keeping data on your own servers | An IT manager asks how to run a chat assistant without sending files to a cloud service. | | Training and study | Teachers and self-taught developers | Get a sourced starting point for a new topic | A student asks how n8n loops work and reads the guides the report cites. | ### Where to use it Any n8n that can reach OpenAI, Anthropic, Tavily and a Google Docs converter will run it. The form is the front door. Share its address with whoever has the questions. - n8n Cloud: import the file into a new workflow there, and publish it so the form’s production address works - Your own n8n server: the same file and steps - The form’s address: its path ends in \`deep\_research\`, so a team can bookmark it - Google Docs: each report goes to your converter with its title as the file name - Another place to read reports: replace the three converter nodes with a node that saves where your team works ### How to set it up Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Its author puts setup at about 16 minutes. Have these ready before you import it. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | OpenAI | An API key. Fifteen nodes use it: fourteen chat models and one call to the Responses API | | Anthropic | An API key for four chat models that repair broken JSON, or OpenAI models in their place | | Tavily | An API key, pasted into three HTTP Request nodes | | Google | An account for a Google Docs OAuth2 credential, and a converter address for three nodes | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Add an OpenAI credential. Select it in `OpenAI Chat Model` and `OpenAI Chat Model1` to `OpenAI Chat Model13`, and in `HTTP Request`. 3. Add an Anthropic credential and select it in `Anthropic Chat Model` and `Anthropic Chat Model1` to `Anthropic Chat Model3`. Or swap those four for OpenAI chat models. 4. In `Tavily Search`, `Loop2_Tavily Search1` and `Loop3_Tavily Search2`, replace `` in the Authorization header with your key. The brackets go too. 5. In `HTTP Request1`, `HTTP Request2` and `HTTP Request3`, replace `YOUR_MARKDOWN_TO_DOC_ENDPOINT` with your converter’s address and select a Google Docs OAuth2 credential. 6. Save, run one question through the test address of `Start`, then press Publish. The converter is not in the file. The original copy’s three nodes called one on its author’s own domain, so this copy leaves the address blank. Each node sends two fields and expects a service that builds a Google Doc from them: ```text POST https://YOUR_MARKDOWN_TO_DOC_ENDPOINT output = the report, in Markdown fileName = the report’s title ``` The nodes use your Google Docs credential, so n8n sends that credential’s access token with the request. Point them only at a service you run yourself. Or replace each one with a Google Docs node set to Create, then one set to Update that inserts the Markdown as plain text. ### How to use it Open the form from `Start`, press Next and write your question in `What would you like to research?`. Be specific. Name the tools, the limits and the outcome you want. Then answer each follow-up page. After the last one the form says thank you. You can close it, because the research goes on behind it. Reports arrive in Google Docs through your converter, so check Drive for more than one document. What to change for a different result | To change | Where | | --- | --- | | Pages searched and read | \`max\_results\` and \`search\_depth\` in the three Tavily nodes, and the up to 5 links line in the three relevance prompts | | Follow-up questions | The limit of three in \`Clarifying Questions\` | | When another pass starts | The criteria in \`Evaluate Answer Completeness\` and \`Loop2\_Evaluate Answer Completeness1\` | | Report layout | The section list in the three report generators’ prompts | | Subject area | The examples in \`Prepare GPT-4.1 Input\` and the relevance prompts, which lean toward tutorials and code | ### Example You write this question: ```text Which self-hosted tool can transcribe meeting recordings to text without sending the audio to a cloud service, and how do I call it from n8n? ``` The model might ask what language the meetings use, how long they run and what hardware you have, one page each. After that, pass 1 writes its answer in the parser’s shape, trimmed here: ```json { "question": "…", "search_query": "…", "answer": "… with citations such as [1] and [3] …", "sources": [{ "id": 1, "title": "…", "url": "…" }] } ``` The check replies in a second shape. On no, the new phrase starts pass 2: ```json { "answered": "no", "next_search_query": "…" } ``` ### For newcomers and experts **If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This file has 90 of them, but most are three near copies of the same search-and-read stage, one per pass, so it reads shorter than it looks. A credential is a key n8n stores for you and hands to the node you select it in. Run the form from its test address first. Each node then shows what it received and sent, which is where a wrong key or a blank converter address turns up. **For experts.** Two vendors’ models share the work, and a few nodes exist only to repair JSON. The model behind each step | Step | Model | What to know | | --- | --- | --- | | \`Clarifying Questions\`, the relevance filters, the page filters, the evaluations and the report generators | chatgpt-4o-latest, in 14 chat model nodes | An alias OpenAI moves. Structured parsers hold the replies to a JSON shape | | \`Prepare GPT-4.1 Input\` and \`HTTP Request\` | gpt-4.1 through the Responses API, with its web search tool on | One call writes the first search phrase, and \`store\` is true | | Three page filters and the pass 2 report | claude-3-7-sonnet-20250219, in four chat model nodes | Each sits behind an auto-fixing parser and runs only when the JSON is broken | | The pass 1 and three-pass reports | The same OpenAI model, in two chat model nodes | Their auto-fixing parsers repair through OpenAI instead | `Merge1` and `Merge2` gather the three passes’ answers so that `Merge Deep Research Answers` can hand them to the last report generator. Pass 3 has no check, so no fourth pass follows. ### Good to know A run costs money on three accounts, and it can leave several documents. - Billing: OpenAI and Tavily bill each run, Anthropic only when a repair runs. Tavily is called at \`advanced\` depth with full page text, so check its pricing for that depth - Several documents: passes 1 and 2 each send their answer to a report at once, and a yes from a check sends that pass again. The pass 2 report holds pass 2’s answer only - Failed status: \`Done\` and \`Done1\` are Stop and Error nodes with the message Success, so a finished run shows as failed in Executions - The first phrase: \`Prepare Keywords (Code)\` reads one spot in the reply and falls back to the words \`fallback search query\`, so read the first run’s phrase - Long pages: one call reads up to five full pages, and one long page can pass the model’s input limit - Open form: once the workflow is published, anyone with the form’s address can start a run on your keys, so turn on the form trigger’s authentication or keep the address to yourself - Where data goes: your question and answers go to OpenAI, page text to OpenAI and sometimes Anthropic, search phrases to Tavily, and each report to your converter - Credentials: the JSON holds none, and nothing from its author’s account ## README ```markdown # Deep research report writer with follow-up questions An n8n workflow that researches a technical question on the web and writes a cited report. It asks follow-up questions first, searches with Tavily in up to three passes, and turns each report into a Google Doc through a converter you supply. ## What is inside - `workflow.json`: the workflow as n8n exports it, 90 nodes, no sticky notes. It holds no credential, no key and nothing from its author's account. - Three repairs in the file itself, listed under Good to know: restored backslashes, a placeholder where a converter's address stood, and forms without the author's picture. - `README.md`: these notes. ## Before you start - An n8n instance, on n8n Cloud or your own server. - An OpenAI API key. Fifteen nodes use it: fourteen chat models and one call to the Responses API. - An Anthropic API key for four chat models that repair broken JSON, or OpenAI models in their place (step 3). - A Tavily API key. - A Google account for a Google Docs OAuth2 credential, and a converter that builds a Google Doc from Markdown (step 5). ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. Add an OpenAI credential. Select it in `OpenAI Chat Model` and `OpenAI Chat Model1` to `OpenAI Chat Model13`, and in `HTTP Request`, the call to api.openai.com. 3. Add an Anthropic credential and select it in `Anthropic Chat Model` and `Anthropic Chat Model1` to `Anthropic Chat Model3`. To skip Anthropic, replace those four with OpenAI chat models: `OpenAI Chat Model1` and `OpenAI Chat Model13` already do that job for two of the repair parsers. 4. Open `Tavily Search`, `Loop2_Tavily Search1` and `Loop3_Tavily Search2`. In each Authorization header, replace `` with your key. The brackets go too, so the value reads Bearer, a space, then the key. 5. Open `HTTP Request1`, `HTTP Request2` and `HTTP Request3`. Replace `YOUR_MARKDOWN_TO_DOC_ENDPOINT` in each address with your converter's address, and select a Google Docs OAuth2 credential (below). 6. Check the model names (`chatgpt-4o-latest`, `claude-3-7-sonnet-20250219`, `gpt-4.1`) against what n8n and your accounts offer. 7. Save, open the test address of `Start` (its path is `deep_research`) and run one question through it. Then press Publish. ## The converter it calls The file does not include it. Each of the three nodes sends two form fields and expects a service that answers by making a Google Doc: | Field | What the node sends | |---|---| | `output` | the report in Markdown | | `fileName` | the report's title | The nodes use a Google Docs credential, so n8n adds that credential's access token to the request. Point them at a service you run yourself. Or delete each of the three and put a Google Docs node set to Create there, with the title as the document's name, followed by one set to Update that inserts the Markdown as text. The headings then show as plain text, but no outside service sees your token. ## How a run goes | Stage | Nodes | What happens | |---|---|---| | Question | `Start`, `Research Request` | A welcome page with a Next button, then a page that asks `What would you like to research?` | | Follow-ups | `Clarifying Questions` to `Get Initial Query` | The model asks up to three questions, one form page each, or answers No clarification needed. The question and answers become one text. | | Search phrase | `End Form` to `Prepare Keywords (Code)` | The form says thank you and closes. `gpt-4.1` through the Responses API, with web search switched on, writes one search phrase. | | Pass 1 | `Tavily Search` to `Filter Relevant Content per Page` | Tavily returns up to ten pages with full text. `LLM Relevance Filter` keeps up to five. One call reads them and writes an answer with numbered citations. | | Check | `Evaluate Answer Completeness`, `Check If Query Fully Answered` | Answers yes or no. On no, it also writes a new search phrase. | | Pass 2 | the `Loop2_` nodes | The same stage on the new phrase, with its own check, `Check Loop2 Answered`. | | Pass 3 | the `Loop3_` nodes | The same stage once more. No check follows it. | | Reports | `Prepare Final Report`, `Final Report Generator` and its two copies, `HTTP Request1` to `HTTP Request3` | Each report is Markdown with a title. The nodes post it to the converter. | ## Change the results - Pages searched and read: `max_results` and `search_depth` in the three Tavily nodes (10 and `advanced`), and the `up to 5 links` line in the three relevance prompts. - Follow-up questions: the maximum of three in `Clarifying Questions` and in the description of `Structured Output Parser1`. - When another pass starts: the criteria in `Evaluate Answer Completeness` and `Loop2_Evaluate Answer Completeness1`. - Report layout: the section list in the prompts of `Final Report Generator`, `Final Report Generator1` and `Final Report Generator2`. - Models: the model field of each chat model node, and `model` in `Prepare GPT-4.1 Input`. - The kind of question: the examples and the style in `Prepare GPT-4.1 Input` and the relevance prompts ask for tutorials, code and implementation guides. Rewrite them for other research. ## Good to know - The original copy's Code nodes and expressions had lost their backslashes. Twelve nodes read `join('n')` or `join('nn')` where a line break was meant, and the two `Parse LLM Output to JSON` nodes had the pattern `/{[sS]*}/`. Mindket put the backslashes back: `\n`, `\n\n` and `[\s\S]`. The twelve are `Get Initial Query`, the three relevance filters, the three page filters, the three report generators, `Prepare Final Report` and `Prepare Final Report Input1`. - The original copy posted its reports to a converter on its author's own domain, with your Google token. This copy has a placeholder instead, so no run sends a token anywhere until you choose where. - The forms showed a banner picture from the author's image host, which this copy leaves out. The welcome text on `Start` said reports were saved to Notion. The file saves through Google Docs, so it now says a Google Doc. - Passes 1 and 2 each send their answer to a report as soon as it is written, without waiting for the check. A yes from a check sends that pass to its report a second time. One run can therefore leave several documents. The pass 2 report holds pass 2's answer alone. Only the report from `Final Report Generator2` holds all three. - `Done` and `Done1` are Stop and Error nodes with the message `Success`, so a run that ends there shows as failed in Executions, with that message. - `Prepare Keywords (Code)` reads only the first item of the reply's `output` list. When it finds no search phrase there, it falls back to the words `fallback search query`. If the model runs its own web search first, the message may come second, so read the first run's search phrase. - When the model asks no question, `Get Initial Query` still writes one stray line into the brief: `question: output` and `answer: [object Object]`. - `Filter Relevant Content per Page` and its two copies put up to five full pages into one prompt. One long page can run past the model's input limit and stop that step. - A run makes roughly six to thirteen model calls, depending on how many passes run, plus up to three Tavily searches at `advanced` depth with full page text. OpenAI, Tavily and, for repairs only, Anthropic each bill their part. `chatgpt-4o-latest` is an alias OpenAI moves, and the Responses API call sets `store` to true. - Once the workflow is published, anyone with the form's address can start a run on your keys. The form trigger can ask for a username and password. - The question and your answers go to OpenAI. Page text goes to OpenAI and, when a repair is needed, to Anthropic. Search phrases go to Tavily, and each report goes to your converter. ``` ## What is in it 2 files, 103 KB, downloaded as a zip. ```text README.md 8 KB workflow.json 96 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 56 steps, starting on a form - AI: 12 steps call an AI model: Clarifying Questions, LLM Relevance Filter, Filter Relevant Content per Page, Evaluate Answer Completeness, Final Report Generator and 7 more - Sign-ins: Signs in to: Google Docs, OpenAI, Anthropic and Tavily - API keys: No API key is left in the file; 1 blank in it for your own key - Step types: Mindket’s checker reads all 11 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/f754d2f8-5f5d-427e-8922-da8bbc6ab4c2) - [Its page on Mindket](https://mindket.com/p/f754d2f8-5f5d-427e-8922-da8bbc6ab4c2)