PII-Safe Help Docs from Crisp Chat

What This Agent Does

This Customer Support Documentation Agent automatically transforms customer support conversations into comprehensive help documentation. By capturing resolved support tickets, extracting key Q&A pairs, and leveraging AI to generate polished documentation, this workflow eliminates manual documentation work while ensuring your knowledge base stays current and accurate.

The agent listens for incoming support conversations via webhook, determines if issues are resolved, retrieves the full conversation history, and uses OpenAI's GPT-4o-mini model to intelligently synthesize customer questions and support responses into professional help documents. These documents are then automatically stored in your spreadsheet for easy access and distribution.

Key Benefits:

• Reduce documentation time by 80% – Automate the conversion of support conversations into polished help articles
• Keep knowledge bases current – New documentation is generated in real-time as issues are resolved
• Improve customer self-service – Empower customers to find answers without contacting support
• Maintain consistency – AI-generated documentation follows a standardized format every time
• Capture institutional knowledge – Preserve valuable support insights that might otherwise be lost

Target Use Cases:

• SaaS companies managing high-volume support tickets
• Product teams building comprehensive knowledge bases
• Support teams looking to reduce repetitive questions
• Organizations scaling customer success operations

Who Is It For

This workflow is ideal for support teams, product managers, and customer success leaders who want to:

• Automate knowledge base creation from real customer interactions
• Reduce the burden on support staff for documentation tasks
• Build searchable, organized help documentation at scale
• Ensure new team members have access to comprehensive support resources
• Track common customer pain points through documentation patterns

You'll get the most value if you're handling 10+ support conversations daily and currently spend time manually documenting solutions.

Required Integrations

Spreadsheet Integration

Why It's Needed: Your spreadsheet serves as the central repository for both conversation history and generated help documentation. This integration allows the workflow to retrieve existing support conversations and store newly created help articles in an organized, searchable format.

Setup Steps:

1. Connect your spreadsheet provider (Google Sheets, Excel Online, or Airtable)

   • Navigate to TaskAGI's Integrations panel
   • Search for your spreadsheet provider
   • Click Connect and authorize access

2. Create or identify your support conversation sheet

   • Ensure your spreadsheet has columns for: Conversation_ID, Customer_Question, Support_Response, Status, Timestamp
   • Example structure:

     | Conversation_ID | Customer_Question | Support_Response | Status | Timestamp |
     |---|---|---|---|---|
     | CONV-001 | How do I reset my password? | Click Settings > Security... | Resolved | 2024-01-15 |
     

3. Create a help documentation sheet

   • Add columns: Doc_ID, Title, Content, Category, Created_Date, Source_Conversation_ID
   • This is where generated help articles will be stored

4. Obtain your spreadsheet credentials

   • Google Sheets: Your sheet URL (found in the browser address bar)
   • Excel Online: Your workbook URL and sheet name
   • Airtable: Your base ID and API key (found in Account Settings > API)

5. Configure in TaskAGI

   • In the spreadsheet integration settings, paste your credentials
   • Select the conversation sheet for the "Get Session Messages" node
   • Select the documentation sheet for the "Store Help Doc" node
   • Test the connection by clicking Verify

OpenAI Integration

Why It's Needed: OpenAI's GPT-4o-mini model intelligently analyzes customer support conversations and generates professional, well-structured help documentation. This is the "brain" that transforms raw conversations into polished articles.

Setup Steps:

1. Create an OpenAI account (if you don't have one)

   • Visit platform.openai.com
   • Sign up or log in with your existing account

2. Generate an API key

   • Click your profile icon (bottom left)
   • Select API keys
   • Click Create new secret key
   • Copy the key immediately (you won't see it again)
   • Store it securely (use a password manager)

3. Set up billing

   • Go to Billing > Overview
   • Add a payment method
   • Set usage limits to control costs (recommended: $10-20/month for testing)
   • Note: GPT-4o-mini is one of the most cost-effective models (~$0.15 per 1M input tokens)

4. Configure in TaskAGI

   • Navigate to Integrations > OpenAI
   • Click Connect
   • Paste your API key
   • Click Verify to confirm the connection
   • You should see a success message with your account details

5. Monitor usage

   • Check TaskAGI's integration dashboard for API call counts
   • Review OpenAI's usage dashboard monthly to track costs

Configuration Steps

Step 1: Webhook Trigger Setup (Crisp Webhook)

The webhook is your workflow's entry point. It receives incoming support conversation data.

Configuration:

• Webhook URL: TaskAGI automatically generates this when you create the workflow
• Copy the webhook URL from the trigger node
• Paste it into your support system (Crisp, Zendesk, Intercom, etc.) as an outgoing webhook
• Trigger event: Set to fire when a conversation is marked as "Resolved"
• Expected payload: Should include conversation_id, messages[], customer_name, status

Example webhook payload:

{
  "conversation_id": "CONV-12345",
  "status": "resolved",
  "messages": [
    {"role": "customer", "text": "How do I export my data?"},
    {"role": "agent", "text": "Go to Settings > Data Export..."}
  ]
}

Step 2: Check If Resolved (Conditional Logic)

This node ensures the workflow only processes conversations that are actually resolved, preventing incomplete conversations from generating documentation.

Configuration:

• Condition: status == "resolved"
• True path: Proceeds to retrieve full conversation history
• False path: Stops processing (no documentation generated)

Why this matters: Prevents generating incomplete or inaccurate help docs from ongoing conversations.

Step 3: Get Session Messages (Spreadsheet Query)

Retrieves the complete conversation history from your spreadsheet.

Configuration:

• Sheet: Select your conversation history sheet
• Query type: Filter by Conversation_ID
• Filter value: {{ webhook.conversation_id }}
• Return columns: Customer_Question, Support_Response, Timestamp
• Sort by: Timestamp (ascending)

What this does: Pulls all messages for the specific conversation so the AI can see the full context.

Step 4: Insert Chat Message (First Spreadsheet Insert)

Logs the incoming conversation to your spreadsheet for record-keeping.

Configuration:

• Sheet: Your conversation history sheet
• Data to insert:
  • Conversation_ID: {{ webhook.conversation_id }}
  • Customer_Question: {{ webhook.messages[0].text }}
  • Support_Response: {{ webhook.messages[-1].text }}
  • Status: {{ webhook.status }}
  • Timestamp: {{ now() }}

Step 5: Format Q&A Pairs (Function Node)

Transforms raw conversation messages into clean, structured Q&A pairs for the AI to process.

Configuration:

• Function type: JavaScript or Python
• Input: {{ step3.data }} (messages from spreadsheet query)
• Processing logic:

  const messages = input.messages;
  const qaPairs = [];
  
  for (let i = 0; i < messages.length; i += 2) {
    if (messages[i] && messages[i+1]) {
      qaPairs.push({
        question: messages[i].text,
        answer: messages[i+1].text
      });
    }
  }
  
  return { qa_pairs: qaPairs };
  

• Output: Structured array of Q&A pairs

Step 6: Generate Help Doc (OpenAI Completion)

The core AI node that creates professional documentation.

Configuration:

• Model: gpt-4o-mini
• Prompt template:

  Based on the following customer support conversation, create a professional help document:
  
  Q&A Pairs:
  {{ step5.qa_pairs }}
  
  Generate a help article with:
  1. Clear title (based on the main question)
  2. Brief introduction
  3. Step-by-step solution
  4. Tips and best practices
  5. Related topics
  
  Format as markdown.
  

• Temperature: 0.7 (balanced creativity and consistency)
• Max tokens: 1000
• Top P: 0.9

Example output:

# How to Export Your Data

## Overview
Exporting your data allows you to download all your information...

## Steps
1. Log in to your account
2. Navigate to Settings > Data Export
3. Select your export format...

Step 7: Store Help Doc (Second Spreadsheet Insert)

Saves the generated documentation to your help article repository.

Configuration:

• Sheet: Your help documentation sheet
• Data to insert:
  • Doc_ID: {{ generateId() }}
  • Title: Extract from generated doc (first heading)
  • Content: {{ step6.output }}
  • Category: Auto-generated
  • Created_Date: {{ now() }}
  • Source_Conversation_ID: {{ webhook.conversation_id }}

Testing Your Agent

Test Execution

1. Trigger a test webhook

   • In TaskAGI, click Test on the Crisp Webhook node
   • Use sample payload:

     {
       "conversation_id": "TEST-001",
       "status": "resolved",
       "messages": [
         {"role": "customer", "text": "How do I change my password?"},
         {"role": "agent", "text": "Click Settings > Security > Change Password"}
       ]
     }
     

2. Monitor execution

   • Watch the workflow progress through each node
   • Check for green checkmarks (success) or red X's (errors)

Verification Checklist

• ✅ Webhook trigger: Receives payload without errors
• ✅ Condition check: Correctly identifies resolved status
• ✅ Spreadsheet query: Retrieves conversation history
• ✅ Message insertion: Logs conversation to spreadsheet
• ✅ Q&A formatting: Structures questions and answers properly
• ✅ OpenAI generation: Creates readable, professional documentation
• ✅ Documentation storage: Help article appears in your documentation sheet

Expected Results

• Execution time: 15-30 seconds per conversation
• Documentation quality: Professional, well-formatted markdown articles
• Spreadsheet entries: New rows appear in both conversation and documentation sheets
• No errors: All nodes complete with success status

Success indicator: A new help article appears in your documentation sheet within 30 seconds of triggering the workflow, with a clear title, structured content, and proper formatting.