Influencing LLMs for Brand Visibility: Complete Guide to AI-Powered SEO in 2025

// LLM Brand Monitoring System
import OpenAI from 'openai';
import { Anthropic } from '@anthropic-ai/sdk';

class LLMBrandMonitor {
  constructor(config) {
    this.openai = new OpenAI({ apiKey: config.openaiKey });
    this.anthropic = new Anthropic({ apiKey: config.anthropicKey });
    this.brandName = config.brandName;
    this.competitors = config.competitors || [];
    this.testQueries = config.testQueries || [];
  }

  async testChatGPT(query) {
    try {
      const response = await this.openai.chat.completions.create({
        model: "gpt-4",
        messages: [{ role: "user", content: query }],
        temperature: 0.1
      });
      
      const content = response.choices[0].message.content;
      return this.analyzeResponse(content, query, 'chatgpt');
    } catch (error) {
      console.error('ChatGPT API Error:', error);
      return null;
    }
  }

  async testClaude(query) {
    try {
      const response = await this.anthropic.messages.create({
        model: "claude-3-sonnet-20240229",
        max_tokens: 1000,
        messages: [{ role: "user", content: query }]
      });
      
      const content = response.content[0].text;
      return this.analyzeResponse(content, query, 'claude');
    } catch (error) {
      console.error('Claude API Error:', error);
      return null;
    }
  }

  analyzeResponse(content, query, platform) {
    const lowerContent = content.toLowerCase();
    const lowerBrand = this.brandName.toLowerCase();
    
    // Check brand mention
    const brandMentioned = lowerContent.includes(lowerBrand);
    
    // Find position of brand mention
    let brandPosition = -1;
    if (brandMentioned) {
      const sentences = content.split(/[.!?]+/);
      for (let i = 0; i < sentences.length; i++) {
        if (sentences[i].toLowerCase().includes(lowerBrand)) {
          brandPosition = i + 1;
          break;
        }
      }
    }
    
    // Check competitor mentions
    const competitorMentions = this.competitors.filter(comp => 
      lowerContent.includes(comp.toLowerCase())
    );
    
    return {
      query,
      platform,
      brandMentioned,
      brandPosition,
      competitorMentions,
      responseLength: content.length,
      timestamp: new Date().toISOString(),
      fullResponse: content
    };
  }

  async runFullAudit() {
    const results = [];
    
    for (const query of this.testQueries) {
      console.log(`Testing query: ${query}`);
      
      const [chatgptResult, claudeResult] = await Promise.all([
        this.testChatGPT(query),
        this.testClaude(query)
      ]);
      
      if (chatgptResult) results.push(chatgptResult);
      if (claudeResult) results.push(claudeResult);
      
      // Rate limiting
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
    
    return this.generateReport(results);
  }

  generateReport(results) {
    const totalTests = results.length;
    const brandMentions = results.filter(r => r.brandMentioned).length;
    const citationRate = (brandMentions / totalTests) * 100;
    
    const platformStats = {};
    results.forEach(result => {
      if (!platformStats[result.platform]) {
        platformStats[result.platform] = {
          total: 0,
          mentions: 0,
          averagePosition: 0
        };
      }
      
      platformStats[result.platform].total++;
      if (result.brandMentioned) {
        platformStats[result.platform].mentions++;
        platformStats[result.platform].averagePosition += result.brandPosition;
      }
    });
    
    // Calculate average positions
    Object.keys(platformStats).forEach(platform => {
      const stats = platformStats[platform];
      if (stats.mentions > 0) {
        stats.averagePosition = stats.averagePosition / stats.mentions;
        stats.citationRate = (stats.mentions / stats.total) * 100;
      }
    });
    
    return {
      summary: {
        totalTests,
        brandMentions,
        citationRate: citationRate.toFixed(1)
      },
      platformStats,
      detailedResults: results,
      generatedAt: new Date().toISOString()
    };
  }
}

// Usage example
const monitor = new LLMBrandMonitor({
  openaiKey: process.env.OPENAI_API_KEY,
  anthropicKey: process.env.ANTHROPIC_API_KEY,
  brandName: "YourBrand",
  competitors: ["Competitor1", "Competitor2", "Competitor3"],
  testQueries: [
    "What are the best SEO tools for enterprises?",
    "Which companies provide technical SEO services?",
    "Recommend software for content optimization",
    "Best programmatic SEO platforms",
    "Top agentic SEO workflow tools"
  ]
});

// Run monitoring
monitor.runFullAudit().then(report => {
  console.log('Brand Visibility Report:', report);
});