ChatGPT Use Cases for SaaS

You are a helpful customer support agent for [Your SaaS Product]. 

Your knowledge base includes:
- Product features and how to use them
- Common troubleshooting steps
- Pricing and billing information
- Integration guides

Instructions:
1. Always be friendly, professional, and helpful
2. If you don't know something, say "I'll connect you with a team member who can help"
3. Provide step-by-step solutions when troubleshooting
4. Ask clarifying questions if the issue is unclear
5. End responses with "Is there anything else I can help you with?"

Customer question: [CUSTOMER_QUESTION]

// Example using OpenAI API
import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
})

async function handleSupportQuery(userQuestion: string, conversationHistory: any[]) {
  const systemPrompt = `You are a helpful customer support agent...`
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "system", content: systemPrompt },
      ...conversationHistory,
      { role: "user", content: userQuestion }
    ],
    temperature: 0.7,
    max_tokens: 500
  })
  
  return completion.choices[0].message.content
}

Generate a personalized onboarding email for a new user.

User profile:
- Name: [USER_NAME]
- Company: [COMPANY_NAME]
- Role: [USER_ROLE]
- Plan: [SUBSCRIPTION_PLAN]
- Signup date: [SIGNUP_DATE]
- Features they've used: [FEATURES_USED]
- Features they haven't explored: [UNUSED_FEATURES]

Email requirements:
- Subject line (compelling, personalized)
- Greeting (use their name)
- Acknowledge what they've already done
- Highlight 2-3 features they should try next (based on role)
- Include clear CTAs
- Keep tone friendly and encouraging
- Length: 150-200 words

Generate email:

// Dynamic email generation
async function generateOnboardingEmail(user: User) {
  const prompt = `Generate a personalized onboarding email...
  
  User profile:
  - Name: ${user.name}
  - Role: ${user.role}
  - Plan: ${user.plan}
  - Used features: ${user.usedFeatures.join(', ')}
  - Unused features: ${user.unusedFeatures.join(', ')}
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.8
  })
  
  return completion.choices[0].message.content
}

Write an SEO-optimized blog post for a SaaS company.

Topic: [TOPIC]
Primary keyword: [PRIMARY_KEYWORD]
Secondary keywords: [SECONDARY_KEYWORDS]
Target audience: [AUDIENCE]
Word count: [WORD_COUNT]

Requirements:
- Compelling H1 title (include primary keyword)
- Meta description (150-160 characters)
- Introduction hook (2-3 paragraphs)
- 5-7 H2 sections with actionable content
- Include bullet points and numbered lists
- Add internal linking opportunities [link]
- Conversational, helpful tone
- Include 1-2 CTAs naturally
- Conclusion with clear next step

Write the blog post:

// SEO content generation
async function generateSEOContent(params: {
  topic: string
  primaryKeyword: string
  secondaryKeywords: string[]
  audience: string
  wordCount: number
}) {
  const prompt = `Write an SEO-optimized blog post...
  
  Topic: ${params.topic}
  Primary keyword: ${params.primaryKeyword}
  Target: ${params.audience}
  Word count: ${params.wordCount}
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.7,
    max_tokens: 2000
  })
  
  return completion.choices[0].message.content
}

Generate comprehensive documentation for this code.

Code:
```
[YOUR_CODE]
```

Include:
1. Overview (what it does)
2. Parameters (name, type, description, required/optional)
3. Return value (type and description)
4. Usage examples (2-3 scenarios)
5. Error handling
6. Notes and best practices
7. Related functions/methods

Format as Markdown with clear sections.

// Auto-generate documentation
async function generateDocs(code: string, language: string) {
  const prompt = `Generate comprehensive documentation for this ${language} code:
  
  \`\`\`${language}
  ${code}
  \`\`\`
  
  Include overview, parameters, return value, examples, and best practices.
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.3 // Lower temperature for technical accuracy
  })
  
  return completion.choices[0].message.content
}

Analyze this collection of user feedback and provide insights.

User Feedback:
[FEEDBACK_LIST]

Please provide:
1. **Sentiment Analysis**: Overall sentiment (Positive/Neutral/Negative) with percentage breakdown
2. **Common Themes**: Top 5 themes mentioned across feedback
3. **Feature Requests**: List specific features users are requesting
4. **Pain Points**: Main problems or frustrations users are experiencing
5. **Urgent Issues**: Critical issues that need immediate attention
6. **Opportunities**: Suggestions for product improvements
7. **Priority Ranking**: Rank issues by frequency and impact

Format as a structured report with clear sections.

// Batch feedback analysis
async function analyzeFeedback(feedbackList: string[]) {
  const combinedFeedback = feedbackList.join('\n---\n')
  
  const prompt = `Analyze this user feedback and provide insights...
  
  User Feedback:
  ${combinedFeedback}
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.5
  })
  
  return completion.choices[0].message.content
}

Generate a personalized sales email reply.

Prospect Information:
- Name: [PROSPECT_NAME]
- Company: [COMPANY_NAME]
- Industry: [INDUSTRY]
- Company size: [SIZE]
- Pain point mentioned: [PAIN_POINT]

Previous conversation:
[CONVERSATION_HISTORY]

Latest prospect message:
"[PROSPECT_MESSAGE]"

Requirements:
- Address their specific question/concern
- Reference their industry/use case
- Include a relevant success story or social proof
- Propose clear next steps
- Keep it under 150 words
- Tone: Professional but conversational
- End with a specific CTA (call/demo/meeting)

Generate reply:

// Contextualized sales replies
async function generateSalesReply(params: {
  prospectName: string
  company: string
  industry: string
  painPoint: string
  conversationHistory: string
  latestMessage: string
}) {
  const prompt = `Generate a personalized sales email reply...
  
  Prospect: ${params.prospectName} from ${params.company} (${params.industry})
  Pain point: ${params.painPoint}
  
  Previous conversation:
  ${params.conversationHistory}
  
  Latest message: "${params.latestMessage}"
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.8
  })
  
  return completion.choices[0].message.content
}

You are a semantic search assistant. When a user asks a question, search through the knowledge base and return the most relevant information.

Knowledge Base:
[YOUR_KNOWLEDGE_BASE]

User Query: [USER_QUERY]

Instructions:
1. Understand the intent behind the query (not just keywords)
2. Find the most relevant information from the knowledge base
3. Provide a direct answer based on the docs
4. Include the source document reference
5. If no relevant info found, say so clearly

Response format:
**Answer:** [Direct answer]
**Source:** [Document name/section]
**Related Topics:** [2-3 related articles]

// Semantic search with embeddings
import OpenAI from 'openai'

const openai = new OpenAI()

async function semanticSearch(query: string, documents: string[]) {
  // 1. Create embedding for user query
  const queryEmbedding = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: query
  })
  
  // 2. Find most similar documents (using vector db like Pinecone)
  const results = await vectorDB.query({
    vector: queryEmbedding.data[0].embedding,
    topK: 3
  })
  
  // 3. Generate answer using relevant docs
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "system", content: "Answer based on these docs: " + results.matches },
      { role: "user", content: query }
    ]
  })
  
  return completion.choices[0].message.content
}

Review this content/process for compliance issues.

Compliance Standard: [GDPR/HIPAA/SOC2/etc]
Content Type: [Privacy Policy/Code/Process/etc]

Content to Review:
[CONTENT]

Please provide:
1. **Compliance Status**: Overall assessment (Compliant/Issues Found/Critical Issues)
2. **Issues Identified**: List specific compliance issues found
3. **Severity Levels**: Critical/High/Medium/Low for each issue
4. **Recommendations**: Specific steps to fix each issue
5. **Best Practices**: Additional suggestions for better compliance
6. **Required Changes**: Exact text/code changes needed

Format as a structured report.

// Compliance checking
async function checkCompliance(
  content: string,
  standard: 'GDPR' | 'HIPAA' | 'SOC2'
) {
  const prompt = `Review this content for ${standard} compliance...
  
  Content:
  ${content}
  
  Identify issues, severity, and provide specific recommendations.
  `
  
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.2 // Lower temp for accuracy
  })
  
  return completion.choices[0].message.content
}