AI Customer Data Query Agent with Google Sheets

Overview

This workflow creates an AI-powered customer data query assistant. It enables users to ask natural language questions about customer information stored in a Google Sheet, such as "Which is our biggest customer?" or "What is the email of customer row 5?". The AI agent (powered by OpenAI) intelligently selects and calls custom tools to retrieve the relevant data from the sheet, making it easy to explore and analyze structured data without writing any queries.

Step-by-Step Breakdown

  1. When Chat Message Received (Chat Trigger) — No auth. Listens for incoming messages from the n8n chat interface. This is the entry point for user queries.
  2. AI Agent (Agent) — No auth. Orchestrates the conversation, decides which tool to use based on the user's query, and passes the response back to the chat. It uses the OpenAI Chat Model and Simple Memory nodes for context.
  3. OpenAI Chat Model (Language Model — OpenAI) — API Key auth. Provides the AI reasoning power. Configured to use gpt-4o-mini for cost-effective performance.
  4. Simple Memory (Memory Buffer Window) — No auth. Maintains conversation history within a sliding window, enabling the agent to remember previous interactions.
  5. List Columns Tool (Workflow Tool) — No auth. A custom sub-workflow tool that calls the sub-workflow below to return all column names from the Google Sheet.
  6. Get Column Values Tool (Workflow Tool) — No auth. Another custom tool that returns all values for a specified column (e.g., all customer names).
  7. Get Customer Tool (Workflow Tool) — No auth. Returns a full row of data for a given customer row number.
  8. When Executed by Another Workflow (Execute Workflow Trigger) — No auth. Receives the operation (column_names, column_values, or row) and query string from the tools above.
  9. Set Google Sheet URL (Set) — No auth. Extracts the sheet URL from an environment variable WEBHOOK_URL (you can change this to any URL or variable).
  10. Get Google Sheet Contents (Google Sheets) — OAuth2. Fetches all rows from the sheet named customer_data using the provided document ID (URL). Requires Google Sheets credentials.
  11. Check Operation (Switch) — No auth. Routes execution based on the operation field: goes to one of three branches (column_names, column_values, row).
  12. Get Column Names (Set) — No auth. Extracts the keys (column headers) from the first row of the sheet data.
  13. Prepare Column Data (Set) — No auth. For the column_values branch, it adds a row_number field to each row for later filtering.
  14. Filter (Filter) — No auth. For the row branch, filters the sheet data to return only the row where row_number matches the user's query.
  15. Prepare Output (Code) — No auth. Wraps the result into a JSON string under the response key, which is sent back to the calling tool.
  16. Error Handler (Stop and Error) — No auth. Catches any errors and stops execution with a meaningful message.

Setup Instructions

  1. Google Sheets — You need a Google Sheet with a sheet named customer_data. The first row should contain column headers (e.g., Name, Email, Revenue). Create Google Sheets OAuth2 credentials in n8n (see Google Sheets node docs).
  2. OpenAI — Obtain an API key from OpenAI. In n8n, create OpenAI credentials (choose API Key auth) and use your key.
  3. Environment Variable — By default, the workflow expects the sheet URL in the WEBHOOK_URL environment variable. You can replace this with a static URL or a credential field.
  4. Chat Trigger — No special setup; the chat interface works out of the box when you click “Chat” in n8n.

Use Cases and Variations

  • Customer Support — Let agents ask about customer accounts without accessing the raw sheet.
  • Sales Analysis — Query sales data, e.g., “Which customer has the highest revenue?”
  • Adapt to Other Data Sources — Replace the Google Sheets node with Airtable, PostgreSQL, or a REST API to query other databases.
  • Different LLM — Swap gpt-4o-mini for another model (e.g., Claude, Gemini) by changing the Language Model node.
  • Add More Tools — Extend the sub-workflow with tools for updating or deleting rows, making the agent bidirectional.

This workflow demonstrates a powerful pattern for turning static spreadsheets into conversational data assistants with minimal coding.

21 nodesmanual triggerAI
Sticky NoteNo OpSetGoogle SheetsSwitchFilterCodeStop And Error

Workflow JSON

{
  "meta": {
    "instanceId": "workflow-de323dd0",
    "versionId": "1.0.0",
    "createdAt": "2025-09-29T07:07:42.480680",
    "updatedAt": "2025-09-29T07:07:42.480694",
    "owner": "n8n-user",
    "license": "MIT",
    "category": "automation",
    "status": "active",
    "priority": "high",
    "environment": "production"
  },
  "nodes": [
    {
      "id": "f3f7546a-8bb3-484c-b0a1-750a8d7d3a74",
      "name": "Sticky Note1",
      "type": "n8n-nodes-base.stickyNote",
      "position": [
        0,
        520
      ],
      "parameters": {
        "color": 7,
        "width": 1549,
        "height": 612,
        "content": "### Sub-workflow: Custom tool\nThis can be called by the agent above. It returns three different types of data from the Google Sheet, which can be used together for more complex queries without returning the whole sheet (which might be too big for GPT to handle)"
      },
      "typeVersion": 1,
      "notes": "This stickyNote node performs automated tasks as part of the workflow."
    },
    {
      "id": "a5afaa40-0b68-4d7c-8f78-5cb176fde81d",
      "name": "Sticky Note2",
      "type": "n8n-nodes-base.stickyNote",
      "position": [
        0,
        -40
      ],
      "parameters": {
        "color": 7,
        "width": 1068,
        "height": 547,
        "content": "### Main workflow: AI agent using custom tool"
      },
      "typeVersion": 1,
      "notes": "This stickyNote node performs automated tasks as part of the workflow."
    },
    {
      "id": "2dc0ce2f-a09c-4804-9962-f542ec78eb87",
// ... truncated (copy to see full JSON)

How to Import This Workflow

  1. 1Copy the workflow JSON above using the Copy Workflow JSON button.
  2. 2Open your n8n instance and go to Workflows.
  3. 3Click Import from JSON and paste the copied workflow.

Don't have an n8n instance? Start your free trial at n8nautomation.cloud

Related Templates

Automated Blog Post Creation from News with AI and Blogger

This workflow automates the entire process of creating a fully SEO-optimized blog post from a news article. It fetches a trending technology news headline from Mediastack, generates relevant images from Pexels, uses two AI agents (via OpenRouter) to produce a title, slug, meta description, and a complete WordPress-compatible HTML blog post, then posts it directly to Blogger and sends you a Telegram notification. It's perfect for content marketers, bloggers, or anyone who wants to consistently publish fresh, data-driven content without manual effort. Node Breakdown Schedule Trigger (No auth) — Runs the workflow at a set interval (configured every minute by default, but you should change it to daily or hourly). Mediastack News (API Key auth via query parameter) — Fetches the latest technology news article in English from the Mediastack API. Parameters: set to . Genarate image (API Key auth via header, ) — Searches Pexels for up to 2 images related to the news title. Parameters: = , = 2. Send a text message1 (Telegram bot token auth) — Sends a Telegram message with the generated image URLs to the chat ID stored in . AI Agent (Uses OpenRouter Chat Model — API Key auth) — This agent takes the news title and returns a JSON object with three fields: , , and (meta description). The prompt includes strict guidelines for SEO-friendly output. OpenRouter Chat Model (API Key auth) — The language model for the first AI agent, using . Parsing (No auth) — A Code node that cleans the raw AI output (removes markdown code fences) and parses the JSON into usable fields. Copywriter AI Agent (Uses OpenRouter Chat Model2 — API Key auth) — This agent writes a complete 1,000-word SEO blog post in HTML format. It uses the title, meta, and the two images from Pexels. The prompt is very detailed, specifying structure, keyword placement, and styling. OpenRouter Chat Model2 (API Key auth) — Same model as the first, but used for the second agent. Cleanup HTML (No auth) — A Set node that removes any leftover htmlurlhttps://www.googleapis.com/blogger/v3/blogs/$vars.bloggerid/postsPOSThttpQueryAuthAuthorization$vars.telegramchatid$vars.bloggeridbusinesssports`) to match your niche. Multi-language Support — Modify the Mediastack query to fetch news in other languages, and adjust the AI prompts to write in that language. Custom Image Sources — Replace the Pexels node with another image API (e.g., Unsplash) or use a local image generation model. Different CMS — Swap the Blogger HTTP Request node with WordPress or any other CMS API (just change the URL and body format). Human-in-the-Loop — Add a Slack or email approval step before publishing to review the AI-generated content. Newsletter Integration — Instead of posting to a blog, send the formatted content as an email newsletter via Gmail or SendGrid.

16 nodes

Telegram RAG Chatbot with File Upload and Groq LLM

This workflow creates a Telegram chatbot that uses Retrieval-Augmented Generation (RAG) to answer questions based on documents you upload. Users can send PDF or CSV files to a Telegram chat, and the workflow processes them into a vector database. When a user then sends a text message, the AI agent retrieves relevant chunks from the stored documents and generates an answer using the Groq Llama 3.1 model. It's like having a personal assistant that learns from your files and responds via Telegram. Node-by-Node Walkthrough Telegram Message Trigger (Telegram Trigger, no authentication required on the node itself — authentication is handled via the Telegram Bot API credentials configured in the n8n credentials store). This trigger listens for all types of updates (messages, commands, etc.) from a Telegram bot. When a new update arrives, it starts the workflow. Get a chat1 (Telegram node, Telegram Bot API token auth). It extracts the from the incoming message and passes it to the next node, ensuring the AI agent knows which chat to reply to. AI Agent1 (LangChain Agent, no auth). This is the core of the workflow. It uses a system message that instructs the AI to answer only from the knowledge base. The agent has access to the Groq Chat Model as its language model and the Retrieve documents tool to fetch relevant document chunks. It also uses Simple Memory to keep conversation context within a session (keyed by the Telegram chat ID). Groq Chat Model (Groq LLM, Groq API key auth). Uses the model. This provides fast, coherent answers. Simple Memory (Memory Buffer Window, no auth). Stores the last few turns of conversation to give the agent context. The session key is set to the Telegram chat ID from the trigger. Retrieve documents (Vector Store as Tool, no auth). This tool allows the agent to query the in-memory vector store. It returns the top 10 most similar document chunks. Embeddings HuggingFace Inference1 (Hugging Face Inference, Hugging Face API key auth). Generates embeddings for the user's query so the vector store can find relevant documents. Upload your file here (Form Trigger, no auth). This form trigger provides a web form where users can upload or files. The uploaded file(s) are passed to the Default Data Loader1. Default Data Loader1 (Document Default Data Loader, no auth). Converts the uploaded binary file into a LangChain document object. Recursive Character Text Splitter (Text Splitter, no auth). Splits the document into chunks of up to 3,000 characters with 200 character overlap. This ensures the vector store indexes manageable pieces. Simple Vector Store (In-Memory Vector Store, no auth). Stores the document chunks along with their embeddings. The embedding model used is Embeddings HuggingFace Inference. Embeddings HuggingFace Inference (Hugging Face Inference, Hugging Face API key auth). Generates embeddings for each document chunk before storing them. Reply in Telegram1 (Telegram node, Telegram Bot API token auth). Sends the AI agent's output back to the same Telegram chat. Setup Instructions Telegram Bot: Create a bot via @BotFather and get its API token. In n8n, add a Telegram credential using this token. Groq: Sign up at GroqCloud to get an API key. Add a Groq credential in n8n. Hugging Face: Create a free account at Hugging Face and generate an Inference API token. Add a Hugging Face Inference credential in n8n. n8n Form Trigger: This node is built-in. Ensure your n8n instance is publicly accessible (or use a tunnel like ngrok) so the form can be accessed by users. Deploy: Activate the workflow. Share the Telegram bot username with users. They can upload files by visiting the form URL (the one generated by the Upload your file here node) and then send text messages to the bot. Use Cases and Variations Personal knowledge base: Upload company policies, technical documentation, or study materials and ask questions about them via Telegram. Customer support bot: Replace the file upload with an HTTP node that fetches FAQs from a database, and use the same RAG architecture to answer customer queries. Multi-user support: The session memory is already scoped by Telegram chat ID, so multiple users can use the bot simultaneously without interfering. Switch LLM: Replace Groq with OpenAI, Anthropic, or any other supported LLM provider by changing the model node. Persistent vector store: Swap the in-memory vector store for Pinecone, Weaviate, or Qdrant to retain documents across restarts.

15 nodes

AI Blog Generator For WordPress Posts

AI Blog Generator For WordPress Posts This workflow automates the creation of blog post drafts by combining an n8n form, OpenAI's language model, and WordPress. It's designed for content creators, marketers, and bloggers who want to overcome writer's block and streamline their content pipeline. Instead of starting from a blank page, you submit a topic, target audience, and key points through a simple form, and the workflow generates a structured, well-written draft ready for your review and editing in WordPress. The core value of this workflow is its efficiency. It transforms a time-consuming task—writing a first draft—into a quick, structured process. By keeping the output as a 'draft' in WordPress, it ensures that nothing goes live without your final approval, maintaining editorial control. The workflow also includes thoughtful touches like automatic retries for the AI call and clear instructions for troubleshooting, making it robust and user-friendly. Workflow Nodes and Steps Here is a step-by-step breakdown of the workflow: Setup — read me first (Sticky Note) — Provides an overview, setup time, level, and links to the creator's site. How it runs (Sticky Note) — Explains the workflow's logic and data flow. If something breaks (Sticky Note) — Offers guidance on error handling and setting up an error workflow. Draft Request Form (Form Trigger) — This node hosts a web form with fields for 'Topic', 'Audience', and 'Key points (one per line)'. It starts the workflow when the form is submitted. (No auth required for the form itself). Write Draft (OpenAI) — This node uses the model to generate the blog post. It receives the form data and uses a carefully crafted prompt to produce a title and body in HTML format. (API Key auth). Split Title and Body (Code) — A JavaScript code node that parses the AI's response, extracting the title and the HTML body content into separate fields for the next step. (No auth). Create WordPress Draft (WordPress) — This node creates a new post in WordPress with the generated title and content, setting the status to 'draft' so it's not published immediately. (Application Password auth). Setup Instructions To use this workflow, you will need the following: OpenAI Account: You need an API key from OpenAI. Create an account at platform.openai.com, go to the API keys section, and create a new secret key. Add this key to the 'Write Draft' node's credentials. WordPress Site: You need a self-hosted WordPress.org site (not WordPress.com). To connect, you'll need to generate an Application Password. In your WordPress admin dashboard, go to Users > Profile and scroll down to the 'Application Passwords' section. Create a new one and use those credentials in the 'Create WordPress Draft' node. Activate the Workflow: After connecting your credentials, activate the workflow in n8n. The 'Draft Request Form' node will provide a production URL. Bookmark this URL to access your form. Use Cases and Variations Content Calendars: Integrate this with a Google Sheets node to log all generated drafts and their statuses. Multi-Platform Publishing: Add a step to convert the HTML draft to Markdown and send it to other CMSs like Ghost or Dev.to. SEO Optimization: Insert a node to analyze the generated content for keywords or readability scores before creating the WordPress post. Team Collaboration: Instead of a public form, trigger the workflow from a Slack command or email, allowing your team to submit topics without leaving their communication tools. Different Content Types: Modify the prompt in the 'Write Draft' node to generate other content formats like product descriptions, social media posts, or email newsletters.

7 nodes

Ready to automate with n8n?

Get affordable managed n8n hosting with 24/7 support.