Multi-Agent Orchestration Platform

1@Injectable()
2export class AiService {
3  private readonly logger = new Logger(AiService.name);
4  private openai: OpenAIApi;
5
6  constructor(private configService: ConfigService) {
7    const apiKey = this.configService.get<string>('OPENAI_API_KEY');
8    const configuration = new Configuration({ apiKey });
9    this.openai = new OpenAIApi(configuration);
10  }
11
12  /**
13   * Generate a completion using the OpenAI API
14   */
15  async generateCompletion(prompt: string, params: Record<string, any> = {}): Promise<string> {
16    // Replace template variables in the prompt
17    let processedPrompt = prompt;
18    for (const [key, value] of Object.entries(params)) {
19      const placeholder = `{{${key}}}`;
20      if (typeof value === 'string') {
21        processedPrompt = processedPrompt.replace(new RegExp(placeholder, 'g'), value);
22      } else if (Array.isArray(value)) {
23        processedPrompt = processedPrompt.replace(new RegExp(placeholder, 'g'), value.join(', '));
24      }
25    }
26
27    const response = await this.openai.createCompletion({
28      model: 'gpt-4',
29      prompt: processedPrompt,
30      max_tokens: 2000,
31      temperature: 0.7,
32    });
33
34    return response.data.choices[0].text.trim();
35  }
36}

1@Injectable()
2export class PRService {
3  constructor(
4    @InjectModel(PRPitch.name) private prPitchModel: Model<PRPitchDocument>,
5    private aiService: AiService,
6    private journalistService: JournalistService,
7    private webSocketService: WebSocketService,
8  ) {}
9
10  /**
11   * Send a PR pitch with A/B testing
12   */
13  async sendPitch(id: number): Promise<PRPitchDocument> {
14    const pitch = await this.findOne(id);
15    const journalist = await this.journalistService.findOne(pitch.journalistId);
16    
17    // Randomly select variant A or B for this recipient
18    const variant = Math.random() > 0.5 ? 'A' : 'B';
19    const subjectLine = variant === 'A' ? pitch.subjectLineA : pitch.subjectLineB;
20    const content = variant === 'A' ? pitch.contentA : pitch.contentB;
21    
22    // Update pitch status and send real-time update via WebSocket
23    pitch.status = 'sent';
24    const savedPitch = await pitch.save();
25    
26    this.webSocketService.sendPRUpdate({
27      action: 'pitch_sent',
28      pitch: { id: savedPitch._id, variant, timestamp: new Date().toISOString() }
29    });
30    
31    return savedPitch;
32  }
33
34  /**
35   * Track email open for A/B test analysis
36   */
37  async trackOpen(id: number, variant: 'A' | 'B'): Promise<PRPitchDocument> {
38    const pitch = await this.findOne(id);
39    variant === 'A' ? pitch.opensA += 1 : pitch.opensB += 1;
40    
41    // Real-time dashboard update
42    this.webSocketService.sendABTestUpdate({
43      action: 'variant_opened',
44      pitch: { id, variant, opensA: pitch.opensA, opensB: pitch.opensB }
45    });
46    
47    return pitch.save();
48  }
49}

1@Injectable()
2export class SentimentService {
3  private distilBertModel: any;
4  private isModelLoaded: boolean = false;
5
6  constructor(
7    @InjectModel(SentimentAnalysis.name) private sentimentAnalysisModel: Model<SentimentAnalysisDocument>,
8    private aiService: AiService,
9    private userSettingsService: UserSettingsService,
10  ) {
11    this.initializeModels();
12  }
13
14  /**
15   * Analyze text sentiment using preferred model (DistilBERT or GPT-4)
16   */
17  async analyzeSentiment(userId: string, dto: CreateSentimentAnalysisDto): Promise<SentimentAnalysisResponseDto> {
18    const userSettings = await this.userSettingsService.getUserSettings(userId);
19    const preferredModel = dto.preferredModel || userSettings?.preferredSentimentModel || SentimentModel.DISTILBERT;
20    
21    const sentimentAnalysis = new this.sentimentAnalysisModel({
22      userId,
23      content: dto.content,
24      modelUsed: preferredModel,
25      isProcessed: false,
26    });
27    
28    const savedAnalysis = await sentimentAnalysis.save();
29    
30    // Process asynchronously - hybrid DistilBERT + GPT-4 approach
31    this.processSentimentAnalysis(savedAnalysis._id, preferredModel);
32    
33    return this.mapToResponseDto(savedAnalysis);
34  }
35
36  /**
37   * Check if sentiment change warrants an alert
38   */
39  private async checkForSentimentAlert(analysis: SentimentAnalysisDocument): Promise<void> {
40    const previousAnalyses = await this.sentimentAnalysisModel
41      .find({ userId: analysis.userId, source: analysis.source })
42      .sort({ createdAt: -1 }).limit(5);
43    
44    const avgPreviousScore = previousAnalyses.reduce((sum, a) => sum + a.score, 0) / previousAnalyses.length;
45    const changeMagnitude = Math.abs(analysis.score - avgPreviousScore);
46    
47    if (changeMagnitude >= this.alertThreshold) {
48      await this.createSentimentAlert(analysis.userId, {
49        title: 'Significant sentiment change detected',
50        severity: changeMagnitude >= 0.7 ? AlertSeverity.CRITICAL : AlertSeverity.MEDIUM,
51        recommendedActions: this.generateRecommendedActions(analysis, changeMagnitude)
52      });
53    }
54  }
55}

1// AI Queue Producer - Async job processing
2@Injectable()
3export class AiQueueProducer {
4  constructor(@InjectQueue('ai-queue') private queue: Queue) {}
5
6  async generateSocialMediaContent(params: SocialMediaContentParams, priority: number = 2) {
7    const job = await this.queue.add(
8      AiJobType.CONTENT_GENERATION,
9      { params },
10      { 
11        priority,
12        attempts: 3,
13        backoff: { type: 'exponential', delay: 5000 },
14      },
15    );
16    return job.id;
17  }
18}
19
20// AI Queue Consumer - Process jobs with retry logic
21@Processor('ai-queue')
22export class AiQueueConsumer {
23  constructor(private readonly aiService: AiService) {}
24
25  @Process(AiJobType.CONTENT_GENERATION)
26  async processContentGeneration(job: Job) {
27    this.logger.log(`Processing content generation job ${job.id}`);
28    try {
29      return await this.aiService.generateSocialMediaContent(job.data.params);
30    } catch (error) {
31      this.logger.error(`Error in job ${job.id}: ${error.message}`);
32      throw error; // Triggers retry with exponential backoff
33    }
34  }
35}