Workflow Templates

WooCommerce Fraud Detection & Slack Alert Workflow This workflow automatically monitors WooCommerce orders, evaluates them for fraud using multiple checks (address mismatch, high-value orders, suspicious emails, admin orders), calculates a fraud score and sends alerts to Slack when risk is detected. Quick Implementation Steps Import the workflow JSON into n8n Configure WooCommerce API credentials Set up Slack API credentials and channel Adjust fraud rules (amount threshold, email regex, etc.) Test with sample order data Activate the workflow What It Does This workflow automates fraud detection for WooCommerce orders by applying multiple validation checks and assigning a fraud score. It starts with scheduled execution, fetches order data and prepares it for evaluation by extracting key details such as billing information, order value and customer email. Once the data is prepared, the workflow applies a series of fraud detection rules. These include checking whether billing and shipping details mismatch, identifying high-value orders, detecting suspicious or disposable email addresses and verifying if the order was created by an admin. Each condition contributes to a fraud score based on predefined logic. Finally, all signals are merged and a fraud score is calculated. If the score crosses the defined threshold, a detailed alert is sent to a Slack channel with complete order and risk information, enabling quick manual review and action. Who’s It For eCommerce store owners using WooCommerce Fraud prevention and risk management teams Operations teams handling order validation Developers building automation workflows in n8n Businesses wanting real-time fraud alerts in Slack Requirements to Use This Workflow n8n instance (self-hosted or cloud) WooCommerce store with API access enabled WooCommerce API credentials configured in n8n Slack workspace with API credentials Slack channel ID for sending alerts Basic understanding of n8n nodes and workflows How It Works & Set Up Setup Instructions Import the workflow JSON into your n8n workspace Configure the Schedule Trigger node to define execution frequency Set up the WooCommerce node: Add API credentials Ensure correct store URL Modify orderId if needed Configure Slack node: Connect Slack API credentials Select or update the target channel Review Set nodes: Ensure fields like email, total and address are correctly mapped Validate IF conditions: Status check (pending/processing) Address mismatch logic High-value threshold (default: 500) Email regex for disposable domains Review Code node logic: Fraud score calculation rules Adjust scoring weights if needed Test the workflow: Use sample order data Verify Slack alert output Activate the workflow for automatic execution How To Customize Nodes Check High Value (>500)** Modify the threshold value to match your business needs Detect Disposable Email** Update regex pattern to include more domains Calculate Fraud Score (Code Node)** Adjust scoring logic: if ($json.high_value_order) score += 3; Fraud Threshold Check** Change minimum score required to trigger alerts Slack Message Node** Customize alert message format and included fields Add-ons (Enhancements) Store fraud results in a database (MySQL, MongoDB, etc.) Automatically cancel or hold suspicious orders via WooCommerce API Send email alerts in addition to Slack notifications Add IP geolocation checks for advanced fraud detection Integrate with third-party fraud detection APIs Add risk categorization (Low / Medium / High) Use Case Examples Detect high-value fraudulent orders before fulfillment Identify mismatched shipping addresses for manual review Flag orders using disposable or temporary email addresses Monitor admin-created orders to reduce internal misuse risk Real-time fraud alerts for operations teams via Slack > There can be many more use cases depending on how you extend and customize this workflow. Troubleshooting Guide | Issue | Possible Cause | Solution | | --------------------------- | ------------------------------------- | -------------------------------------------- | | No orders fetched | Incorrect WooCommerce credentials | Verify API keys and store URL | | Slack message not sent | Wrong Slack credentials or channel ID | Reconnect Slack and check channel | | Fraud score always 0 | Conditions not triggering | Verify IF node logic and data mapping | | Email detection not working | Regex not matching | Update regex pattern | | Workflow not running | Schedule trigger not configured | Set interval correctly and activate workflow | Need Help? If you need assistance setting up this workflow, customizing fraud rules or adding advanced features, our n8n workflow development team at WeblineIndia is here to help. We can help you: Customize this workflow for your business needs Integrate with external systems and APIs Build advanced fraud detection logic Create fully automated eCommerce workflows 👉 Reach out to WeblineIndia for expert support and tailored automation solutions.

⚠️ Important: This workflow uses the Autype community node and requires a self-hosted n8n instance. This workflow reads overdue invoices from a NocoDB database, generates a personalized payment reminder PDF for each record using the Autype Bulk Render API, and sends the resulting ZIP archive by email via SMTP. Days overdue are calculated automatically from the due date at runtime. Supported output formats: PDF, DOCX (Word), ODT. Who is this for? Finance teams, accounting departments, and developers who want to automate recurring document generation from database records. Good fit for payment reminders, invoices, collection letters, dunning notices, or any business correspondence that goes out in batches. What this workflow does It reads all overdue invoices from a NocoDB table, maps each row to a set of document variables, and sends everything to the Autype Bulk Render API in a single batch request. The result is a ZIP archive with one PDF per invoice, which gets sent by email via SMTP on a weekly schedule. The included payment reminder template includes: Company logo in the header, page numbers in the footer Customer name and full address block Invoice details table with USD amounts Styled table with alternating row colors Automatic date insertion via {{date/DD.MM.YYYY}} Days overdue calculated at runtime from due_date (no separate DB column needed) There is also a one-time setup flow (orange sticky note) that creates the Autype project and document template via API. NocoDB Table Structure Create a table called Overdue Invoices with the following columns: | Column | Type | Example | |---|---|---| | customer_name | Text | Jane Smith | | customer_address | Text | 742 Evergreen Terrace, Springfield, IL 62704 | | invoice_number | Text | INV-2026-0042 | | amount_due | Number | 1,250.00 | | due_date | Date | 2026-02-15 | | company_name | Text | TechStart Inc. | > days_overdue is not stored in the database. The workflow calculates it from due_date at runtime. Amounts are rendered in USD. Change the template if you need a different currency. Test Data Use these two sample records to test the workflow: Record 1: | Column | Value | |---|---| | customer_name | Jane Smith | | customer_address | 742 Evergreen Terrace, Springfield, IL 62704 | | invoice_number | INV-2026-0042 | | amount_due | 1250.00 | | due_date | 2026-02-01 | | company_name | TechStart Inc. | Record 2: | Column | Value | |---|---| | customer_name | Robert Chen | | customer_address | 88 Innovation Drive, Suite 400, Austin, TX 73301 | | invoice_number | INV-2026-0078 | | amount_due | 3480.50 | | due_date | 2026-01-15 | | company_name | DataFlow GmbH | How it works One-time setup (run once, then disable): Run Setup Once — triggers the setup flow manually. Create Project — creates an Autype project named "Payment Reminders". Create Document — creates the payment reminder template and returns the document ID. Main flow (weekly): Weekly Schedule — runs every Monday by default. Get Overdue Invoices — fetches all NocoDB rows where due_date < today. Build Bulk Items — maps rows to Autype variable sets and calculates daysOverdue from due_date. Bulk Render Payment Reminders — sends all items in one API call, waits for completion, downloads the ZIP. Send ZIP via Email — sends the ZIP via SMTP to a print service, accounting inbox, or document archive. Setup Install n8n-nodes-autype via Settings → Community Nodes (self-hosted n8n only). Get your API key at app.autype.com → API Keys. Add an Autype API credential in n8n and update YOUR_CREDENTIAL_ID in each Autype node. Set up a NocoDB instance and create the "Overdue Invoices" table with the columns listed above. Add NocoDB API credentials in n8n. Configure SMTP credentials in n8n for email delivery. Run the one-time setup: Click Run Setup Once, then copy the document id from the Create Document output and paste it into the Build Bulk Items code node (replace YOUR_DOCUMENT_ID). Then disable the setup nodes. Tip: It is easier to create and edit templates directly in the Autype web editor. The built-in AI agent can generate a full template from a single prompt. Once saved, the document ID is in the URL, e.g. https://app.autype.com/document/a70a811d-a745-46f8-8eeb-bb9f2eb8cegb. Use the JSON/Markdown switch to inspect the document JSON, or the Bulk tab to check the expected variable structure. Note: This is a community node so it Requires a self-hosted n8n instance. Requirements Self-hosted n8n instance (community nodes are not available on n8n Cloud) Autype account with API key (free tier available, paid plan recommended for bulk rendering) n8n-nodes-autype community node installed NocoDB instance with API access SMTP server for email delivery How to customize Currency:** Change $ {{amountDue}} in the document JSON to any other symbol if needed. Output format:** Set document.type to docx or odt for Word or OpenDocument output. Data source:** The NocoDB node can be swapped for Google Sheets, Airtable, PostgreSQL, MySQL, or any other n8n data source. Just map the field names in the Code node. Document type:** Replace the payment reminder layout with invoices, contracts, certificates, or any other document. Update the template and variable mappings to match. Individual emails:** Use Split In Batches to loop over the output and send each PDF to the corresponding customer directly. Schedule:** Adjust the Schedule Trigger to run daily, monthly, or swap it for a webhook trigger. JSON syntax:** All available document elements are documented in the Autype JSON Syntax Reference. Post-processing:** The Autype Tools API supports watermarks, password protection, compression, merging, and format conversion.

How it works This workflow consolidates data from five different systems — Google Sheets, PostgreSQL, MongoDB, Microsoft SQL Server, and Google Analytics — into a single master Google Sheet. It runs on a scheduled trigger three times a week. Each dataset is tagged with a unique source identifier before merging, ensuring data traceability. Finally, the merged dataset is cleaned, standardized, and written into the output Google Sheet for reporting and analysis. Step-by-step 1. Trigger the workflow Schedule Trigger** – Runs the workflow at set weekly intervals. 2. Collect data from sources Google Sheets Source** – Retrieves records from a specific sheet. PostgreSQL Source** – Extracts customer data from the database. MongoDB Source** – Pulls documents from the defined collection. Microsoft SQL Server** – Executes a SQL query and returns results. Google Analytics** – Captures user activity and engagement metrics. 3. Tag each dataset Add Sheets Source ID** – Marks data from Google Sheets. Add PostgreSQL Source ID** – Marks data from PostgreSQL. Add MongoDB Source ID** – Marks data from MongoDB. Add SQL Server Source ID** – Marks data from SQL Server. Add Analytics Source ID** – Marks data from Google Analytics. 4. Merge and process Merge** – Combines all tagged datasets into a single structure. Process Merged Data** – Cleans, aligns schemas, and standardizes key fields. 5. Store consolidated output Final Google Sheet** – Appends or updates the master sheet with the processed data. Why use this? Centralizes multiple data sources into a single, consistent dataset. Ensures data traceability by tagging each source. Reduces manual effort in data cleaning and consolidation. Provides a reliable reporting hub for business analysis. Enables scheduled, automated updates for up-to-date visibility.

This automated n8n workflow enables the creation and management of AWS RDS databases through email interactions. Users can send emails with commands such as "Create RDS" or "Delete RDS," including details like database engine, instance class, and credentials. The workflow parses the email, uses Terraform to execute the requested action on AWS RDS, updates a Google Sheet with the status, and sends a confirmation email. Fundamental Aspects Gmail Trigger**: Initiates the workflow upon receiving a new email in Gmail. Parse Email Content**: Analyzes the email body to extract the command (create or delete) and database details like region, identifier, engine, and credentials. Manage RDS Instance**: Executes Terraform commands to create or delete the AWS RDS database instance based on the parsed details. Wait For Data**: Pauses the workflow to allow time for the RDS operation to complete and data to become available. Update Google Sheet**: Appends or updates the Google Sheet with the database instance details, status, and any relevant IDs. Send Confirmation Email**: Formats and sends a response email confirming the action taken, including success/failure details. Setup Instructions Import the Workflow into n8n**: Download the workflow JSON and import it via the n8n interface. Configure API Credentials**: Set up Gmail API credentials for email triggering and sending. Configure AWS credentials with RDS management permissions. Set up Google Sheets API credentials with read/write access. Ensure Terraform is integrated or nodes are configured for Terraform execution. Prepare Google Sheet**: Create a sheet with columns for database identifier, engine, instance class, status, and other relevant fields. Run the Workflow**: Activate the Gmail trigger and test by sending an email with a create or delete command. Verify Responses**: Check the Google Sheet for updates and your email for confirmation messages. Adjust Parameters**: Fine-tune Terraform variables, email parsing logic, or wait times as needed. Columns For The Google Sheet: Database Identifier: Unique identifier for the RDS instance (e.g., var.db_identifier). Engine: Database engine type (e.g., MySQL, PostgreSQL) (e.g., var.db_engine). Instance Class: RDS instance class (e.g., var.instance_class) (e.g., db.t3.micro). Allocated Storage: Storage size in GB (e.g., var.allocated_storage) (e.g., 20). Region: AWS region for the instance (e.g., var.aws_region) (e.g., us-east-1). Username: Database admin username (e.g., var.db_username) (e.g., admin). Password: Database admin password (e.g., var.db_password) (e.g., SecurePassword123). Status: Current status of the RDS instance (e.g., creating, deleted). Database Name: Name or tag for the database (e.g., var.db_name) (e.g., MyRDSDatabase). Technical Dependencies Gmail API**: For receiving trigger emails and sending confirmations. AWS RDS API**: For database management (via Terraform). Google Sheets API**: For logging and updating database status. Terraform**: For infrastructure-as-code management of RDS instances. n8n**: For workflow automation and node integrations. Customization Possibilities Support Additional Commands**: Extend to include update or snapshot operations for RDS instances. Enhance Parsing**: Improve email content analysis with AI for better intent detection. Add Database Engines**: Include support for more RDS engines like Oracle or SQL Server. Integrate Monitoring**: Add nodes to monitor RDS performance and alert via email. Customize Sheets**: Modify sheet columns or add visualizations for database metrics. Security Enhancements**: Incorporate additional validation for sensitive credentials in emails. Want a tailored workflow for your business? Our experts can craft it quickly Contact our team

Synchronize Excel or Google Sheets with Postgres (bi-directional) Who’s it for This workflow is perfect for companies that have always managed their operations in Excel or Google Sheets and want to gradually transition to using a database or custom software. It ensures business continuity while modernizing data management. How it works / What it does Trigger options → Run the sync manually, on schedule, or as part of another workflow. Get data from Excel → Reads rows from an Excel or Google Sheet table. Sanitize data → Cleans up formats (e.g., converting Excel serial dates into proper date strings). Upsert into Postgres → Inserts or updates rows in the database, ensuring no duplicates. For auto-mapping to work, the column names in Excel/Sheets and the DB must match exactly. If you want different names, you can manually map columns in the Postgres node. (Optional) → Can be extended to push DB updates back to Excel, creating a true two-way sync. This way, your team can continue working in Excel/Sheets while data is safely persisted in a database—ideal for scaling into dashboards, SaaS, or ERP systems later. How to set up Import the workflow JSON into your n8n instance. Connect your credentials: Microsoft Excel / Google Sheets OAuth2 Postgres database Point the Excel node to the right workbook, worksheet, and table. Make sure column names match between the Excel sheet and DB table (or map manually if they differ). Run manually or configure the schedule trigger for automated syncs. Requirements n8n self-hosted or cloud account. Either Microsoft Excel Online or Google Sheets access. Postgres database (or replace with MySQL, MariaDB, or any supported DB). How to customize the workflow Replace Excel with Google Sheets by swapping the node. Replace Postgres with any preferred database node. Add validation steps (e.g., check for missing emails, duplicate IDs). Extend with reporting workflows (e.g., sync DB data to BI dashboards). Use this as a stepping stone to migrate from spreadsheets into software-driven processes.

Quick overview This workflow receives first-reply LinkedIn webhook events from Aimfox, fetches the full conversation for context, uses OpenAI to classify lead intent and draft a short reply for interested leads, sends the reply back via Aimfox, and posts outcome notifications to Slack. How it works Receives a POST webhook from Aimfox when a prospect sends their first reply in a LinkedIn campaign. Extracts key event fields and fetches the full conversation thread from the Aimfox API. Reorders and aggregates the conversation messages into a single context string for the AI. Uses OpenAI to classify the latest prospect reply as INTERESTED, NOT_INTERESTED, or NEEDS_REVIEW. If INTERESTED, waits a random 3–15 minutes, then uses OpenAI to generate a concise, human-sounding LinkedIn reply using the full conversation context. Sends the generated reply to the prospect through the Aimfox API and posts a confirmation to a Slack channel with the message and LinkedIn profile link. If NOT_INTERESTED or NEEDS_REVIEW, posts the prospect’s reply to Slack so the team can close out or handle the conversation manually. Setup Create an Aimfox webhook that triggers on first reply and paste the n8n webhook URL into Aimfox. Add an Aimfox API credential (HTTP Header Auth) and confirm the account/recipient ID and conversation URN fields in the Aimfox API request URLs match your Aimfox payload. Add an OpenAI API key and review both OpenAI prompts to match your business, offer, and tone. Add Slack credentials and select the channel where you want “sent”, “not interested”, and “needs review” notifications posted.

Quick Overview This workflow ingests PDF cost-engineering manuals from Google Drive into a Pinecone vector index using OpenAI embeddings, then answers user questions via an n8n chat webhook using a retrieval-augmented OpenAI agent that responds only with evidence from the indexed documents. How it works Runs every 2 minutes on a schedule. Lists files in a configured Google Drive “incoming” folder and downloads each document. Extracts text from each PDF, splits it into overlapping chunks, and attaches document metadata. Generates OpenAI embeddings for the chunks and inserts them into the Pinecone rag index. Moves each successfully processed Google Drive file into a configured “ingested/archive” folder. Receives user questions through an n8n Chat webhook and uses a LangChain agent with a Pinecone retrieval tool plus an OpenAI chat model to answer strictly from retrieved passages (or returns the defined fallback message when evidence is missing). Setup Connect Google Drive credentials and replace RAG_INCOMING_FOLDER_ID and RAG_INGESTED_FOLDER_ID with your actual folder IDs. Add an OpenAI API key for both embedding generation and chat responses, and confirm the chat model selection (e.g., gpt-4.1-mini). Connect Pinecone credentials, ensure an index named rag exists, and match its embedding dimension to the OpenAI embeddings model you use. Upload your Technical Composition Manuals as PDFs to the Google Drive incoming folder. Enable the Chat trigger and copy its webhook URL into the client/app you use to send questions (or use n8n’s chat UI).

Quick Overview This workflow accepts resume submissions via webhook or a weekday schedule, extracts verifiable claims from the resume text, cross-checks them against GitHub and LinkedIn data, uses OpenAI to generate a verification report, calculates an authenticity score, logs results to Google Sheets, and emails a summary via SendGrid. How it works Triggers from an inbound webhook request or on a weekday cron schedule for batch verification. Normalizes incoming candidate data (ID, name, resume text, LinkedIn URL, GitHub username) and loads scoring weights and thresholds. Parses the resume text with Python to extract employment, education, skills, and certification claims and stops if no claims are found. Fetches public GitHub profile and repository data from the GitHub API and retrieves a public LinkedIn profile via a RapidAPI endpoint, with a short wait to reduce rate-limit risk. Aggregates GitHub and LinkedIn evidence and sends the extracted claims plus evidence to OpenAI to produce a structured JSON verification report. Computes category scores and an overall authenticity score and verdict, then appends the results to Google Sheets, emails a summary via SendGrid, and returns the full report in the webhook response. Setup Provide an OpenAI API credential for the LangChain agent node (or replace the model with your preferred provider). Replace the placeholder tokens/keys for the GitHub API and the RapidAPI LinkedIn endpoint (X-RapidAPI-Key and host) in the HTTP requests. Configure Google Sheets access by setting your spreadsheet ID and providing a valid Google OAuth access token (or switch to the Google Sheets node with OAuth credentials). Add your SendGrid API key and update the sender/recipient email addresses used for the verification summary. If using the webhook trigger, copy the production webhook URL for resume-verify-inbound and configure your ATS/form to POST candidateId, name, resumeText, linkedinUrl, githubUsername, and optional portfolioUrl.

Quick Overview This workflow ingests chat messages via a webhook or a 15-minute schedule, filters out low-signal content, uses Anthropic Claude to extract entities and relationships, and stores the resulting knowledge graph in Neo4j while appending an audit log row to Google Sheets. How it works Receives a chat message via an n8n webhook or runs every 15 minutes to process polled Slack data. Normalizes the incoming payload into consistent fields like channel, sender, timestamp, and message text. Uses a Python script to tag message signals (questions, decisions, action items) and filter out noise such as greetings, bots, and very short messages. Sends each relevant message to Anthropic Claude to extract entities, relationships, a summary, message type, and importance. Sends the extracted graph to Anthropic Claude again to add implicit relationships, weights, decision-chain metadata, and a thread category. Merges both AI passes into a single nodes-and-edges knowledge graph, validates references and edge weights, and drops invalid graphs. Upserts the graph into Neo4j via its transactional HTTP endpoint, appends an audit row to Google Sheets, and returns a JSON success response to the webhook caller. Setup Add an Anthropic API credential and select the Claude model used by the two AI steps. Configure Neo4j access by replacing the Neo4j HTTP endpoint URL and setting up HTTP Basic Auth credentials for your Neo4j instance. Configure Google Sheets OAuth2 credentials and replace the placeholder Google Sheet ID, sheet tab name/range (KnowledgeGraph), and any required API permissions. If using the webhook ingest path, copy the production webhook URL from n8n and configure your Slack/app integration to POST message payloads to /chat-ingest with the expected fields (text, channel, sender, timestamps).

Quick overview This workflow accepts a meeting transcript via an n8n form or webhook, uses Anthropic Claude to extract technical terms and acronyms into a JSON glossary, and then sends either the formatted glossary or a “nothing to add” confirmation to Telegram. How it works Receives a transcript either from an n8n form submission or from an HTTP POST webhook. Normalizes the incoming payload into consistent transcript and sessionId fields. Sends the full transcript to an Anthropic Claude chat model to extract distinct technical terms and short definitions as a strict JSON block. Parses the model’s JSON response into structured fields and checks whether any terms were found. Formats a numbered glossary message when terms exist and sends it to a Telegram chat. Sends a short “Nothing to add” message to Telegram when no relevant terms are found. Setup Add an Anthropic API credential and select the model in the Anthropic Claude chat model node. Create a Telegram bot, add Telegram credentials in n8n, and replace `` with your target Telegram chat ID in both Telegram send steps. If using the webhook trigger, copy the webhook URL and configure your transcription tool to POST JSON like { "transcript": "...", "sessionId": "optional" } to the post-call-glossary endpoint.

📄Template Creator Who is this for This template is built for legal professionals, operations teams, and agencies that work with recurring document types — contracts, NDAs, invoices, lease agreements, proposals — and want to stop rebuilding templates from scratch. If you have an OpenAI API key, a Google Drive account, and a self-hosted Gotenberg instance, you can turn any uploaded document into a clean, reusable fill-in-the-blank template in seconds. What it does The workflow accepts any uploaded PDF or DOCX file, uses a two-pass AI process to identify the document type and extract variable fields, replaces all variable content with labeled [BRACKET] placeholders, renders the result to PDF, and returns a shareable Google Drive link — fully automated from upload to delivery. How it works A Webhook Trigger receives the uploaded file (PDF or DOCX) from your form or API client and passes the binary content downstream for processing. Identify Document is a GPT-4o pass that reads the document and determines two things: the document type (e.g., Employment Contract, NDA, Lease Agreement, Project Proposal) and the specific variable fields that type of document typically contains. This classification step ensures the second pass has precise, context-aware instructions to work from. Templatize Document is a second GPT-4o pass that uses the identified document type and field list to replace all variable content — names, dates, amounts, addresses, party details — with clearly labeled [BRACKET] placeholders, while preserving all static boilerplate and document structure verbatim. Convert to PDF sends the finished template text to your self-hosted Gotenberg instance, which returns a clean, print-ready PDF — no third-party PDF service or API key required. Upload to Google Drive saves the PDF to your designated Drive folder and sets public link sharing, so the template is immediately accessible and shareable. Return Response delivers a JSON payload back to the caller containing the Google Drive file URL and any metadata, completing the webhook request. How to set up In Webhook Trigger, update the path if needed (default: general-template-creator). On both Identify Document and Templatize Document, select your OpenAI credential. In Upload to Google Drive, select your Google Drive credential and confirm the target folder ID. In Convert to PDF, update the Gotenberg base URL to match your self-hosted instance. Install the community node n8n-nodes-word2text for DOCX support (see the ⚠️ warning sticky in the workflow). Requirements OpenAI API key (GPT-4o used on both AI passes) Google Drive account with OAuth2 configured in n8n Self-hosted Gotenberg instance (for PDF rendering) Community node n8n-nodes-word2text installed on your n8n instance Self-hosted n8n** — required for community node support and Gotenberg integration A form or API client capable of POSTing a file to a webhook URL — a sample form is available for testing How to customize the workflow Reduce cost* — Swap GPT-4o for GPT-4.1-mini on the *Identify Document** node. The classification task is lightweight and the smaller model handles it reliably at lower cost. Type-specific prompts* — Add a Switch node after *Identify Document** to route different document types to specialized templatization prompts tuned for contracts, invoices, or proposals. Subfolder sorting* — Pass the identified document type into the Drive folder path in *Upload to Google Drive** to automatically sort output templates by document category. Additional output formats* — Add a parallel branch after *Templatize Document** to also save the raw template text to SharePoint, Airtable, or a Google Sheet for searchability. Batch processing** — Wrap the workflow in a loop trigger to process a folder of documents at once rather than one at a time via webhook. Visit automatedintelligentsolutions.com for more information and workflows.

How It Works This workflow automates academic research processing by routing queries through specialized AI models while maintaining contextual memory. Designed for researchers, faculty, and graduate students, it solves the challenge of managing multiple AI models for different research tasks while preserving conversation context across sessions. The system accepts research queries via webhook, stores them in vector databases for semantic search, and intelligently routes requests to appropriate AI models (OpenAI, Anthropic Claude, or NVIDIA NIM). Results are consolidated, formatted, and delivered via email with full citation tracking. The workflow maintains conversation history using Pinecone vector storage, enabling follow-up queries that reference previous interactions. This eliminates manual model switching, context loss, and repetitive credential management—streamlining research workflows from literature review to hypothesis generation. Setup Steps Configure Pinecone credentials Add OpenAI API key for GPT-4 access and embeddings Set up Anthropic Claude API credentials for advanced reasoning Configure NVIDIA NIM API key for specialized academic models Connect Google Sheets for query logging and result tracking Set Gmail OAuth credentials for automated result delivery Configure webhook URL for query submission endpoint Prerequisites Active accounts and API keys for Pinecone, OpenAI Use Cases Literature review automation with semantic paper discovery. Customization Modify AI model selection logic for domain-specific optimization. Benefits Reduces research processing time by 60% through automated routing.