aiTrainingService.ts•12.7 kB
import { chickenMemoryService } from './chickenMemoryService.js';
import { chickenBusinessAI } from './chickenBusinessAI.js';
import { unifiedAIService } from './unifiedAIService.js';
export interface TrainingData {
id: string;
type: 'conversation' | 'workflow' | 'pattern' | 'feedback';
input: string;
expectedOutput: string;
actualOutput?: string;
role: string;
context: any;
quality: number; // 0-1 score
timestamp: Date;
}
export interface TrainingSession {
id: string;
name: string;
description: string;
dataPoints: TrainingData[];
status: 'preparing' | 'training' | 'completed' | 'failed';
metrics: TrainingMetrics;
createdAt: Date;
completedAt?: Date;
}
export interface TrainingMetrics {
totalSamples: number;
qualityScore: number;
improvementAreas: string[];
performanceByRole: Record<string, number>;
patterns: any[];
}
export class AITrainingService {
private trainingSessions: Map<string, TrainingSession> = new Map();
private trainingData: TrainingData[] = [];
/**
* Collect training data from user interactions
*/
async collectInteractionData(
userId: string,
userInput: string,
aiResponse: string,
role: string,
context: any,
userFeedback?: number
): Promise<void> {
const trainingPoint: TrainingData = {
id: crypto.randomUUID(),
type: 'conversation',
input: userInput,
expectedOutput: aiResponse, // Will be refined based on feedback
actualOutput: aiResponse,
role,
context,
quality: userFeedback || 0.8, // Default assumption
timestamp: new Date()
};
this.trainingData.push(trainingPoint);
// Store in persistent memory
await chickenMemoryService.addObservation(
`training_data_${userId}`,
trainingPoint
);
// Analyze for immediate improvements
await this.analyzeAndImprove(trainingPoint);
}
/**
* Create a new training session
*/
async createTrainingSession(
name: string,
description: string,
dataFilter?: any
): Promise<string> {
const sessionId = crypto.randomUUID();
// Filter training data based on criteria
let filteredData = this.trainingData;
if (dataFilter) {
filteredData = this.filterTrainingData(dataFilter);
}
const session: TrainingSession = {
id: sessionId,
name,
description,
dataPoints: filteredData,
status: 'preparing',
metrics: await this.calculateMetrics(filteredData),
createdAt: new Date()
};
this.trainingSessions.set(sessionId, session);
// Start training process
this.startTraining(sessionId);
return sessionId;
}
/**
* Analyze workflow patterns for optimization
*/
async analyzeWorkflowPatterns(): Promise<any[]> {
// Get all workflow-related interactions
const workflowData = this.trainingData.filter(
data => data.type === 'workflow' || data.context?.currentWorkflow
);
const patterns = [];
// Group by workflow type
const workflowGroups = this.groupBy(workflowData, 'context.currentWorkflow');
for (const [workflow, data] of Object.entries(workflowGroups)) {
const pattern = await this.analyzeWorkflowGroup(workflow, data as TrainingData[]);
patterns.push(pattern);
}
// Store patterns for future use
await chickenMemoryService.storeEntity('workflow_patterns', patterns);
return patterns;
}
/**
* Fine-tune AI responses based on role performance
*/
async optimizeRoleResponses(role: string): Promise<any> {
const roleData = this.trainingData.filter(data => data.role === role);
if (roleData.length < 10) {
return { error: 'Insufficient data for role optimization' };
}
// Analyze common patterns and issues
const commonInputs = this.findCommonPatterns(roleData.map(d => d.input));
const lowQualityResponses = roleData.filter(d => d.quality < 0.6);
// Generate optimization suggestions
const optimizations = {
role,
commonQueries: commonInputs,
problemAreas: lowQualityResponses.map(d => ({
input: d.input,
issue: d.actualOutput,
suggestion: await this.generateImprovedResponse(d)
})),
recommendedPromptChanges: await this.suggestPromptImprovements(role, roleData),
trainingDataQuality: this.calculateDataQuality(roleData)
};
return optimizations;
}
/**
* Learn patterns from website interactions
*/
async learnWebsitePatterns(interactionLogs: any[]): Promise<any> {
const patterns = {
commonUserFlows: [],
dropOffPoints: [],
efficientPaths: [],
roleBasedBehaviors: {}
};
// Analyze user flows
const userFlows = this.extractUserFlows(interactionLogs);
patterns.commonUserFlows = this.findMostCommonFlows(userFlows);
// Find drop-off points
patterns.dropOffPoints = this.identifyDropOffPoints(userFlows);
// Identify efficient paths
patterns.efficientPaths = this.findEfficientPaths(userFlows);
// Role-based behavior analysis
const roleGroups = this.groupBy(interactionLogs, 'role');
for (const [role, logs] of Object.entries(roleGroups)) {
patterns.roleBasedBehaviors[role] = this.analyzeRoleBehavior(logs as any[]);
}
// Store patterns
await chickenMemoryService.storeEntity('website_patterns', patterns);
// Generate workflow optimizations
const optimizations = await this.generateWorkflowOptimizations(patterns);
return { patterns, optimizations };
}
/**
* Generate training insights and recommendations
*/
async generateTrainingInsights(): Promise<any> {
const insights = {
overallPerformance: await this.calculateOverallPerformance(),
rolePerformance: await this.calculateRolePerformance(),
improvementAreas: await this.identifyImprovementAreas(),
trainingRecommendations: await this.generateTrainingRecommendations(),
patternAnalysis: await this.analyzeInteractionPatterns()
};
return insights;
}
/**
* Private helper methods
*/
private async startTraining(sessionId: string): Promise<void> {
const session = this.trainingSessions.get(sessionId);
if (!session) return;
try {
session.status = 'training';
// Process training data
await this.processTrainingData(session.dataPoints);
// Update AI models with new patterns
await this.updateAIModels(session);
session.status = 'completed';
session.completedAt = new Date();
} catch (error) {
console.error('Training failed:', error);
session.status = 'failed';
}
}
private async calculateMetrics(data: TrainingData[]): Promise<TrainingMetrics> {
const metrics: TrainingMetrics = {
totalSamples: data.length,
qualityScore: data.reduce((sum, d) => sum + d.quality, 0) / data.length,
improvementAreas: [],
performanceByRole: {},
patterns: []
};
// Calculate performance by role
const roleGroups = this.groupBy(data, 'role');
for (const [role, roleData] of Object.entries(roleGroups)) {
const roleArray = roleData as TrainingData[];
metrics.performanceByRole[role] =
roleArray.reduce((sum, d) => sum + d.quality, 0) / roleArray.length;
}
// Identify improvement areas
metrics.improvementAreas = this.identifyWeakAreas(data);
return metrics;
}
private filterTrainingData(filter: any): TrainingData[] {
return this.trainingData.filter(data => {
if (filter.role && data.role !== filter.role) return false;
if (filter.minQuality && data.quality < filter.minQuality) return false;
if (filter.dateRange) {
const dataDate = data.timestamp;
if (dataDate < filter.dateRange.start || dataDate > filter.dateRange.end) {
return false;
}
}
return true;
});
}
private groupBy<T>(array: T[], key: string): Record<string, T[]> {
return array.reduce((groups, item) => {
const value = this.getNestedProperty(item, key);
const group = groups[value] || [];
group.push(item);
groups[value] = group;
return groups;
}, {} as Record<string, T[]>);
}
private getNestedProperty(obj: any, path: string): any {
return path.split('.').reduce((o, p) => o && o[p], obj);
}
private async analyzeAndImprove(trainingPoint: TrainingData): Promise<void> {
// Real-time analysis and improvement
if (trainingPoint.quality < 0.5) {
const improvement = await this.generateImprovedResponse(trainingPoint);
console.log(`Improvement suggestion for low-quality response:`, improvement);
}
}
private async generateImprovedResponse(trainingPoint: TrainingData): Promise<string> {
// Use AI to generate improved response
return `Improved response for: ${trainingPoint.input}`;
}
private findCommonPatterns(inputs: string[]): string[] {
// Analyze common input patterns
const patterns = [];
// Implementation would use NLP to find common themes
return patterns;
}
private async suggestPromptImprovements(role: string, data: TrainingData[]): Promise<string[]> {
// Analyze patterns and suggest prompt improvements
return [`Improve ${role} responses for better clarity`];
}
private calculateDataQuality(data: TrainingData[]): number {
return data.reduce((sum, d) => sum + d.quality, 0) / data.length;
}
private extractUserFlows(logs: any[]): any[] {
// Extract user interaction flows from logs
return [];
}
private findMostCommonFlows(flows: any[]): any[] {
// Find most common user flows
return [];
}
private identifyDropOffPoints(flows: any[]): any[] {
// Identify where users commonly drop off
return [];
}
private findEfficientPaths(flows: any[]): any[] {
// Find most efficient user paths
return [];
}
private analyzeRoleBehavior(logs: any[]): any {
// Analyze behavior patterns for specific role
return {};
}
private async generateWorkflowOptimizations(patterns: any): Promise<any[]> {
// Generate optimization suggestions based on patterns
return [];
}
private async calculateOverallPerformance(): Promise<number> {
return this.trainingData.reduce((sum, d) => sum + d.quality, 0) / this.trainingData.length;
}
private async calculateRolePerformance(): Promise<Record<string, number>> {
const roleGroups = this.groupBy(this.trainingData, 'role');
const performance: Record<string, number> = {};
for (const [role, data] of Object.entries(roleGroups)) {
const roleArray = data as TrainingData[];
performance[role] = roleArray.reduce((sum, d) => sum + d.quality, 0) / roleArray.length;
}
return performance;
}
private async identifyImprovementAreas(): Promise<string[]> {
const lowQualityData = this.trainingData.filter(d => d.quality < 0.6);
const areas = this.groupBy(lowQualityData, 'role');
return Object.keys(areas);
}
private async generateTrainingRecommendations(): Promise<string[]> {
return [
"Increase training data for low-performing roles",
"Focus on improving response quality for common queries",
"Implement feedback loops for continuous learning"
];
}
private async analyzeInteractionPatterns(): Promise<any> {
// Comprehensive pattern analysis
return {
temporalPatterns: "Peak usage during business hours",
rolePatterns: "Workers prefer voice input, owners prefer analytics",
contentPatterns: "Stock queries most common"
};
}
private identifyWeakAreas(data: TrainingData[]): string[] {
const lowQualityByType = data
.filter(d => d.quality < 0.6)
.reduce((acc, d) => {
acc[d.type] = (acc[d.type] || 0) + 1;
return acc;
}, {} as Record<string, number>);
return Object.keys(lowQualityByType);
}
private async analyzeWorkflowGroup(workflow: string, data: TrainingData[]): Promise<any> {
return {
workflow,
efficiency: this.calculateDataQuality(data),
commonIssues: this.identifyWeakAreas(data),
optimizations: []
};
}
private async processTrainingData(data: TrainingData[]): Promise<void> {
// Process training data for model improvement
console.log(`Processing ${data.length} training samples`);
}
private async updateAIModels(session: TrainingSession): Promise<void> {
// Update AI models with insights from training session
console.log(`Updating AI models from session: ${session.name}`);
}
}
export const aiTrainingService = new AITrainingService();