--- title: "Voice RAG chatbot for an ElevenLabs agent" kind: "Kit" category: "Business" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/213f8441-3a7d-432b-b481-e1ececa8c144" updated: "2026-11-12" --- # Voice RAG chatbot for an ElevenLabs agent > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that loads a Google Drive folder into Qdrant and answers an ElevenLabs voice agent’s questions from it. An OpenAI agent searches the stored chunks and sends back text for the agent to speak. Voice RAG chatbot for an ElevenLabs agent is an n8n workflow in the Business 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 lets a voice agent answer from your own documents. One part reads the files in a Google Drive folder, cuts them into chunks and stores them in a Qdrant collection. The other part is a webhook. An ElevenLabs agent posts the caller’s question to it, and an OpenAI agent looks up the closest chunks in Qdrant and writes the answer. The reply goes back as JSON, and ElevenLabs speaks it. Eighteen nodes do the work, beside five sticky notes. ### Who it suits Businesses that want a voice assistant to answer from their own price lists, menus or policies, and the developers who set it up for them. Skip it if answers must never go beyond the documents, since the agent has no instruction to stay inside them. Skip it too for a big library, because the folder step reads only 50 files. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Hospitality | Restaurants and hotels | Load the menu, the opening hours and the house rules, and let a voice agent answer callers | A café loads its allergen list, and a caller asks whether the carrot cake has nuts. | | Customer support | Small support teams | Put the help articles in one folder and let the agent answer the common questions | A shop loads its returns policy, and the agent explains it to a caller in plain words. | | Education | School offices | Load term dates and school rules for parents who phone in | A parent asks when the holiday starts, and the agent reads the date from the calendar file. | | Property management | Building managers | Let tenants ask about house rules without waiting for an office | A tenant asks about parking, and the agent answers from the house rules. | You need some n8n and several accounts: four credentials in n8n, a Qdrant database and an agent on the ElevenLabs side. ### Where to use it Any n8n with a public address that ElevenLabs can reach, plus a Qdrant database that your n8n can call. - n8n Cloud: import the file there and use the production address of its webhook - Your own n8n server: the same file, with the server open to the internet - Qdrant: a cloud cluster or your own server, as long as n8n can call it - A website: the widget snippet in the last sticky note puts the agent on a page ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Have the accounts ready, because the load step uses Google, Qdrant and OpenAI together. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own, with a public address | | OpenAI | An API key, for the two chat models and the embeddings | | Qdrant | The address of an instance and its API key | | Google Drive | A folder with your documents and an OAuth2 credential | | ElevenLabs | An account with an agent that can call a webhook tool | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Add an OpenAI credential and select it in `OpenAI`, `OpenAI Chat Model`, `Embeddings OpenAI` and `Embeddings OpenAI1`. 3. Add a Qdrant credential and select it in `Qdrant Vector Store` and `Qdrant Vector Store1`. 4. Add an HTTP Header Auth credential with the header name `api-key` and your Qdrant key, and select it in `Create collection` and `Refresh collection`. 5. In all four Qdrant nodes replace `YOUR_COLLECTION` with your collection’s name. In the two HTTP requests also replace `YOUR_QDRANT_URL` with your Qdrant host. 6. Add a Google Drive OAuth2 credential, select it in `Get folder` and `Download Files`, and replace `YOUR_FOLDER_ID` in `Get folder` with your folder’s ID. 7. Press Test workflow once. The collection is made, emptied and filled, so check in Qdrant that it holds points. 8. Save, press Publish and copy the production address of `Listen`. In ElevenLabs, add a Webhook tool to your agent with the method POST, that address and one body parameter named `question`. 9. Test the agent in ElevenLabs. ### How to use it Talk to your ElevenLabs agent. When it needs a fact, it calls the tool and posts the question in a field named `question`. The workflow answers with a field named `output`, and the agent speaks it. Press Test workflow again whenever the documents change, because the load only runs from that button. What to change for a different result | To change | Where | | --- | --- | | The documents | The folder in \`Get folder\` | | The chunk size | 300 and 30 in \`Token Splitter\` | | The chunks per answer | The Limit of \`Vector Store Tool\`, 4 by default | | When the agent searches | The name and description of \`Vector Store Tool\` | | The answering models | \`OpenAI\` and \`OpenAI Chat Model\` | | The conversation | The session key \`voice-rag-chat\` in \`Window Buffer Memory\` | ### Example A café puts its menu, its opening hours and an allergen list in the Drive folder and presses Test workflow. A caller asks the voice agent whether the carrot cake has nuts. The agent posts the question and the OpenAI agent finds the allergen chunk in Qdrant. It writes the answer, and ElevenLabs speaks it. Check the first answers against the documents, because nothing tells the agent to stay inside 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. This one has two lines of work. The first reads files and stores them in Qdrant, a database that finds text by meaning. The second waits for a question and searches that database. Load one short document first and ask about it. **For experts.** The agent calls a Vector Store Tool that wraps Qdrant retrieval and a second chat model, and Window Buffer Memory uses one fixed key. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Create collection\` | Sends a PUT that makes a collection with 1536 dimensions and cosine distance | Its On Error setting is Continue, so an existing collection does not stop a later run | | \`Refresh collection\` | Posts a delete with an empty filter | It is meant to remove every point before a reload | | \`Get folder\` | Lists the files directly in your folder | It returns up to 50 files and skips subfolders | | \`Vector Store Tool\` | Named \`company\`, with a description written in Italian | The description decides when the agent searches, so rewrite it in your language | | \`Window Buffer Memory\` | Keeps five exchanges under a fixed key | Every caller shares one conversation | ### Good to know Four services can bill a run, and the load step wipes the collection first. One model default needs a look. - Models: the two OpenAI chat nodes set no model, so n8n fills in \`gpt-5-mini\`. OpenAI’s deprecations page, read on 12 November 2026, lists it for shutdown on 11 December 2026, with \`gpt-5.6-terra\` as the replacement. Choose another model in both nodes before then. The embedding default, \`text-embedding-3-small\`, is not listed there - Collection: the original copy sent a POST with a points filter to make the collection. Mindket’s copy sends the PUT that Qdrant uses, with 1536 dimensions to match \`text-embedding-3-small\`. Another embedding model needs its own size and a new collection - Reload: every press of Test workflow empties the collection and embeds every file again, and OpenAI bills the embeddings each time. A caller who asks in between gets no help from the documents - Delete filter: Qdrant’s API page does not say what an empty filter in a delete matches, so check the point count after a load - Folder: only files directly in the folder are read, up to 50 - Memory: the original copy set no session, so the agent would stop with “No session ID found”. Mindket’s copy uses the fixed key \`voice-rag-chat\`, so every caller shares one conversation. n8n drops it after an hour without use - Open webhook: anyone with the address can ask questions on your OpenAI key, so turn on the webhook’s authentication and send the same header from the ElevenLabs tool - Widget: ElevenLabs shows it only for a public agent with authentication off - Billing: OpenAI bills at least one agent call for each question, plus a second model call and an embedding when the agent searches - Your data: the documents go to OpenAI to be embedded and are stored in Qdrant, and each question goes to OpenAI - Credentials: the JSON holds none ## README ```markdown # Voice RAG chatbot for an ElevenLabs agent An n8n workflow that answers a voice agent's questions from your own documents. One part loads the files of a Google Drive folder into a Qdrant collection. The other is a webhook. An ElevenLabs agent posts the caller's question to it, an OpenAI agent looks the answer up in Qdrant, and ElevenLabs speaks what comes back. ## What is inside - `workflow.json`: the workflow as n8n exports it, 18 nodes and five sticky notes. It holds no credential. - `README.md`: these notes. ## What we changed from the original copy - `Create collection` sent a POST to `/collections/` with a body of `{"filter": {}}`, which is a points filter. Qdrant creates a collection with a PUT and a `vectors` setting. The node now sends a PUT with a vector size of 1536 and the distance `Cosine`, and its On Error setting is Continue, so a second run does not stop when the collection already exists. - `Window Buffer Memory` had no session setting. Its default reads a `sessionId` field that a webhook call does not carry, so the agent would stop with "No session ID found". It now uses a fixed key, `voice-rag-chat`. - The address placeholders are now `YOUR_QDRANT_URL`, `YOUR_COLLECTION` and `YOUR_FOLDER_ID`. The original copy wrote them as `QDRANTURL`, `COLLECTION` and a sample folder name after an equals sign. - The five sticky notes are rewritten. The widget snippet in the last one uses the script address ElevenLabs shows now. - The original copy was exported with no credential, as these notes expect, and with the workflow switched off. ## Before you start - An n8n instance with a public address, on n8n Cloud or your own server, so ElevenLabs can reach the webhook. - An OpenAI API key. It covers the two chat models and the embeddings. - A Qdrant instance, its address and its API key. - A Google account, a Drive folder with your documents in it and a Google Drive OAuth2 credential. - An ElevenLabs account with an agent that can call a webhook tool. ## 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`, `OpenAI Chat Model`, `Embeddings OpenAI` and `Embeddings OpenAI1`. 3. Add a Qdrant credential with your address and key. Select it in `Qdrant Vector Store` and `Qdrant Vector Store1`. In both, replace `YOUR_COLLECTION` with your collection's name. 4. Add an HTTP Header Auth credential with the header name `api-key` and your Qdrant key as its value. Select it in `Create collection` and `Refresh collection`. In both, replace `YOUR_QDRANT_URL` with your Qdrant host, with its port if it uses one, and `YOUR_COLLECTION` with the same collection name. 5. Add a Google Drive OAuth2 credential. Select it in `Get folder` and `Download Files`. In `Get folder`, replace `YOUR_FOLDER_ID` with the ID of your folder, the last part of its web address. 6. Press Test workflow once. The collection is made, emptied and filled from the folder. Check in Qdrant that it holds points. 7. Save and press Publish. Copy the production address of `Listen`. It ends in `test_voice_message_elevenlabs`. 8. In ElevenLabs, create an agent and give it a first message and a system prompt that tells it to call your tool for every question. Add a Webhook tool with the method POST and the production address. Add one body parameter named `question`, a string whose value the model fills in from the conversation. 9. Test the agent in ElevenLabs. Then add the widget to your site, as the last sticky note shows. ## How a run goes Loading the documents runs from `When clicking ‘Test workflow’`: 1. `Create collection` makes the collection in Qdrant. `Refresh collection` then posts a delete of every point, with an empty filter, so each load starts from nothing. 2. `Get folder` lists the files directly inside your folder, up to 50. `Download Files` downloads each one, and turns a Google Doc into plain text. 3. `Qdrant Vector Store1` stores them. `Default Data Loader` reads each file's binary data and picks a loader by file type. `Token Splitter` cuts the text into chunks of 300 tokens that overlap by 30. `Embeddings OpenAI1` turns each chunk into a vector. Answering runs from the webhook: 1. `Listen` takes a POST on the path `test_voice_message_elevenlabs` and waits for `Respond to ElevenLabs` to answer. 2. `AI Agent` takes `body.question` from the request as its message. `OpenAI` is its chat model, and `Window Buffer Memory` keeps the last five exchanges. 3. The agent can call `Vector Store Tool`, named `company`. `Qdrant Vector Store` finds the four closest chunks, using `Embeddings OpenAI` for the question, and `OpenAI Chat Model` writes an answer from them. 4. `Respond to ElevenLabs` sends the first item back as JSON, `{"output": "..."}`, and the ElevenLabs agent speaks it. ## Change the look - What the agent is allowed to say: add a system message to `AI Agent`, and tell the ElevenLabs agent how to behave in its own prompt. - When the agent searches: the name and description of `Vector Store Tool`. The description is written in Italian, so put yours there, in the language of your documents. - The chunks: 300 and 30 in `Token Splitter`. - How many chunks an answer uses: the Limit of `Vector Store Tool`, 4 by default. - The chat models: `OpenAI` and `OpenAI Chat Model`. The file sets no model, so n8n fills in its own default. - The embedding model: `Embeddings OpenAI` and `Embeddings OpenAI1`. Keep them the same, and change the vector size in `Create collection` to match. ## Good to know - Neither OpenAI chat node names a model in the file, so n8n fills in `gpt-5-mini`. OpenAI's deprecations page, read on 12 November 2026, lists it for shutdown on 11 December 2026, with `gpt-5.6-terra` as the replacement. Choose another model in both nodes before then. The embedding default, `text-embedding-3-small`, is not on that page. - Qdrant's API page does not say what an empty filter in a delete matches. `Refresh collection` expects every point to go, so look at the point count after a load. - The vector size of 1536 matches `text-embedding-3-small`. A different embedding model needs its own size and a new collection. - Every press of Test workflow empties the collection and embeds every file again, and OpenAI bills the embeddings each time. - `Get folder` reads only the files directly in the folder, not its subfolders. - Every caller shares one conversation, because the memory key is fixed. The history lives in the n8n process, and n8n drops it after an hour without use. - The webhook has no authentication. Anyone with its address can ask questions on your OpenAI key. Turn on the webhook's authentication and send the same header from the ElevenLabs tool. - The test address works only while n8n is listening, so the ElevenLabs tool needs the production address. - ElevenLabs only shows a widget for an agent that is public, with authentication off. - Your documents go to OpenAI to be embedded and are stored in Qdrant. Each question goes to OpenAI. ``` ## What is in it 3 files, 22 KB, downloaded as a zip. ```text NOTICE.md 664 B README.md 7 KB workflow.json 14 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 9 steps, starting by hand or when its webhook is called - AI: 2 steps call an AI model: Qdrant Vector Store1 and AI Agent - Sign-ins: Signs in to: your_qdrant_url, Google Drive, Qdrant and OpenAI - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 7 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/213f8441-3a7d-432b-b481-e1ececa8c144) - [Its page on Mindket](https://mindket.com/p/213f8441-3a7d-432b-b481-e1ececa8c144)