Building AI Automations with GPT-4

Artificial Intelligence has moved from experimental to essential. GPT-4 represents a breakthrough in language understanding and generation, opening unprecedented opportunities for business automation.

The Power of GPT-4 in Business Automation

GPT-4's advanced language capabilities make it ideal for automating complex tasks that previously required human intelligence:

• Document Understanding: Extract insights from contracts, reports, and emails
• Customer Support: Provide intelligent, context-aware responses 24/7
• Content Generation: Create personalized marketing copy, reports, and documentation
• Data Analysis: Transform unstructured data into actionable insights
• Workflow Orchestration: Coordinate multi-step business processes

Real-World Implementation Patterns

1. Intelligent Document Processing

import OpenAI from 'openai';

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

async function processInvoice(invoiceText: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: 'You are an expert at extracting structured data from invoices.',
      },
      {
        role: 'user',
        content: `Extract invoice details from this text: ${invoiceText}`,
      },
    ],
    functions: [
      {
        name: 'extract_invoice_data',
        description: 'Extract structured invoice data',
        parameters: {
          type: 'object',
          properties: {
            invoice_number: { type: 'string' },
            date: { type: 'string' },
            total_amount: { type: 'number' },
            vendor: { type: 'string' },
            line_items: {
              type: 'array',
              items: {
                type: 'object',
                properties: {
                  description: { type: 'string' },
                  quantity: { type: 'number' },
                  price: { type: 'number' },
                },
              },
            },
          },
          required: ['invoice_number', 'date', 'total_amount', 'vendor'],
        },
      },
    ],
    function_call: { name: 'extract_invoice_data' },
  });

  return JSON.parse(response.choices[0].message.function_call?.arguments || '{}');
}

2. Context-Aware Customer Support

Building a customer support bot that maintains conversation context:

interface Message {
  role: 'system' | 'user' | 'assistant';
  content: string;
}

class CustomerSupportBot {
  private conversationHistory: Message[] = [];

  constructor(systemPrompt: string) {
    this.conversationHistory.push({
      role: 'system',
      content: systemPrompt,
    });
  }

  async sendMessage(userMessage: string): Promise<string> {
    this.conversationHistory.push({
      role: 'user',
      content: userMessage,
    });

    const response = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: this.conversationHistory,
      temperature: 0.7,
      max_tokens: 500,
    });

    const assistantMessage = response.choices[0].message.content || '';

    this.conversationHistory.push({
      role: 'assistant',
      content: assistantMessage,
    });

    return assistantMessage;
  }
}

3. Smart Email Classification and Routing

async function classifyEmail(emailContent: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: 'Classify emails into categories: sales, support, billing, technical, general.',
      },
      {
        role: 'user',
        content: emailContent,
      },
    ],
    functions: [
      {
        name: 'classify_email',
        parameters: {
          type: 'object',
          properties: {
            category: {
              type: 'string',
              enum: ['sales', 'support', 'billing', 'technical', 'general'],
            },
            priority: {
              type: 'string',
              enum: ['low', 'medium', 'high', 'urgent'],
            },
            sentiment: {
              type: 'string',
              enum: ['positive', 'neutral', 'negative'],
            },
            suggested_action: { type: 'string' },
          },
        },
      },
    ],
    function_call: { name: 'classify_email' },
  });

  return JSON.parse(response.choices[0].message.function_call?.arguments || '{}');
}

Best Practices for Production Systems

1. Error Handling & Retries

Always implement robust error handling:

async function callGPT4WithRetry(
  messages: Message[],
  maxRetries = 3
): Promise<string> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await openai.chat.completions.create({
        model: 'gpt-4',
        messages,
      });
      return response.choices[0].message.content || '';
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
    }
  }
  throw new Error('Max retries exceeded');
}

2. Cost Management

Monitor and optimize API costs:

• Use GPT-3.5-turbo for simpler tasks
• Implement caching for repeated queries
• Set appropriate max_tokens limits
• Use streaming for long responses

3. Security Considerations

• Never expose API keys client-side
• Implement rate limiting
• Validate and sanitize all inputs
• Use function calling for structured outputs
• Implement content filtering

Performance Optimization Strategies

Caching Frequent Queries

import { Redis } from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);

async function getCachedCompletion(prompt: string): Promise<string> {
  const cacheKey = `gpt4:${hashString(prompt)}`;

  // Check cache
  const cached = await redis.get(cacheKey);
  if (cached) return cached;

  // Call GPT-4
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: prompt }],
  });

  const result = response.choices[0].message.content || '';

  // Cache for 24 hours
  await redis.setex(cacheKey, 86400, result);

  return result;
}

Streaming Responses

For better UX, stream responses in real-time:

async function streamCompletion(prompt: string) {
  const stream = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: prompt }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content || '';
    process.stdout.write(content);
  }
}

Real-World Use Cases

E-Commerce Product Descriptions

Automatically generate SEO-optimized product descriptions:

async function generateProductDescription(product: {
  name: string;
  features: string[];
  category: string;
}) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: 'Write compelling, SEO-optimized product descriptions.',
      },
      {
        role: 'user',
        content: `Product: ${product.name}\nCategory: ${product.category}\nFeatures: ${product.features.join(', ')}`,
      },
    ],
  });

  return response.choices[0].message.content;
}

Legal Document Analysis

Extract key clauses from contracts:

async function analyzeContract(contractText: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: 'Extract key terms, obligations, and risks from legal contracts.',
      },
      {
        role: 'user',
        content: contractText,
      },
    ],
  });

  return response.choices[0].message.content;
}

Conclusion

GPT-4 automation represents a paradigm shift in how businesses operate. By following these patterns and best practices, you can build robust, scalable AI systems that deliver real value.

Key Takeaways

1. Start with high-value, repetitive tasks
2. Implement proper error handling and monitoring
3. Optimize costs through caching and model selection
4. Prioritize security and data privacy
5. Use function calling for structured outputs
6. Stream responses for better UX

Ready to build your own AI automation? Contact us to discuss your project.