n8n AI Automation Masterclass: Build AI Chatbots (Hindi)

Creating the Basic n8n Chatbot Flow

In this chapter, Tushar Vishwakarma walks you through building your first working chatbot in n8n from scratch. You will start by creating a new workflow, adding a Chat Trigger node, and connecting it to an AI Agent node, the flexible core that will power your chatbot as it evolves throughout the course.

Tushar then guides you through connecting a chat model to the agent. The chapter uses Google Gemini as the example, chosen for its straightforward setup and generous free tier that requires no credit card. You will learn how to generate an API key from AI Studio, connect it to n8n, and select the right model for your needs.

Once the setup is complete, you will test your chatbot live using n8n's built-in chat window. But here is where things get interesting. You will also discover a key limitation of this basic setup: the chatbot has no memory. Each message is a separate API call, meaning the bot cannot recall anything from earlier in the same conversation. This sets up the next important milestone, giving your chatbot a personality and persistent memory, which is exactly what the upcoming chapters will cover.

By the end of this chapter, you will have a functional chatbot running inside n8n and a clear understanding of what needs to be built next.

Two Ways to Give LLMs Access to Your Data

In this chapter, Tushar Vishwakarma breaks down one of the most important decisions you will face when building AI-powered applications: how do you give a language model access to your own data?

Tushar starts by addressing the two core limitations that every LLM has out of the box. First, the knowledge cutoff, meaning models only know what they were trained on and are essentially out of date the moment they are deployed. Second, LLMs have no access to your internal data, whether that is company documents, databases, or internal tools.

To solve these problems, there are two main approaches covered in this chapter:

Fine-Tuning: This involves taking a pre-trained model and continuing to train it on your own proprietary data. While it can create deep domain-specific expertise, it comes with significant trade-offs including high cost, technical complexity, and the fact that even a fine-tuned model still has a knowledge cutoff.

Context Augmentation (Prompting): Instead of changing the model, you keep it as-is and feed it the right information at run time through a well-crafted prompt. This approach is faster, more flexible, and more practical for most real-world use cases.

By the end of this chapter, you will have a clear mental model of both approaches and know which one fits your specific use case, setting the foundation for the vector search and Pinecone integration that follows later in the course.

Configuring the LLM and Prompt

In this chapter, Tushar Vishwakarma shows you how to make your chatbot actually useful by giving it a personality, a role, and real knowledge about your company, all through a well-crafted system prompt.

You will revisit the GitHub repository and explore the system prompt provided for the simple chatbot. This prompt does several important things at once. It defines the chatbot's role as an internal HR support assistant, embeds FAQ data directly as the chatbot's knowledge source, sets clear constraints to keep the bot focused on its purpose, and includes a fallback response for anything it cannot answer, helping prevent hallucinations by defaulting to "I'm sorry, I can't answer that. Please contact HR."

Tushar walks you through copying this prompt into the AI Agent node inside n8n, and then testing it live. You will see the chatbot respond with its new identity, answer policy-related questions from the embedded FAQ, and gracefully handle questions that fall outside its scope.

However, by the end of this chapter, a key limitation becomes clear. Even with a well-configured prompt, the chatbot still has no memory of the conversation. Each message is processed in isolation, meaning follow-up questions and context from earlier in the chat are completely lost. This sets up the next chapter perfectly, where you will solve this problem by adding memory to your chatbot.

Customizing the Memory Buffer

In this chapter, Tushar Vishwakarma solves one of the most important limitations identified in the previous chapter: giving your chatbot the ability to remember past messages within a conversation.

You will learn how to use n8n's built-in Memory feature by adding a Simple Memory node to your workflow. Tushar walks you through configuring how many previous messages the bot can retain and demonstrates the impact this has on conversation quality through a live example. When asked follow-up questions like "tell me more about the first" or "tell me more about the second," the bot can now refer back to its earlier responses accurately.

But the chapter also highlights a critical nuance. Through a deliberate test, you will see what happens when the memory window is too short. When asked about the third item in a list, the bot pulls from the wrong context because the original response has already fallen outside the memory buffer. This is a practical and eye-opening demonstration of how memory length directly shapes what your chatbot can and cannot recall.

Tushar shares practical guidance on choosing the right memory size, typically between 10 and 20 messages, while also flagging an important consideration around user experience: if the chat interface shows a long conversation history but the bot can only look back a few messages, users may have mismatched expectations about what the bot remembers.

By the end of this chapter, you will have a fully functional first version of your chatbot, complete with personality, knowledge, and memory, ready to be made publicly accessible in the next chapter.

Milestone: Working Prompt-Based Support Bot

In this chapter, Tushar Vishwakarma takes your chatbot live for the first time. You will learn how to use n8n's built-in chat feature to make your bot publicly accessible through a real web interface, marking the first major milestone of the course.

Tushar walks you through enabling the public chat URL inside the Chat Trigger node and explains the two available modes: a hosted chat page provided by n8n, and an embedded chat widget you can integrate directly into your own website. You will also explore authentication options, initial greeting messages, and basic styling settings including title, subtitle, colors, and fonts.

A key insight in this chapter is the trade-off between model power and response speed. You will see firsthand how switching from Gemini 2.5 Pro to Gemini 2.5 Flash significantly reduces response time, and how tuning the sampling temperature down to zero makes your chatbot's answers more consistent and reliable for a support use case.

By the end of this chapter, you will have a fully deployed, prompt-based HR support chatbot running on a live URL, complete with a branded interface and optimized model settings. It can answer common employee questions, stay in character, and handle follow-up queries thanks to the memory configured in the previous chapter.

This is your first working version, and the foundation everything else in the course builds on.

Retrieval-Augmented Generation (RAG) in Five Minutes

In this chapter, Tushar Vishwakarma gives you a concise and practical introduction to Retrieval-Augmented Generation, the core concept that powers the next stage of your chatbot's evolution.

The chapter starts by revisiting a fundamental limitation: feeding entire documents into a prompt does not scale. As your knowledge base grows, you need a smarter way to give your chatbot access to the right information at the right time, without overwhelming the model or manually maintaining a massive prompt.

Tushar introduces the concept of Smart Context Augmentation, where documents are broken into smaller chunks and only the most relevant pieces are pulled into the prompt when a question is asked. This approach is more efficient, produces better quality responses, and works seamlessly with existing search tools.

From there, you will get a clear, step-by-step breakdown of how RAG works:

• Storage: Documents are broken into chunks and stored in a searchable database as both plain text and numerical vector embeddings

• Retrieval: When a question is asked, only the most relevant chunks are pulled from the database

• Generation: The LLM uses those retrieved chunks combined with its own reasoning to produce accurate, grounded responses

You will also get an accessible explanation of what vector embeddings are, how they capture the meaning of text numerically, and why this enables smarter semantic search compared to traditional keyword matching.

By the end of this chapter, you will have a solid conceptual foundation for the Pinecone integration coming up next, where you will put RAG into practice inside your n8n workflow.

Setting Up Pinecone

In this chapter, Tushar Vishwakarma walks you through setting up Pinecone as the vector database that will power your chatbot's ability to search across large custom document sets.

Tushar starts by explaining why Pinecone is the choice for this course: it is widely used, beginner-friendly, and quick to get running. That said, you will also understand that any vector database of your choice can be used in its place.

The chapter covers the full setup process from scratch. You will create a Pinecone account, retrieve your API key, and configure your first index, which acts as the database where your documents will be stored. Tushar walks you through the specific configuration settings required to match the Gemini embedding model used later in the course, including setting the vector type to dense, the dimension length to 768, and the metric to cosine.

Once the index is created, you will switch back to n8n and connect Pinecone by adding your API key as a new credential. The entire process is straightforward and takes just a few minutes.

By the end of this chapter, your Pinecone vector store is live, configured correctly, and connected to n8n, ready to receive your documents in the next chapter.

Creating the Embedding Workflow in n8n

In this chapter, Tushar Vishwakarma builds the data ingestion pipeline that transforms your raw documents into searchable vector embeddings stored in Pinecone. This is the backbone of your RAG-powered chatbot.

You will start by creating a new workflow in n8n with a manual trigger, then define variables for your GitHub repository details including the owner, repository name, and document path. Tushar walks you through connecting a GitHub node to list and download files directly from the course repository, pulling in your HR policy documents as binary files.

From there, you will add and configure the Pinecone Vector Store node to store incoming documents into the index you created in the previous chapter. You will also connect the Gemini text embedding model, specifically the text-embedding-004 model, which converts your document chunks into 768-dimensional vectors that Pinecone can search across.

The chapter goes deeper into document processing configuration, covering:

• Setting up the Default Data Loader to handle PDF files

• Splitting documents by page to enable precise source attribution

• Adding metadata fields including Document ID and Document URL for traceability

• Configuring the Recursive Character Text Splitter with a chunk size of 1000 characters and 10% overlap as a solid starting point

Tushar also tackles a practical challenge: preventing duplicate data. You will add an HTTP request node that clears the Pinecone index before each run, ensuring the store is always rebuilt cleanly from the latest documents rather than accumulating duplicates over time.

By the end of this chapter, your embedding workflow is fully operational, with 87 document chunks successfully stored in Pinecone and ready to be queried by your chatbot in the next chapter.

Creating the Retrieval Workflow in n8n

In this chapter, Tushar Vishwakarma builds the second half of the RAG pipeline: the retrieval workflow that fetches the right information from Pinecone whenever your chatbot needs to answer a question.

You will create a new workflow from scratch, this time triggered by another workflow rather than manually. This is important because the retrieval flow will later be called automatically by your chatbot as a custom tool every time it needs to look up internal information.

Tushar walks you through connecting the Pinecone Vector Store node in retrieval mode, configuring it to fetch the top five most relevant document chunks based on an incoming search query. You will use the same Gemini embedding model from the ingestion workflow to ensure the search vectors are compatible, and enable metadata inclusion so each result carries its source information.

The chapter then covers how to clean and structure the retrieved data for use by the LLM, including:

• Extracting the four key fields per chunk: content, filename, URL, and page number

• Aggregating all chunks into a single flat list using an Aggregate node

• Converting everything into one clean text string using an Edit Fields node, ready to be injected into the chatbot's context window

Tushar also highlights a useful extension point: the ability to filter retrieved chunks based on user permissions or other criteria, giving you a glimpse into how this workflow can be expanded for more advanced use cases.

By the end of this chapter, your retrieval workflow is saved, tested, and ready to be plugged directly into your chatbot in the next chapter.

Step by Step: Advanced Chatbot Workflow in n8n

In this chapter, Tushar Vishwakarma brings everything together by building the advanced chatbot workflow that connects your AI agent to the data ingestion and retrieval pipelines created in the previous chapters.

You will create a new workflow with a Chat Trigger and an AI Agent node, then configure it with a more sophisticated system prompt. Compared to the basic version, this prompt introduces three important upgrades: it instructs the agent to retrieve knowledge by calling a dedicated tool rather than relying on embedded FAQ data, it prompts the agent to ask clarifying questions when faced with broad or open-ended queries to improve retrieval accuracy, and it adds citation instructions so every answer includes a footnote showing exactly which document and page the information came from.

Tushar walks you through adding a Gemini chat model with the sampling temperature set to zero for consistent responses, a Simple Memory node configured to retain up to 20 messages, and most importantly, a custom tool that calls the Chatbot Data Retrieval workflow you built in the previous chapter. This tool is named "GET HR policy" and acts as the agent's gateway to your entire Pinecone knowledge base.

The chapter includes a live demonstration of the chatbot in action, covering three revealing scenarios. A simple greeting that requires no tool use, a policy question that triggers a vector search and returns a cited answer, and a query about MacBooks that shows the power of semantic search, where the bot retrieves relevant results about company equipment even though the exact keyword never appears in the source documents.

By the end of this chapter, you will have a fully functional advanced chatbot that can intelligently search your internal knowledge base, handle natural language queries, and cite its sources, ready to be tested in the real world.

Milestone: Smart Chatbot Powered by Your Own Docs

In this chapter, Tushar Vishwakarma takes your advanced RAG-powered chatbot live, marking the second and most significant milestone of the course.

You will learn how to activate your workflow and make the chatbot publicly accessible through n8n's hosted chat interface, the same process covered earlier but now applied to a far more powerful bot. Tushar walks you through enabling the public chat URL, activating the workflow, and testing the chatbot in a real browser window.

The live demo in this chapter showcases everything you have built working together seamlessly. When asked a broad question about vacation policies, the chatbot does exactly what it was designed to do: it asks a clarifying follow-up question to narrow down the query before searching the knowledge base. When a specific answer is provided, it retrieves the right document chunks, generates a clear and accurate response, and displays cited sources with clickable links back to the original PDF documents stored in GitHub. This confirms that memory, retrieval, and citation are all functioning correctly end to end.

Tushar also highlights a current limitation worth knowing about: the AI Agent in n8n does not support streaming responses out of the box, meaning replies are delivered all at once rather than word by word as you might expect from tools like ChatGPT. This is flagged as a topic covered in the next chapter on optimization and performance improvements.

By the end of this chapter, you will have successfully launched a production-ready chatbot backed by a full RAG architecture, one that searches your own documents, remembers conversations, cites its sources, and handles natural language queries with ease.

Recap

In this chapter, Tushar Vishwakarma pauses to take stock of everything built so far, what was intentionally left out, and what comes next as the chatbot moves closer to production.

On the built side, the recap covers the full journey: creating a custom chatbot flow in n8n using no-code building blocks, using prompt engineering to shape LLM behavior, adding a memory buffer for conversational context, and integrating a RAG pipeline that grounds every answer in your own internal documentation.

Tushar also calls out the genuine strengths of what has been built. It was fast to build, requires no external development support, allows the LLM to be swapped out at any time, and is modular by design, making it easy to add new workflows, data sources, and logic without breaking what already works. Most importantly, it is already capable of reducing workload on support and HR teams.

Just as valuable is the honest breakdown of what was not built yet. There is no user authentication or session management, no polished chat UI or widget integration, no caching, error handling, or retries, no security gateway, and no monitoring or analytics. These gaps were intentional to keep the build fast and focused, but they represent the natural next steps toward a production-ready deployment.

The chapter closes with a clear roadmap for what comes next: validating demand, handling edge cases, automating document updates to keep the knowledge base current, and defining a development roadmap to prioritize features in the right order.

This chapter is an important checkpoint that sets up the final section of the course, where the focus shifts to optimization, refinement, and scaling.

Optimizing the UI

In this chapter, Tushar Vishwakarma shifts focus to one of the most practical aspects of shipping a chatbot that people will actually use: the interface. A well-designed UI drives adoption, and this chapter gives you a clear framework for choosing the right approach based on your specific use case.

Tushar walks through three distinct options for deploying your chatbot's front end:

n8n's built-in frontend: The fastest way to get started, ideal for prototyping and internal use. You can customize fonts, colors, and layout using CSS through the chat trigger node's styling options, though deeper customization has its limits.

Custom frontend: When you need a polished, branded experience, n8n can serve as a pure backend that communicates with a custom-built frontend via webhooks or APIs. This works well with popular frameworks like React or Vue and open-source chatbot UI templates.

Direct integration: Skip frontend development entirely by connecting your chatbot to tools your team already uses, such as Slack or Microsoft Teams, via n8n's built-in integrations. This is a low-friction, high-impact option for internal use cases where convenience matters most.

The chapter also covers an important limitation shared across all three options: none support native message streaming out of the box. Workarounds exist but add significant technical complexity.

Tushar closes with a set of practical best practices to keep in mind during development, including saving chat history for returning users, enabling retry on fail for error handling, validating user input for security, and formatting LLM output correctly with markdown, hyperlinks, and code highlighting.

The key takeaway: your n8n chatbot backend stays the same regardless of which interface you choose. It is the UI layer that adapts to your audience.

Working with Complex Documents

In this chapter, Tushar Vishwakarma tackles one of the most important but often overlooked challenges in building a production-ready RAG chatbot: the messiness of real-world documents.

The documents used in the course demo were a best-case scenario, clean text, consistent formatting, and simple layouts. In practice, you will encounter scanned PDFs with poor OCR output, multi-column layouts, complex tables, headers, footers, and embedded images. Since your RAG architecture converts text into vector embeddings, the quality of that text directly determines the quality of your chatbot's answers. Garbage in, garbage out.

Tushar walks through four practical strategies for handling document complexity:

Pre-processing: Verify OCR outputs, flatten unusual layouts, strip headers and footers, and process images separately before feeding anything into your embedding pipeline. Cleaning inputs upfront makes a significant difference in retrieval quality.

Enriching metadata: Go beyond file name and page number. Store section headings, document versions, and other references that help both the chatbot and the user understand where an answer came from. Traceability builds trust and makes debugging far easier.

Starting narrow: Focus on one clean, business-critical domain first, such as HR policies or customer support. Get that domain working well before expanding. Scaling quality is much easier than fixing problems at scale.

Tracking freshness and versioning: Add timestamps to document versions, prioritize the latest during retrieval, and automate stale chunk expiration or rebuild your vector store regularly to keep information accurate and current.

The chapter also looks ahead at four areas to improve your RAG system over time: optimizing your embedding model, applying advanced retrieval filters, re-ranking results based on custom scoring, and rewriting search queries to better match user intent.

Tushar closes with a look at knowledge graphs as an advanced option for adding structure to chaotic content, enabling more precise retrieval and more explainable results.

Securing and Scaling Your Chatbot

In this chapter, Tushar Vishwakarma shifts focus from making your chatbot work to making it work securely and reliably at scale. This is the critical bridge between a working prototype and a production-ready deployment.

Tushar opens by acknowledging the real risks: LLMs can be costly to run at scale, and there are well-documented cases of chatbots leaking internal information, producing wrong responses, or being manipulated into behaving in unintended ways. This chapter gives you a practical framework to prevent all of that.

On the security side, three key areas are covered:

Input control: Implement a security gateway in n8n that sits between the chat input and your LLM. This filters out harmful, manipulative, or prompt injection attempts before they ever reach your model. One straightforward approach is using a second LLM to classify incoming messages by risk level and replace flagged content with a redacted value.

Data leakage prevention: Restrict what each user can query by passing access group metadata to the retrieval node as a filter. Additionally, clean retrieved data before it reaches the LLM by stripping personal information or internal fields that should not be exposed.

Infrastructure protection: Apply rate limiting, monitor traffic to detect abuse, and set token budgets or cost limits with your LLM provider to avoid unexpected expenses.

On the scaling and performance side, Tushar covers caching as the single biggest win, storing answers to frequent questions using input hashes to save tokens and reduce latency. He also compares n8n Cloud versus n8n On-Prem, helping you choose the right infrastructure depending on your scale, data sensitivity, and compliance requirements.

Four concrete performance levers are outlined to reduce end-to-end latency: choosing a fast capable model like Gemini Flash or GPT-4o, keeping your retrieval workflow lean, selecting a fast vector store, and implementing semantic or recently used caching to avoid hitting the LLM with repeated queries.

By the end of this chapter, you will have a clear and actionable roadmap for taking your chatbot from a functional prototype to a secure, scalable, production-grade deployment.

Keeping Your Chatbot Accurate Over Time

In this chapter, Tushar Vishwakarma addresses one of the most important realities of deploying a chatbot: it is not a one-time setup. It is a living system that requires ongoing monitoring, feedback loops, and iteration to stay useful and accurate.

Tushar opens by outlining why monitoring is non-negotiable from day one. Documents change and can quietly break things that used to work. When the retrieval system cannot find the right content, it will not flag the problem, it will simply fall back to a default response or worse, hallucinate an answer. Token usage and costs can grow unnoticed, and users will inevitably ask questions you did not anticipate when you first built the bot.

The chapter covers what to track across two dimensions. On the usage side: query volume, peak usage patterns, and popular topics. On the quality side: fallback rates, user feedback signals like thumbs up or down, retrieval accuracy, and overall answer quality.

Tushar then walks through what data to log for each interaction, including the user query, session ID, timestamp, retrieved content with its source document and page, the final LLM response, and whether a fallback was triggered. You will also learn how n8n's built-in tools support this, from execution logs and webhooks to integrations with visualization platforms like Grafana or Datadog, with the option to set up automated alerts for key metrics.

The chapter also covers keeping your knowledge base current by scheduling re-indexing runs, triggering document uploads automatically when content changes, and using n8n to automate the entire ingestion workflow so freshness requires no manual effort.

Tushar closes with the core principle that separates good chatbots from great ones: a continuous feedback loop of monitoring, analyzing, updating, testing, and deploying. This cycle is what keeps your chatbot accurate, efficient, and relevant over time.

Next Steps

In this closing chapter, Tushar Vishwakarma brings the course to a close with a look back at everything you have accomplished and a clear-eyed view of where to go from here.

Starting from zero code, you have built a fully functional custom chatbot using n8n and vector search. Along the way you learned how to structure chatbot workflows in n8n, understood two key approaches for connecting LLMs to your own data, and implemented a working RAG architecture with real-time semantic search powered by Pinecone. You also explored advanced topics including UI optimization, handling complex documents, securing and scaling your deployment, and setting up monitoring for long-term accuracy.

Tushar puts the achievement in perspective: without AI, building something like this would have required an entire engineering team, and the results still would not have come close to what you have built here.

The chapter closes with a practical nudge to keep the momentum going. The natural first step is to try everything out on your own data and adapt the system prompt to fit your specific use case. From there, the possibilities are wide open: new interfaces, additional data sources, tighter integrations, and continuous iteration based on real user feedback.

Tushar signs off by encouraging you to share what you have built, connect on LinkedIn, and keep building. This course is not the finish line. It is the starting point.