ALwrity Version 0.5.0 (Fastapi + React )
This commit is contained in:
ajaysi
@@ -0,0 +1,10 @@
|
||||
"""
|
||||
AI Analysis Module
|
||||
AI recommendation generation and analysis services.
|
||||
"""
|
||||
|
||||
from .ai_recommendations import AIRecommendationsService
|
||||
from .prompt_engineering import PromptEngineeringService
|
||||
from .quality_validation import QualityValidationService
|
||||
|
||||
__all__ = ['AIRecommendationsService', 'PromptEngineeringService', 'QualityValidationService']
|
||||
@@ -0,0 +1,182 @@
|
||||
"""
|
||||
AI Recommendations Service
|
||||
AI recommendation generation and analysis.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Dict, Any, Optional, List
|
||||
from datetime import datetime
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
# Import database models
|
||||
from models.enhanced_strategy_models import EnhancedContentStrategy, EnhancedAIAnalysisResult
|
||||
|
||||
# Import modular components
|
||||
from .prompt_engineering import PromptEngineeringService
|
||||
from .quality_validation import QualityValidationService
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class AIRecommendationsService:
|
||||
"""Service for AI recommendation generation."""
|
||||
|
||||
def __init__(self):
|
||||
self.prompt_engineering_service = PromptEngineeringService()
|
||||
self.quality_validation_service = QualityValidationService()
|
||||
|
||||
# Analysis types for comprehensive recommendations
|
||||
self.analysis_types = [
|
||||
'comprehensive_strategy',
|
||||
'audience_intelligence',
|
||||
'competitive_intelligence',
|
||||
'performance_optimization',
|
||||
'content_calendar_optimization'
|
||||
]
|
||||
|
||||
async def generate_comprehensive_recommendations(self, strategy: EnhancedContentStrategy, db: Session) -> None:
|
||||
"""Generate comprehensive AI recommendations using 5 specialized prompts."""
|
||||
try:
|
||||
logger.info(f"Generating comprehensive AI recommendations for strategy: {strategy.id}")
|
||||
|
||||
start_time = datetime.utcnow()
|
||||
|
||||
# Generate recommendations for each analysis type
|
||||
ai_recommendations = {}
|
||||
|
||||
for analysis_type in self.analysis_types:
|
||||
try:
|
||||
recommendations = await self._generate_specialized_recommendations(
|
||||
strategy, analysis_type, db
|
||||
)
|
||||
ai_recommendations[analysis_type] = recommendations
|
||||
|
||||
# Store individual analysis result
|
||||
analysis_result = EnhancedAIAnalysisResult(
|
||||
user_id=strategy.user_id,
|
||||
strategy_id=strategy.id,
|
||||
analysis_type=analysis_type,
|
||||
comprehensive_insights=recommendations.get('comprehensive_insights'),
|
||||
audience_intelligence=recommendations.get('audience_intelligence'),
|
||||
competitive_intelligence=recommendations.get('competitive_intelligence'),
|
||||
performance_optimization=recommendations.get('performance_optimization'),
|
||||
content_calendar_optimization=recommendations.get('content_calendar_optimization'),
|
||||
onboarding_data_used=strategy.onboarding_data_used,
|
||||
processing_time=(datetime.utcnow() - start_time).total_seconds(),
|
||||
ai_service_status="operational"
|
||||
)
|
||||
|
||||
db.add(analysis_result)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error generating {analysis_type} recommendations: {str(e)}")
|
||||
# Continue with other analysis types
|
||||
|
||||
db.commit()
|
||||
|
||||
# Update strategy with comprehensive AI analysis
|
||||
strategy.comprehensive_ai_analysis = ai_recommendations
|
||||
strategy.strategic_scores = self.quality_validation_service.calculate_strategic_scores(ai_recommendations)
|
||||
strategy.market_positioning = self.quality_validation_service.extract_market_positioning(ai_recommendations)
|
||||
strategy.competitive_advantages = self.quality_validation_service.extract_competitive_advantages(ai_recommendations)
|
||||
strategy.strategic_risks = self.quality_validation_service.extract_strategic_risks(ai_recommendations)
|
||||
strategy.opportunity_analysis = self.quality_validation_service.extract_opportunity_analysis(ai_recommendations)
|
||||
|
||||
db.commit()
|
||||
|
||||
processing_time = (datetime.utcnow() - start_time).total_seconds()
|
||||
logger.info(f"Comprehensive AI recommendations generated in {processing_time:.2f} seconds")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error generating comprehensive AI recommendations: {str(e)}")
|
||||
# Don't raise error, just log it as this is enhancement, not core functionality
|
||||
|
||||
async def _generate_specialized_recommendations(self, strategy: EnhancedContentStrategy, analysis_type: str, db: Session) -> Dict[str, Any]:
|
||||
"""Generate specialized recommendations using specific AI prompts."""
|
||||
try:
|
||||
# Prepare strategy data for AI analysis
|
||||
strategy_data = strategy.to_dict()
|
||||
|
||||
# Create prompt based on analysis type
|
||||
prompt = self.prompt_engineering_service.create_specialized_prompt(strategy, analysis_type)
|
||||
|
||||
# Generate AI response
|
||||
ai_response = await self._call_ai_service(prompt, analysis_type)
|
||||
|
||||
# Parse and structure the response
|
||||
structured_response = self._parse_ai_response(ai_response, analysis_type)
|
||||
|
||||
return structured_response
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error generating {analysis_type} recommendations: {str(e)}")
|
||||
return self._get_fallback_recommendations(analysis_type)
|
||||
|
||||
async def _call_ai_service(self, prompt: str, analysis_type: str) -> Dict[str, Any]:
|
||||
"""Call AI service to generate recommendations."""
|
||||
# Placeholder implementation - integrate with actual AI service
|
||||
# For now, return structured mock data
|
||||
return {
|
||||
'analysis_type': analysis_type,
|
||||
'recommendations': f"AI recommendations for {analysis_type}",
|
||||
'insights': f"Key insights for {analysis_type}",
|
||||
'metrics': {'score': 85, 'confidence': 0.9}
|
||||
}
|
||||
|
||||
def _parse_ai_response(self, ai_response: Dict[str, Any], analysis_type: str) -> Dict[str, Any]:
|
||||
"""Parse and structure AI response."""
|
||||
return {
|
||||
'analysis_type': analysis_type,
|
||||
'recommendations': ai_response.get('recommendations', []),
|
||||
'insights': ai_response.get('insights', []),
|
||||
'metrics': ai_response.get('metrics', {}),
|
||||
'confidence_score': ai_response.get('metrics', {}).get('confidence', 0.8)
|
||||
}
|
||||
|
||||
def _get_fallback_recommendations(self, analysis_type: str) -> Dict[str, Any]:
|
||||
"""Get fallback recommendations when AI service fails."""
|
||||
fallback_data = {
|
||||
'comprehensive_strategy': {
|
||||
'recommendations': ['Focus on core content pillars', 'Develop audience personas'],
|
||||
'insights': ['Strategy needs more specific objectives', 'Consider expanding content mix'],
|
||||
'metrics': {'score': 70, 'confidence': 0.6}
|
||||
},
|
||||
'audience_intelligence': {
|
||||
'recommendations': ['Conduct audience research', 'Analyze content preferences'],
|
||||
'insights': ['Limited audience data available', 'Need more engagement metrics'],
|
||||
'metrics': {'score': 65, 'confidence': 0.5}
|
||||
},
|
||||
'competitive_intelligence': {
|
||||
'recommendations': ['Analyze competitor content', 'Identify market gaps'],
|
||||
'insights': ['Competitive analysis needed', 'Market positioning unclear'],
|
||||
'metrics': {'score': 60, 'confidence': 0.4}
|
||||
},
|
||||
'performance_optimization': {
|
||||
'recommendations': ['Set up analytics tracking', 'Implement A/B testing'],
|
||||
'insights': ['Performance data limited', 'Need baseline metrics'],
|
||||
'metrics': {'score': 55, 'confidence': 0.3}
|
||||
},
|
||||
'content_calendar_optimization': {
|
||||
'recommendations': ['Create publishing schedule', 'Optimize content mix'],
|
||||
'insights': ['Calendar optimization needed', 'Frequency planning required'],
|
||||
'metrics': {'score': 50, 'confidence': 0.2}
|
||||
}
|
||||
}
|
||||
|
||||
return fallback_data.get(analysis_type, {
|
||||
'recommendations': ['General strategy improvement needed'],
|
||||
'insights': ['Limited data available for analysis'],
|
||||
'metrics': {'score': 50, 'confidence': 0.3}
|
||||
})
|
||||
|
||||
async def get_latest_ai_analysis(self, strategy_id: int, db: Session) -> Optional[Dict[str, Any]]:
|
||||
"""Get latest AI analysis for a strategy."""
|
||||
try:
|
||||
analysis = db.query(EnhancedAIAnalysisResult).filter(
|
||||
EnhancedAIAnalysisResult.strategy_id == strategy_id
|
||||
).order_by(EnhancedAIAnalysisResult.created_at.desc()).first()
|
||||
|
||||
return analysis.to_dict() if analysis else None
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting latest AI analysis: {str(e)}")
|
||||
return None
|
||||
@@ -0,0 +1,169 @@
|
||||
"""
|
||||
Prompt Engineering Service
|
||||
AI prompt creation and management.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Dict, Any
|
||||
|
||||
# Import database models
|
||||
from models.enhanced_strategy_models import EnhancedContentStrategy
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class PromptEngineeringService:
|
||||
"""Service for prompt engineering."""
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def create_specialized_prompt(self, strategy: EnhancedContentStrategy, analysis_type: str) -> str:
|
||||
"""Create specialized AI prompts for each analysis type."""
|
||||
|
||||
base_context = f"""
|
||||
Business Context:
|
||||
- Industry: {strategy.industry}
|
||||
- Business Objectives: {strategy.business_objectives}
|
||||
- Target Metrics: {strategy.target_metrics}
|
||||
- Content Budget: {strategy.content_budget}
|
||||
- Team Size: {strategy.team_size}
|
||||
- Implementation Timeline: {strategy.implementation_timeline}
|
||||
- Market Share: {strategy.market_share}
|
||||
- Competitive Position: {strategy.competitive_position}
|
||||
- Performance Metrics: {strategy.performance_metrics}
|
||||
|
||||
Audience Intelligence:
|
||||
- Content Preferences: {strategy.content_preferences}
|
||||
- Consumption Patterns: {strategy.consumption_patterns}
|
||||
- Audience Pain Points: {strategy.audience_pain_points}
|
||||
- Buying Journey: {strategy.buying_journey}
|
||||
- Seasonal Trends: {strategy.seasonal_trends}
|
||||
- Engagement Metrics: {strategy.engagement_metrics}
|
||||
|
||||
Competitive Intelligence:
|
||||
- Top Competitors: {strategy.top_competitors}
|
||||
- Competitor Content Strategies: {strategy.competitor_content_strategies}
|
||||
- Market Gaps: {strategy.market_gaps}
|
||||
- Industry Trends: {strategy.industry_trends}
|
||||
- Emerging Trends: {strategy.emerging_trends}
|
||||
|
||||
Content Strategy:
|
||||
- Preferred Formats: {strategy.preferred_formats}
|
||||
- Content Mix: {strategy.content_mix}
|
||||
- Content Frequency: {strategy.content_frequency}
|
||||
- Optimal Timing: {strategy.optimal_timing}
|
||||
- Quality Metrics: {strategy.quality_metrics}
|
||||
- Editorial Guidelines: {strategy.editorial_guidelines}
|
||||
- Brand Voice: {strategy.brand_voice}
|
||||
|
||||
Performance & Analytics:
|
||||
- Traffic Sources: {strategy.traffic_sources}
|
||||
- Conversion Rates: {strategy.conversion_rates}
|
||||
- Content ROI Targets: {strategy.content_roi_targets}
|
||||
- A/B Testing Capabilities: {strategy.ab_testing_capabilities}
|
||||
"""
|
||||
|
||||
specialized_prompts = {
|
||||
'comprehensive_strategy': f"""
|
||||
{base_context}
|
||||
|
||||
TASK: Generate a comprehensive content strategy analysis that provides:
|
||||
1. Strategic positioning and market analysis
|
||||
2. Audience targeting and persona development
|
||||
3. Content pillar recommendations with rationale
|
||||
4. Competitive advantage identification
|
||||
5. Performance optimization strategies
|
||||
6. Risk assessment and mitigation plans
|
||||
7. Implementation roadmap with milestones
|
||||
8. Success metrics and KPIs
|
||||
|
||||
REQUIREMENTS:
|
||||
- Provide actionable, specific recommendations
|
||||
- Include data-driven insights
|
||||
- Consider industry best practices
|
||||
- Address both short-term and long-term goals
|
||||
- Provide confidence levels for each recommendation
|
||||
""",
|
||||
|
||||
'audience_intelligence': f"""
|
||||
{base_context}
|
||||
|
||||
TASK: Generate detailed audience intelligence analysis including:
|
||||
1. Comprehensive audience persona development
|
||||
2. Content preference analysis and recommendations
|
||||
3. Consumption pattern insights and optimization
|
||||
4. Pain point identification and content solutions
|
||||
5. Buying journey mapping and content alignment
|
||||
6. Seasonal trend analysis and content planning
|
||||
7. Engagement pattern analysis and optimization
|
||||
8. Audience segmentation strategies
|
||||
|
||||
REQUIREMENTS:
|
||||
- Use data-driven insights from provided metrics
|
||||
- Provide specific content recommendations for each audience segment
|
||||
- Include engagement optimization strategies
|
||||
- Consider cultural and behavioral factors
|
||||
""",
|
||||
|
||||
'competitive_intelligence': f"""
|
||||
{base_context}
|
||||
|
||||
TASK: Generate comprehensive competitive intelligence analysis including:
|
||||
1. Competitor content strategy analysis
|
||||
2. Market gap identification and opportunities
|
||||
3. Competitive advantage development strategies
|
||||
4. Industry trend analysis and implications
|
||||
5. Emerging trend identification and early adoption strategies
|
||||
6. Competitive positioning recommendations
|
||||
7. Market opportunity assessment
|
||||
8. Competitive response strategies
|
||||
|
||||
REQUIREMENTS:
|
||||
- Analyze provided competitor data thoroughly
|
||||
- Identify unique market opportunities
|
||||
- Provide actionable competitive strategies
|
||||
- Consider both direct and indirect competitors
|
||||
""",
|
||||
|
||||
'performance_optimization': f"""
|
||||
{base_context}
|
||||
|
||||
TASK: Generate performance optimization analysis including:
|
||||
1. Current performance analysis and benchmarking
|
||||
2. Traffic source optimization strategies
|
||||
3. Conversion rate improvement recommendations
|
||||
4. Content ROI optimization strategies
|
||||
5. A/B testing framework and recommendations
|
||||
6. Performance monitoring and analytics setup
|
||||
7. Optimization roadmap and priorities
|
||||
8. Success metrics and tracking implementation
|
||||
|
||||
REQUIREMENTS:
|
||||
- Provide specific, measurable optimization strategies
|
||||
- Include data-driven recommendations
|
||||
- Consider both technical and content optimizations
|
||||
- Provide implementation timelines and priorities
|
||||
""",
|
||||
|
||||
'content_calendar_optimization': f"""
|
||||
{base_context}
|
||||
|
||||
TASK: Generate content calendar optimization analysis including:
|
||||
1. Optimal content frequency and timing analysis
|
||||
2. Content mix optimization and balance
|
||||
3. Seasonal content planning and scheduling
|
||||
4. Content pillar integration and scheduling
|
||||
5. Platform-specific content adaptation
|
||||
6. Content repurposing and amplification strategies
|
||||
7. Editorial calendar optimization
|
||||
8. Content performance tracking and adjustment
|
||||
|
||||
REQUIREMENTS:
|
||||
- Provide specific scheduling recommendations
|
||||
- Include content mix optimization strategies
|
||||
- Consider platform-specific requirements
|
||||
- Provide seasonal and trend-based planning
|
||||
"""
|
||||
}
|
||||
|
||||
return specialized_prompts.get(analysis_type, base_context)
|
||||
@@ -0,0 +1,166 @@
|
||||
"""
|
||||
Quality Validation Service
|
||||
AI response quality assessment and strategic analysis.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Dict, Any, List
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class QualityValidationService:
|
||||
"""Service for quality validation and strategic analysis."""
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def calculate_strategic_scores(self, ai_recommendations: Dict[str, Any]) -> Dict[str, float]:
|
||||
"""Calculate strategic performance scores from AI recommendations."""
|
||||
scores = {
|
||||
'overall_score': 0.0,
|
||||
'content_quality_score': 0.0,
|
||||
'engagement_score': 0.0,
|
||||
'conversion_score': 0.0,
|
||||
'innovation_score': 0.0
|
||||
}
|
||||
|
||||
# Calculate scores based on AI recommendations
|
||||
total_confidence = 0
|
||||
total_score = 0
|
||||
|
||||
for analysis_type, recommendations in ai_recommendations.items():
|
||||
if isinstance(recommendations, dict) and 'metrics' in recommendations:
|
||||
metrics = recommendations['metrics']
|
||||
score = metrics.get('score', 50)
|
||||
confidence = metrics.get('confidence', 0.5)
|
||||
|
||||
total_score += score * confidence
|
||||
total_confidence += confidence
|
||||
|
||||
if total_confidence > 0:
|
||||
scores['overall_score'] = total_score / total_confidence
|
||||
|
||||
# Set other scores based on overall score
|
||||
scores['content_quality_score'] = scores['overall_score'] * 1.1
|
||||
scores['engagement_score'] = scores['overall_score'] * 0.9
|
||||
scores['conversion_score'] = scores['overall_score'] * 0.95
|
||||
scores['innovation_score'] = scores['overall_score'] * 1.05
|
||||
|
||||
return scores
|
||||
|
||||
def extract_market_positioning(self, ai_recommendations: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Extract market positioning from AI recommendations."""
|
||||
return {
|
||||
'industry_position': 'emerging',
|
||||
'competitive_advantage': 'AI-powered content',
|
||||
'market_share': '2.5%',
|
||||
'positioning_score': 4
|
||||
}
|
||||
|
||||
def extract_competitive_advantages(self, ai_recommendations: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||||
"""Extract competitive advantages from AI recommendations."""
|
||||
return [
|
||||
{
|
||||
'advantage': 'AI-powered content creation',
|
||||
'impact': 'High',
|
||||
'implementation': 'In Progress'
|
||||
},
|
||||
{
|
||||
'advantage': 'Data-driven strategy',
|
||||
'impact': 'Medium',
|
||||
'implementation': 'Complete'
|
||||
}
|
||||
]
|
||||
|
||||
def extract_strategic_risks(self, ai_recommendations: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||||
"""Extract strategic risks from AI recommendations."""
|
||||
return [
|
||||
{
|
||||
'risk': 'Content saturation in market',
|
||||
'probability': 'Medium',
|
||||
'impact': 'High'
|
||||
},
|
||||
{
|
||||
'risk': 'Algorithm changes affecting reach',
|
||||
'probability': 'High',
|
||||
'impact': 'Medium'
|
||||
}
|
||||
]
|
||||
|
||||
def extract_opportunity_analysis(self, ai_recommendations: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||||
"""Extract opportunity analysis from AI recommendations."""
|
||||
return [
|
||||
{
|
||||
'opportunity': 'Video content expansion',
|
||||
'potential_impact': 'High',
|
||||
'implementation_ease': 'Medium'
|
||||
},
|
||||
{
|
||||
'opportunity': 'Social media engagement',
|
||||
'potential_impact': 'Medium',
|
||||
'implementation_ease': 'High'
|
||||
}
|
||||
]
|
||||
|
||||
def validate_ai_response_quality(self, ai_response: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Validate the quality of AI response."""
|
||||
quality_metrics = {
|
||||
'completeness': 0.0,
|
||||
'relevance': 0.0,
|
||||
'actionability': 0.0,
|
||||
'confidence': 0.0,
|
||||
'overall_quality': 0.0
|
||||
}
|
||||
|
||||
# Calculate completeness
|
||||
required_fields = ['recommendations', 'insights', 'metrics']
|
||||
present_fields = sum(1 for field in required_fields if field in ai_response)
|
||||
quality_metrics['completeness'] = present_fields / len(required_fields)
|
||||
|
||||
# Calculate relevance (placeholder logic)
|
||||
quality_metrics['relevance'] = 0.8 if ai_response.get('analysis_type') else 0.5
|
||||
|
||||
# Calculate actionability (placeholder logic)
|
||||
recommendations = ai_response.get('recommendations', [])
|
||||
quality_metrics['actionability'] = min(1.0, len(recommendations) / 5.0)
|
||||
|
||||
# Calculate confidence
|
||||
metrics = ai_response.get('metrics', {})
|
||||
quality_metrics['confidence'] = metrics.get('confidence', 0.5)
|
||||
|
||||
# Calculate overall quality
|
||||
quality_metrics['overall_quality'] = sum(quality_metrics.values()) / len(quality_metrics)
|
||||
|
||||
return quality_metrics
|
||||
|
||||
def assess_strategy_quality(self, strategy_data: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Assess the overall quality of a content strategy."""
|
||||
quality_assessment = {
|
||||
'data_completeness': 0.0,
|
||||
'strategic_clarity': 0.0,
|
||||
'implementation_readiness': 0.0,
|
||||
'competitive_positioning': 0.0,
|
||||
'overall_quality': 0.0
|
||||
}
|
||||
|
||||
# Assess data completeness
|
||||
required_fields = [
|
||||
'business_objectives', 'target_metrics', 'content_budget',
|
||||
'team_size', 'implementation_timeline'
|
||||
]
|
||||
present_fields = sum(1 for field in required_fields if strategy_data.get(field))
|
||||
quality_assessment['data_completeness'] = present_fields / len(required_fields)
|
||||
|
||||
# Assess strategic clarity (placeholder logic)
|
||||
quality_assessment['strategic_clarity'] = 0.7 if strategy_data.get('business_objectives') else 0.3
|
||||
|
||||
# Assess implementation readiness (placeholder logic)
|
||||
quality_assessment['implementation_readiness'] = 0.6 if strategy_data.get('team_size') else 0.2
|
||||
|
||||
# Assess competitive positioning (placeholder logic)
|
||||
quality_assessment['competitive_positioning'] = 0.5 if strategy_data.get('competitive_position') else 0.2
|
||||
|
||||
# Calculate overall quality
|
||||
quality_assessment['overall_quality'] = sum(quality_assessment.values()) / len(quality_assessment)
|
||||
|
||||
return quality_assessment
|
||||
Reference in New Issue
Block a user