--- title: "Study notes from files dropped in a folder" kind: "Kit" category: "Education" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/b1eeebd9-e69a-4db8-aae3-1d8eda970b68" updated: "2026-11-12" --- # Study notes from files dropped in a folder > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that watches a folder and writes study notes for each new file. It stores the file in Qdrant, asks Mistral questions about it, and saves a study guide, a timeline and a briefing as Markdown files. Study notes from files dropped in a folder is an n8n workflow in the Education category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. 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 turns files dropped in a folder into study notes. It watches the folder, reads each new PDF or text file and stores its text in Qdrant. A Mistral model summarizes the file and writes questions about it, then answers them from Qdrant. From those answers it writes three Markdown documents, a study guide, a timeline and a briefing. Thirty-three nodes do the work, plus seven sticky notes. ### Who it suits Students, teachers and researchers who run their own n8n server and want notes from long readings. It is made for people who already use n8n and are happy to run a Qdrant server. Skip it on n8n Cloud, since the folder trigger is not there. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Education | Students | Turn a reading into a study guide | A student drops in a chapter as a PDF and gets a guide, a timeline and a briefing. | | Research | Analysts | Brief a long report | An analyst drops in a report and reads the briefing first. | | Training | Course authors | Make revision notes for a lesson | An author drops in lesson notes and gets a guide with questions and a glossary. | | Journalism | Reporters | Put the events of a source in order | A reporter drops in a transcript and gets a timeline with the people involved. | You need a self-hosted n8n, a Qdrant server and a Mistral key, and some comfort with a Docker folder. ### Where to use it Only a self-hosted n8n runs it, since n8n Cloud has no Local File Trigger. The server needs a folder that n8n can read and write, and it must reach Mistral and Qdrant. - Your own n8n server: turn on the trigger, mount a folder and import the file - Another kind of note: add an entry to the template list in \`Get Doc Types\` - Another watched folder: change the path in \`Local File Trigger\` - Another model: change the model field of the chat and embeddings nodes ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Setup is two server settings, two folders, two credentials and a first test file. What you need first | Need | Detail | | --- | --- | | n8n | A self-hosted server with the Local File Trigger turned on | | Folder | \`/home/node/storynotes\`, with \`context\` and \`notes\` inside it | | Qdrant | A server, its address and its API key if it needs one | | Mistral | An API key | 1. Set `NODES_EXCLUDE` to `[]` and `N8N_RESTRICT_FILE_ACCESS_TO` to `/home/node/storynotes`, then restart n8n. 2. Mount a folder at `/home/node/storynotes` and make two folders in it, `context` and `notes`. 3. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 4. Add a Qdrant credential and select it in `Qdrant Vector Store` and `Qdrant Vector Store1`. 5. Add a Mistral Cloud credential and select it in the four chat models and in the two embeddings nodes. 6. Publish the workflow and copy a short PDF into `context`. 7. When the run ends, look in `notes` for three Markdown files. ### How to use it Copy a PDF or a text file into the `context` folder and wait for the run to end. Three Markdown files appear in `notes`, one for each template. Word files are not read, so save them as PDF first. What to change for a different result | To change | Where | | --- | --- | | Which notes are written | The list in \`Get Doc Types\` | | How a document is written | The instruction in \`Generate\` | | Where the notes go | The file name in \`Export to Folder\` | | The models | The model field of each chat and embeddings node | ### Example You copy a PDF of a history chapter into the folder. Three files appear in `notes`. They are a study guide with a quiz and a glossary, a timeline with a cast of people, and a briefing outline. Check them against the chapter, since a model wrote them. ### 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. Qdrant is a vector store, a database that keeps text as lists of numbers so it can find passages by meaning. The workflow asks a model for questions, finds the answers in the stored text and writes a document from them. **For experts.** `Local File Trigger` feeds `Settings` and `Import File`, then `Get FileType` picks the PDF reader or the text reader. `Qdrant Vector Store` and `Summarization Chain` run side by side, and `Merge` waits for both. `For Each Doc Type...` loops over three templates. In each pass, `Interview` writes the questions, `Answer from Qdrant` answers them through a retriever on Qdrant, `Aggregate` joins the answers and `Generate` writes the document. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Local File Trigger\` | Fires on each new file in the folder | Self-hosted only, and off by default from n8n 2.0 | | \`Get FileType\` | Sends a PDF to the PDF reader and the rest to the text reader | A Word file takes the text path and comes out as noise | | \`Qdrant Vector Store\` | Stores the file’s pieces with the project and file name | Every file goes into one collection, \`storynotes\` | | \`Interview\` | Asks the model for questions about the summary | It returns one item per question | | \`Answer from Qdrant\` | Answers each question from the four closest pieces | It searches the whole collection, not one file | | \`Export to Folder\` | Writes each document as a Markdown file | Mindket’s copy writes into \`notes\`, not the watched folder | ### Good to know The original copy wrote its notes back into the watched folder, and several of its steps would have failed on current n8n. - Self-hosted only: n8n’s docs say the trigger is not on n8n Cloud, and from n8n 2.0 it stays off until \`NODES\_EXCLUDE\` is changed. Turn it on only where you trust everyone who can edit workflows - Endless loop: the original copy wrote the notes into the watched folder, so each note started a new run. Mindket’s copy writes them to \`notes\` - Word files: n8n’s Extract From File node has no Word operation, and the original copy’s Word branch was never reached. Save a Word file as PDF first - Text files and export: the original copy wrote the text of a text file to a field the next step did not read, and \`To Binary\` named its source field wrongly. Both are fixed - Questions: current n8n returns one item per question from \`Interview\`, so Mindket’s copy drops the Split Out step after it - Models: Mistral’s models page, read on 12 November 2026, lists \`open-mixtral-8x7b\` as retired on 30 March 2025, with Mistral Small 4 as the alternative. Mindket’s copy uses \`mistral-small-latest\` and \`mistral-embed\`. No node here uses tools - One collection: every file goes into the same Qdrant collection, so questions about one file can pull in pieces of another. A search filter on the file name would keep them apart - Cost: each file means about 21 model calls for the three documents, plus the summary calls and one embedding call for each piece - Your data: the text of every file goes to Mistral and to Qdrant - Not run: nothing here was run against Mistral or Qdrant, and no file was watched. The notes come from n8n’s source and the vendors’ pages - Credentials: the JSON holds none ## README ```markdown # Study notes from files dropped in a folder An n8n workflow that watches a folder and writes study notes for every new file. Drop in a PDF or a text file. The workflow stores it in Qdrant, asks Mistral questions about it and writes three Markdown documents: a study guide, a timeline and a briefing. ## What is inside - `workflow.json`: the workflow as n8n exports it, 40 nodes, seven of them sticky notes. It holds no credential. Five notes are coloured frames, one holds the try-it summary, and one is a small hint about adding templates. - `README.md`: these notes. ## What we changed from the original copy - The Mistral and Qdrant nodes were linked to credentials in their author's n8n. The links are gone, so select your own. - All four chat models were `open-mixtral-8x7b`, which Mistral retired on 30 March 2025, or had no model and used n8n's old default, `mistral-small`. They are now set to `mistral-small-latest`. Both embeddings nodes are set to `mistral-embed`, which they used before without saying so. - The notes were written into the watched folder. Each new note then started the workflow again, and every run wrote more notes. They now go to a folder named `notes` beside the watched one, and the sticky note about the export says so. - The Local File Trigger now waits until a file has finished copying before it starts. - `To Binary` named its source field with an expression that returned the whole text, so it looked for a field with that text as its name and failed. It now names the field `data`. - Text and Markdown files were read into a field called `data`, but the next step reads `text`. `Extract from TEXT` now writes `text`, as the PDF step does. - The Word branch is gone. A file type of `docx` never occurs, so the branch was never reached, and its node was set to the OpenDocument spreadsheet operation. Any file that is not a PDF goes down the text path. - `Interview` returned one item per question, but a `Split Out` step after it looked for a list field and found none. The step is gone, and `Answer from Qdrant` reads each question from the `text` field. - The Qdrant collection is chosen by name, so it need not exist yet. `2secs` is renamed `Pause two seconds` and its amount is set to two seconds. Before, it used n8n's default. - Nothing else. ## Before you start - A self-hosted n8n. The Local File Trigger does not exist on n8n Cloud. - Access to a folder that n8n can read and write. In Docker, mount a host folder at `/home/node/storynotes`. - A Qdrant server, and its address and API key if it needs one. - A Mistral API key. ## Set it up 1. Turn on the Local File Trigger. n8n 2.0 and later leave it off. Set the environment variable `NODES_EXCLUDE` to `[]` and restart n8n. 2. Allow n8n to use the folder. Set `N8N_RESTRICT_FILE_ACCESS_TO` to `/home/node/storynotes`, since n8n 2.0 limits file access to one folder otherwise. Create two folders inside it, `context` and `notes`. 3. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 4. Add a Qdrant credential with your server's address and key. Select it in `Qdrant Vector Store` and `Qdrant Vector Store1`. 5. Add a Mistral Cloud credential. Select it in the four chat models, `Mistral Cloud Chat Model` through `Mistral Cloud Chat Model3`, and in `Embeddings Mistral Cloud` and `Embeddings Mistral Cloud1`. 6. Publish the workflow. Copy a PDF or a text file into the `context` folder. 7. Wait a few minutes, then look in the `notes` folder for three files, one for each template. ## How a run goes 1. `Local File Trigger` fires when a new file appears in `/home/node/storynotes/context`. `Settings` takes the project name from the fourth part of the path, `storynotes`, and keeps the path and the file name. 2. `Import File` reads the file and `Get FileType` sends a PDF to `Extract from PDF` and everything else to `Extract from TEXT`. `Prep Incoming Doc` puts the text in a field called `data`. 3. Two things then happen at once. `Qdrant Vector Store` stores the text, cut into pieces of 2,000 characters by `Recursive Character Text Splitter` and embedded by `Embeddings Mistral Cloud`, with the project and file name as metadata. `Summarization Chain` writes a summary in chunks of 4,000 characters. 4. `Merge` waits for both. `Prep For AI` gathers the summary, the project and the file name, and `Get Doc Types` lists three templates: a study guide, a timeline and a briefing doc. `Split Out Doc Types` makes one item per template. 5. `For Each Doc Type...` takes one template at a time. `Interview` reads the summary and writes questions that the template would need answered. 6. `Answer from Qdrant` answers each question. `Vector Store Retriever` fetches the closest four pieces, using `Qdrant Vector Store1` and `Embeddings Mistral Cloud1`. `Aggregate` collects the answers. 7. `Generate` writes the document from the template's description and the answers. `Pause two seconds` waits and the loop moves to the next template. 8. When all three are done, `Get Generated Documents`, `To Binary` and `Export to Folder` write each one as a Markdown file in `/home/node/storynotes/notes`. The name is the first 21 characters of the source file name, three dots and the template title. ## Change the look - Which templates are written: the list in `Get Doc Types`. Add an entry with a file name, a title and a description. - How many questions are asked: the wording in `Interview`. - Where the notes go: the file name in `Export to Folder`. - How a document is written: the instruction in `Generate`. - The models: the model field of each chat node, and of the two embeddings nodes. Both embeddings nodes must use the same model. - How big a stored piece is: the chunk size in `Recursive Character Text Splitter`. ## Good to know - Self-hosted only: n8n's docs say the Local File Trigger is not on n8n Cloud, and from n8n 2.0 it is off until you change `NODES_EXCLUDE`. Anyone who can edit workflows on your n8n can then watch folders on the machine, so enable it only where you trust them. - Word files: the workflow reads PDFs and plain text. n8n's Extract From File node has no Word operation, so a `.docx` takes the text path and comes out as noise. Save it as PDF first. - Models: Mistral's models page, read on 12 November 2026, lists `open-mixtral-8x7b` as retired on 30 March 2025, with Mistral Small 4 as the alternative. The card for Mistral Small 4 names `mistral-small-latest` as one of its names. The chains here use no tools. - One collection: every file goes into the same Qdrant collection, `storynotes`, and `Answer from Qdrant` searches all of it. Questions about one file can pull in pieces of another. The metadata holds the file name, so a search filter on it would keep them apart. - Cost: each file means about 21 model calls for the three documents, plus the summary calls and one embedding call for each piece. - Your data: the text of every file goes to Mistral and to Qdrant. - Not run: nothing here was run against Mistral or Qdrant, and no file was watched. The edits come from n8n's source and the vendors' pages, read on 12 November 2026. Run one short file first and read the notes before you trust it. ``` ## What is in it 3 files, 37 KB, downloaded as a zip. ```text NOTICE.md 696 B README.md 7 KB workflow.json 30 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 22 steps, starting on its trigger node - AI: 5 steps call an AI model: Summarization Chain, Interview, Answer from Qdrant, Generate and Qdrant Vector Store - Sign-ins: Signs in to: Qdrant and Mistral - API keys: No API key is left in the file - Step types: Mindket’s checker reads 14 of its 15 step types. It does not read: Local File Trigger ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/b1eeebd9-e69a-4db8-aae3-1d8eda970b68) - [Its page on Mindket](https://mindket.com/p/b1eeebd9-e69a-4db8-aae3-1d8eda970b68)