1048 lines
45 KiB
Python
1048 lines
45 KiB
Python
"""
|
|
AI Service Manager
|
|
Centralized AI service management for content planning system.
|
|
"""
|
|
|
|
from typing import Dict, Any, List, Optional
|
|
from loguru import logger
|
|
from datetime import datetime
|
|
import json
|
|
import asyncio
|
|
from dataclasses import dataclass
|
|
from enum import Enum
|
|
|
|
# Import AI providers
|
|
from services.llm_providers.main_text_generation import llm_text_gen
|
|
# Prefer the extended gemini provider if available; fallback to base
|
|
try:
|
|
from services.llm_providers.gemini_provider import gemini_structured_json_response as _gemini_fn
|
|
_GEMINI_EXTENDED = True
|
|
except Exception:
|
|
from services.llm_providers.gemini_provider import gemini_structured_json_response as _gemini_fn
|
|
_GEMINI_EXTENDED = False
|
|
|
|
class AIServiceType(Enum):
|
|
"""AI service types for monitoring."""
|
|
CONTENT_GAP_ANALYSIS = "content_gap_analysis"
|
|
MARKET_POSITION_ANALYSIS = "market_position_analysis"
|
|
KEYWORD_ANALYSIS = "keyword_analysis"
|
|
PERFORMANCE_PREDICTION = "performance_prediction"
|
|
STRATEGIC_INTELLIGENCE = "strategic_intelligence"
|
|
CONTENT_QUALITY_ASSESSMENT = "content_quality_assessment"
|
|
CONTENT_SCHEDULE_GENERATION = "content_schedule_generation"
|
|
|
|
@dataclass
|
|
class AIServiceMetrics:
|
|
"""Metrics for AI service performance."""
|
|
service_type: AIServiceType
|
|
response_time: float
|
|
success: bool
|
|
error_message: Optional[str] = None
|
|
timestamp: datetime = None
|
|
|
|
def __post_init__(self):
|
|
if self.timestamp is None:
|
|
self.timestamp = datetime.utcnow()
|
|
|
|
class AIServiceManager:
|
|
"""Centralized AI service management for content planning system."""
|
|
|
|
_instance = None
|
|
_initialized = False
|
|
|
|
def __new__(cls):
|
|
"""Implement singleton pattern to prevent multiple initializations."""
|
|
if cls._instance is None:
|
|
cls._instance = super(AIServiceManager, cls).__new__(cls)
|
|
return cls._instance
|
|
|
|
def __init__(self):
|
|
"""Initialize AI service manager (only once)."""
|
|
if not self._initialized:
|
|
self.logger = logger
|
|
self.metrics: List[AIServiceMetrics] = []
|
|
self.prompts = self._load_centralized_prompts()
|
|
self.schemas = self._load_centralized_schemas()
|
|
self.config = self._load_ai_configuration()
|
|
|
|
logger.debug("AIServiceManager initialized")
|
|
self._initialized = True
|
|
|
|
def _load_ai_configuration(self) -> Dict[str, Any]:
|
|
"""Load AI configuration settings."""
|
|
return {
|
|
'max_retries': 2, # Reduced from 3
|
|
'timeout_seconds': 45, # increased from 15 to accommodate structured 30+ fields
|
|
'temperature': 0.3, # more deterministic for schema-constrained JSON
|
|
'top_p': 0.9,
|
|
'top_k': 40,
|
|
'max_tokens': 8192, # increased from 4096 to prevent JSON truncation
|
|
'enable_caching': False, # 🚨 CRITICAL: Disabled caching to ensure fresh AI responses
|
|
'cache_duration_minutes': 0, # 🚨 CRITICAL: Zero cache duration
|
|
'performance_monitoring': True,
|
|
'fallback_enabled': False # Disabled fallback to prevent false positives
|
|
}
|
|
|
|
def _load_centralized_prompts(self) -> Dict[str, str]:
|
|
"""Load centralized AI prompts."""
|
|
return {
|
|
'content_gap_analysis': """
|
|
As an expert SEO content strategist with 15+ years of experience in content marketing and competitive analysis, analyze this comprehensive content gap analysis data and provide actionable strategic insights:
|
|
|
|
TARGET ANALYSIS:
|
|
- Website: {target_url}
|
|
- Industry: {industry}
|
|
- SERP Opportunities: {serp_opportunities} keywords not ranking
|
|
- Keyword Expansion: {expanded_keywords_count} additional keywords identified
|
|
- Competitors Analyzed: {competitors_analyzed} websites
|
|
- Content Quality Score: {content_quality_score}/10
|
|
- Market Competition Level: {competition_level}
|
|
|
|
DOMINANT CONTENT THEMES:
|
|
{dominant_themes}
|
|
|
|
COMPETITIVE LANDSCAPE:
|
|
{competitive_landscape}
|
|
|
|
PROVIDE COMPREHENSIVE ANALYSIS:
|
|
1. Strategic Content Gap Analysis (identify 3-5 major gaps with impact assessment)
|
|
2. Priority Content Recommendations (top 5 with ROI estimates)
|
|
3. Keyword Strategy Insights (trending, seasonal, long-tail opportunities)
|
|
4. Competitive Positioning Advice (differentiation strategies)
|
|
5. Content Format Recommendations (video, interactive, comprehensive guides)
|
|
6. Technical SEO Opportunities (structured data, schema markup)
|
|
7. Implementation Timeline (30/60/90 days with milestones)
|
|
8. Risk Assessment and Mitigation Strategies
|
|
9. Success Metrics and KPIs
|
|
10. Resource Allocation Recommendations
|
|
|
|
Consider user intent, search behavior patterns, and content consumption trends in your analysis.
|
|
Format as structured JSON with clear, actionable recommendations and confidence scores.
|
|
""",
|
|
|
|
'market_position_analysis': """
|
|
As a senior competitive intelligence analyst specializing in digital marketing and content strategy, analyze the market position of competitors in the {industry} industry:
|
|
|
|
COMPETITOR ANALYSES:
|
|
{competitor_analyses}
|
|
|
|
MARKET CONTEXT:
|
|
- Industry: {industry}
|
|
- Market Size: {market_size}
|
|
- Growth Rate: {growth_rate}
|
|
- Key Trends: {key_trends}
|
|
|
|
PROVIDE COMPREHENSIVE MARKET ANALYSIS:
|
|
1. Market Leader Identification (with reasoning)
|
|
2. Content Leader Analysis (content strategy assessment)
|
|
3. Quality Leader Assessment (content quality metrics)
|
|
4. Market Gaps Identification (3-5 major gaps)
|
|
5. Opportunities Analysis (high-impact opportunities)
|
|
6. Competitive Advantages (unique positioning)
|
|
7. Strategic Positioning Recommendations (differentiation)
|
|
8. Content Strategy Insights (format, frequency, quality)
|
|
9. Innovation Opportunities (emerging trends)
|
|
10. Risk Assessment (competitive threats)
|
|
|
|
Include market share estimates, competitive positioning matrix, and strategic recommendations with implementation timeline.
|
|
Format as structured JSON with detailed analysis and confidence levels.
|
|
""",
|
|
|
|
'keyword_analysis': """
|
|
As an expert keyword research specialist with deep understanding of search algorithms and user behavior, analyze keyword opportunities for {industry} industry:
|
|
|
|
KEYWORD DATA:
|
|
- Target Keywords: {target_keywords}
|
|
- Industry Context: {industry}
|
|
- Search Volume Data: {search_volume_data}
|
|
- Competition Analysis: {competition_analysis}
|
|
- Trend Analysis: {trend_analysis}
|
|
|
|
PROVIDE COMPREHENSIVE KEYWORD ANALYSIS:
|
|
1. Search Volume Estimates (with confidence intervals)
|
|
2. Competition Level Assessment (difficulty scoring)
|
|
3. Trend Analysis (seasonal, cyclical, emerging)
|
|
4. Opportunity Scoring (ROI potential)
|
|
5. Content Format Recommendations (based on intent)
|
|
6. Keyword Clustering (semantic relationships)
|
|
7. Long-tail Opportunities (specific, low-competition)
|
|
8. Seasonal Variations (trending patterns)
|
|
9. Search Intent Classification (informational, commercial, navigational, transactional)
|
|
10. Implementation Priority (quick wins vs long-term)
|
|
|
|
Consider search intent, user journey stages, and conversion potential in your analysis.
|
|
Format as structured JSON with detailed metrics and strategic recommendations.
|
|
""",
|
|
|
|
'performance_prediction': """
|
|
As a data-driven content strategist with expertise in predictive analytics and content performance optimization, predict content performance based on comprehensive analysis:
|
|
|
|
CONTENT DATA:
|
|
{content_data}
|
|
|
|
MARKET CONTEXT:
|
|
- Industry: {industry}
|
|
- Target Audience: {target_audience}
|
|
- Competition Level: {competition_level}
|
|
- Content Quality Score: {quality_score}
|
|
|
|
PROVIDE DETAILED PERFORMANCE PREDICTIONS:
|
|
1. Traffic Predictions (monthly, peak, growth rate)
|
|
2. Engagement Predictions (time on page, bounce rate, social shares)
|
|
3. Ranking Predictions (position, timeline, competition)
|
|
4. Conversion Predictions (CTR, conversion rate, leads)
|
|
5. Revenue Impact (estimated revenue, ROI)
|
|
6. Risk Factors (content saturation, algorithm changes)
|
|
7. Success Factors (quality indicators, optimization opportunities)
|
|
8. Competitive Response (market reaction)
|
|
9. Seasonal Variations (performance fluctuations)
|
|
10. Long-term Sustainability (content lifecycle)
|
|
|
|
Include confidence intervals, risk assessments, and optimization recommendations.
|
|
Format as structured JSON with detailed predictions and actionable insights.
|
|
""",
|
|
|
|
'strategic_intelligence': """
|
|
As a senior content strategy consultant with expertise in digital marketing, competitive intelligence, and strategic planning, generate comprehensive strategic insights:
|
|
|
|
ANALYSIS DATA:
|
|
{analysis_data}
|
|
|
|
STRATEGIC CONTEXT:
|
|
- Business Objectives: {business_objectives}
|
|
- Target Audience: {target_audience}
|
|
- Competitive Landscape: {competitive_landscape}
|
|
- Market Opportunities: {market_opportunities}
|
|
|
|
PROVIDE STRATEGIC INTELLIGENCE:
|
|
1. Content Strategy Recommendations (pillar content, topic clusters)
|
|
2. Competitive Positioning Advice (differentiation strategies)
|
|
3. Content Optimization Suggestions (quality, format, frequency)
|
|
4. Innovation Opportunities (emerging trends, new formats)
|
|
5. Risk Mitigation Strategies (competitive threats, algorithm changes)
|
|
6. Resource Allocation (budget, team, timeline)
|
|
7. Performance Optimization (KPIs, metrics, tracking)
|
|
8. Market Expansion Opportunities (new audiences, verticals)
|
|
9. Technology Integration (AI, automation, tools)
|
|
10. Long-term Strategic Vision (3-5 year roadmap)
|
|
|
|
Consider market dynamics, user behavior trends, and competitive landscape in your analysis.
|
|
Format as structured JSON with strategic insights and implementation guidance.
|
|
""",
|
|
|
|
'content_quality_assessment': """
|
|
As an expert content quality analyst with deep understanding of SEO, user experience, and content marketing best practices, assess content quality comprehensively:
|
|
|
|
CONTENT DATA:
|
|
{content_data}
|
|
|
|
QUALITY METRICS:
|
|
- Readability Score: {readability_score}
|
|
- SEO Optimization: {seo_score}
|
|
- User Engagement: {engagement_score}
|
|
- Content Depth: {depth_score}
|
|
|
|
PROVIDE COMPREHENSIVE QUALITY ASSESSMENT:
|
|
1. Overall Quality Score (comprehensive evaluation)
|
|
2. Readability Analysis (clarity, accessibility, flow)
|
|
3. SEO Optimization Analysis (technical, on-page, off-page)
|
|
4. Engagement Potential (user experience, interaction)
|
|
5. Content Depth Assessment (comprehensiveness, authority)
|
|
6. Improvement Suggestions (specific, actionable)
|
|
7. Competitive Benchmarking (industry standards)
|
|
8. Performance Optimization (conversion, retention)
|
|
9. Accessibility Assessment (inclusive design)
|
|
10. Future-Proofing (algorithm resilience)
|
|
|
|
Include specific recommendations with implementation steps and expected impact.
|
|
Format as structured JSON with detailed assessment and optimization guidance.
|
|
"""
|
|
}
|
|
|
|
def _load_centralized_schemas(self) -> Dict[str, Dict[str, Any]]:
|
|
"""Load centralized JSON schemas."""
|
|
return {
|
|
'content_gap_analysis': {
|
|
"type": "object",
|
|
"properties": {
|
|
"strategic_insights": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"type": {"type": "string"},
|
|
"insight": {"type": "string"},
|
|
"confidence": {"type": "number"},
|
|
"priority": {"type": "string"},
|
|
"estimated_impact": {"type": "string"},
|
|
"implementation_time": {"type": "string"},
|
|
"risk_level": {"type": "string"}
|
|
}
|
|
}
|
|
},
|
|
"content_recommendations": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"type": {"type": "string"},
|
|
"recommendation": {"type": "string"},
|
|
"priority": {"type": "string"},
|
|
"estimated_traffic": {"type": "string"},
|
|
"implementation_time": {"type": "string"},
|
|
"roi_estimate": {"type": "string"},
|
|
"success_metrics": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
'market_position_analysis': {
|
|
"type": "object",
|
|
"properties": {
|
|
"market_leader": {"type": "string"},
|
|
"content_leader": {"type": "string"},
|
|
"quality_leader": {"type": "string"},
|
|
"market_gaps": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
},
|
|
"opportunities": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
},
|
|
"competitive_advantages": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
},
|
|
"strategic_recommendations": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"type": {"type": "string"},
|
|
"recommendation": {"type": "string"},
|
|
"priority": {"type": "string"},
|
|
"estimated_impact": {"type": "string"},
|
|
"implementation_time": {"type": "string"},
|
|
"confidence_level": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
'keyword_analysis': {
|
|
"type": "object",
|
|
"properties": {
|
|
"keyword_opportunities": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"keyword": {"type": "string"},
|
|
"search_volume": {"type": "number"},
|
|
"competition_level": {"type": "string"},
|
|
"difficulty_score": {"type": "number"},
|
|
"trend": {"type": "string"},
|
|
"intent": {"type": "string"},
|
|
"opportunity_score": {"type": "number"},
|
|
"recommended_format": {"type": "string"},
|
|
"estimated_traffic": {"type": "string"},
|
|
"implementation_priority": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
'performance_prediction': {
|
|
"type": "object",
|
|
"properties": {
|
|
"traffic_predictions": {
|
|
"type": "object",
|
|
"properties": {
|
|
"estimated_monthly_traffic": {"type": "string"},
|
|
"traffic_growth_rate": {"type": "string"},
|
|
"peak_traffic_month": {"type": "string"},
|
|
"confidence_level": {"type": "string"}
|
|
}
|
|
},
|
|
"engagement_predictions": {
|
|
"type": "object",
|
|
"properties": {
|
|
"estimated_time_on_page": {"type": "string"},
|
|
"estimated_bounce_rate": {"type": "string"},
|
|
"estimated_social_shares": {"type": "string"},
|
|
"estimated_comments": {"type": "string"},
|
|
"confidence_level": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
'strategic_intelligence': {
|
|
"type": "object",
|
|
"properties": {
|
|
"strategic_insights": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"type": {"type": "string"},
|
|
"insight": {"type": "string"},
|
|
"reasoning": {"type": "string"},
|
|
"priority": {"type": "string"},
|
|
"estimated_impact": {"type": "string"},
|
|
"implementation_time": {"type": "string"},
|
|
"confidence_level": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
'content_quality_assessment': {
|
|
"type": "object",
|
|
"properties": {
|
|
"overall_score": {"type": "number"},
|
|
"readability_score": {"type": "number"},
|
|
"seo_score": {"type": "number"},
|
|
"engagement_potential": {"type": "string"},
|
|
"improvement_suggestions": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
},
|
|
"timestamp": {"type": "string"}
|
|
}
|
|
},
|
|
'content_schedule_generation': {
|
|
"type": "object",
|
|
"properties": {
|
|
"schedule": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"day": {"type": "number"},
|
|
"title": {"type": "string"},
|
|
"description": {"type": "string"},
|
|
"content_type": {"type": "string"},
|
|
"platform": {"type": "string"},
|
|
"pillar": {"type": "string"},
|
|
"priority": {"type": "string"},
|
|
"keywords": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
},
|
|
"estimated_impact": {"type": "string"},
|
|
"implementation_time": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async def _execute_ai_call(self, service_type: AIServiceType, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Execute AI call with comprehensive error handling and monitoring.
|
|
|
|
Args:
|
|
service_type: Type of AI service being called
|
|
prompt: The prompt to send to AI
|
|
schema: Expected response schema
|
|
|
|
Returns:
|
|
Dictionary with AI response or error information
|
|
"""
|
|
start_time = datetime.utcnow()
|
|
success = False
|
|
error_message = None
|
|
|
|
try:
|
|
logger.info(f"🤖 Executing AI call for {service_type.value}")
|
|
|
|
# Emit educational content for frontend
|
|
await self._emit_educational_content(service_type, "start")
|
|
|
|
# Execute the AI call
|
|
response = await asyncio.wait_for(
|
|
asyncio.to_thread(
|
|
self._call_gemini_structured,
|
|
prompt,
|
|
schema,
|
|
),
|
|
timeout=self.config['timeout_seconds']
|
|
)
|
|
|
|
# Check for errors in response
|
|
if response.get("error"):
|
|
error_message = response["error"]
|
|
logger.error(f"AI call error for {service_type.value}: {error_message}")
|
|
await self._emit_educational_content(service_type, "error", error_message)
|
|
raise Exception(error_message)
|
|
|
|
# Validate response structure
|
|
if not response or not isinstance(response, dict):
|
|
error_message = "Invalid response structure from AI service"
|
|
logger.error(f"AI call error for {service_type.value}: {error_message}")
|
|
await self._emit_educational_content(service_type, "error", error_message)
|
|
raise Exception(error_message)
|
|
|
|
success = True
|
|
processing_time = (datetime.utcnow() - start_time).total_seconds()
|
|
|
|
# Emit success educational content
|
|
await self._emit_educational_content(service_type, "success", processing_time=processing_time)
|
|
|
|
# Record metrics
|
|
self._record_metrics(service_type, processing_time, success, error_message)
|
|
|
|
logger.info(f"✅ AI call for {service_type.value} completed successfully in {processing_time:.2f}s")
|
|
|
|
return {
|
|
"data": response,
|
|
"processing_time": processing_time,
|
|
"service_type": service_type.value,
|
|
"success": True
|
|
}
|
|
|
|
except Exception as e:
|
|
processing_time = (datetime.utcnow() - start_time).total_seconds()
|
|
error_message = str(e)
|
|
|
|
# Emit error educational content
|
|
await self._emit_educational_content(service_type, "error", error_message)
|
|
|
|
# Record metrics
|
|
self._record_metrics(service_type, processing_time, success, error_message)
|
|
|
|
logger.error(f"❌ AI call error for {service_type.value}: {error_message}")
|
|
|
|
return {
|
|
"error": error_message,
|
|
"processing_time": processing_time,
|
|
"service_type": service_type.value,
|
|
"success": False
|
|
}
|
|
|
|
def _call_gemini_structured(self, prompt: str, schema: Dict[str, Any]):
|
|
"""Call gemini structured JSON with flexible signature support.
|
|
Tries extended signature first; falls back to minimal signature to avoid TypeError.
|
|
"""
|
|
try:
|
|
# Attempt extended signature (temperature/top_p/top_k/max_tokens/system_prompt)
|
|
return _gemini_fn(
|
|
prompt,
|
|
schema,
|
|
self.config['temperature'],
|
|
self.config['top_p'],
|
|
self.config.get('top_k', 40),
|
|
self.config['max_tokens'],
|
|
None
|
|
)
|
|
except TypeError:
|
|
logger.debug("Falling back to base gemini provider signature (prompt, schema)")
|
|
return _gemini_fn(prompt, schema)
|
|
|
|
async def execute_structured_json_call(self, service_type: AIServiceType, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Public wrapper to execute a structured JSON AI call with a provided schema."""
|
|
return await self._execute_ai_call(service_type, prompt, schema)
|
|
|
|
async def generate_content_gap_analysis(self, analysis_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate content gap analysis using centralized AI service.
|
|
|
|
Args:
|
|
analysis_data: Analysis data
|
|
|
|
Returns:
|
|
Content gap analysis results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['content_gap_analysis'].format(
|
|
target_url=analysis_data.get('target_url', 'N/A'),
|
|
industry=analysis_data.get('industry', 'N/A'),
|
|
serp_opportunities=analysis_data.get('serp_opportunities', 0),
|
|
expanded_keywords_count=analysis_data.get('expanded_keywords_count', 0),
|
|
competitors_analyzed=analysis_data.get('competitors_analyzed', 0),
|
|
content_quality_score=analysis_data.get('content_quality_score', 7.0),
|
|
competition_level=analysis_data.get('competition_level', 'medium'),
|
|
dominant_themes=json.dumps(analysis_data.get('dominant_themes', {}), indent=2),
|
|
competitive_landscape=json.dumps(analysis_data.get('competitive_landscape', {}), indent=2)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.CONTENT_GAP_ANALYSIS,
|
|
prompt,
|
|
self.schemas['content_gap_analysis']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in content gap analysis: {str(e)}")
|
|
raise Exception(f"Failed to generate content gap analysis: {str(e)}")
|
|
|
|
async def generate_market_position_analysis(self, market_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate market position analysis using centralized AI service.
|
|
|
|
Args:
|
|
market_data: Market analysis data
|
|
|
|
Returns:
|
|
Market position analysis results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['market_position_analysis'].format(
|
|
industry=market_data.get('industry', 'N/A'),
|
|
competitor_analyses=json.dumps(market_data.get('competitors', []), indent=2),
|
|
market_size=market_data.get('market_size', 'N/A'),
|
|
growth_rate=market_data.get('growth_rate', 'N/A'),
|
|
key_trends=json.dumps(market_data.get('key_trends', []), indent=2)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.MARKET_POSITION_ANALYSIS,
|
|
prompt,
|
|
self.schemas['market_position_analysis']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in market position analysis: {str(e)}")
|
|
raise Exception(f"Failed to generate market position analysis: {str(e)}")
|
|
|
|
async def generate_keyword_analysis(self, keyword_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate keyword analysis using centralized AI service.
|
|
|
|
Args:
|
|
keyword_data: Keyword analysis data
|
|
|
|
Returns:
|
|
Keyword analysis results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['keyword_analysis'].format(
|
|
industry=keyword_data.get('industry', 'N/A'),
|
|
target_keywords=json.dumps(keyword_data.get('target_keywords', []), indent=2),
|
|
search_volume_data=json.dumps(keyword_data.get('search_volume_data', {}), indent=2),
|
|
competition_analysis=json.dumps(keyword_data.get('competition_analysis', {}), indent=2),
|
|
trend_analysis=json.dumps(keyword_data.get('trend_analysis', {}), indent=2)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.KEYWORD_ANALYSIS,
|
|
prompt,
|
|
self.schemas['keyword_analysis']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in keyword analysis: {str(e)}")
|
|
raise Exception(f"Failed to generate keyword analysis: {str(e)}")
|
|
|
|
async def generate_performance_prediction(self, content_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate performance prediction using centralized AI service.
|
|
|
|
Args:
|
|
content_data: Content data for prediction
|
|
|
|
Returns:
|
|
Performance prediction results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['performance_prediction'].format(
|
|
industry=content_data.get('industry', 'N/A'),
|
|
target_audience=json.dumps(content_data.get('target_audience', {})),
|
|
competition_level=content_data.get('competition_level', 'medium'),
|
|
quality_score=content_data.get('quality_score', 7.0)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.PERFORMANCE_PREDICTION,
|
|
prompt,
|
|
self.schemas['performance_prediction']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in performance prediction: {str(e)}")
|
|
raise Exception(f"Failed to generate performance prediction: {str(e)}")
|
|
|
|
async def generate_strategic_intelligence(self, analysis_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate strategic intelligence using centralized AI service.
|
|
|
|
Args:
|
|
analysis_data: Analysis data for strategic insights
|
|
|
|
Returns:
|
|
Strategic intelligence results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['strategic_intelligence'].format(
|
|
analysis_data=json.dumps(analysis_data, indent=2),
|
|
business_objectives=json.dumps(analysis_data.get('business_objectives', {})),
|
|
target_audience=json.dumps(analysis_data.get('target_audience', {})),
|
|
competitive_landscape=json.dumps(analysis_data.get('competitive_landscape', {}), indent=2),
|
|
market_opportunities=json.dumps(analysis_data.get('market_opportunities', []), indent=2)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.STRATEGIC_INTELLIGENCE,
|
|
prompt,
|
|
self.schemas['strategic_intelligence']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in strategic intelligence: {str(e)}")
|
|
raise Exception(f"Failed to generate strategic intelligence: {str(e)}")
|
|
|
|
async def generate_content_quality_assessment(self, content_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Generate content quality assessment using centralized AI service.
|
|
|
|
Args:
|
|
content_data: Content data for assessment
|
|
|
|
Returns:
|
|
Content quality assessment results
|
|
"""
|
|
try:
|
|
# Format prompt
|
|
prompt = self.prompts['content_quality_assessment'].format(
|
|
content_data=json.dumps(content_data, indent=2),
|
|
readability_score=content_data.get('readability_score', 80.0),
|
|
seo_score=content_data.get('seo_score', 90.0),
|
|
engagement_score=content_data.get('engagement_score', 75.0),
|
|
depth_score=content_data.get('depth_score', 85.0)
|
|
)
|
|
|
|
# Execute AI call
|
|
result = await self._execute_ai_call(
|
|
AIServiceType.CONTENT_QUALITY_ASSESSMENT,
|
|
prompt,
|
|
self.schemas['content_quality_assessment']
|
|
)
|
|
|
|
return result if result else {}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in content quality assessment: {str(e)}")
|
|
raise Exception(f"Failed to generate content quality assessment: {str(e)}")
|
|
|
|
async def generate_content_schedule(self, prompt: str) -> Dict[str, Any]:
|
|
"""
|
|
Generate content schedule using AI.
|
|
"""
|
|
try:
|
|
logger.info("Generating content schedule using AI")
|
|
|
|
# Use the content schedule prompt
|
|
enhanced_prompt = f"""
|
|
{prompt}
|
|
|
|
Please return a structured JSON response with the following format:
|
|
{{
|
|
"schedule": [
|
|
{{
|
|
"day": 1,
|
|
"title": "Content Title",
|
|
"description": "Content description",
|
|
"content_type": "blog_post",
|
|
"platform": "website",
|
|
"pillar": "Educational Content",
|
|
"priority": "high",
|
|
"keywords": ["keyword1", "keyword2"],
|
|
"estimated_impact": "High",
|
|
"implementation_time": "2-4 weeks"
|
|
}}
|
|
]
|
|
}}
|
|
"""
|
|
|
|
response = await self._execute_ai_call(
|
|
AIServiceType.CONTENT_SCHEDULE_GENERATION,
|
|
enhanced_prompt,
|
|
self.schemas.get('content_schedule_generation', {})
|
|
)
|
|
|
|
logger.info("Content schedule generated successfully")
|
|
return response
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error generating content schedule: {str(e)}")
|
|
return {"schedule": []}
|
|
|
|
def get_performance_metrics(self) -> Dict[str, Any]:
|
|
"""
|
|
Get AI service performance metrics.
|
|
|
|
Returns:
|
|
Performance metrics
|
|
"""
|
|
if not self.metrics:
|
|
return {
|
|
'total_calls': 0,
|
|
'success_rate': 0,
|
|
'average_response_time': 0,
|
|
'service_breakdown': {}
|
|
}
|
|
|
|
total_calls = len(self.metrics)
|
|
successful_calls = len([m for m in self.metrics if m.success])
|
|
success_rate = (successful_calls / total_calls) * 100 if total_calls > 0 else 0
|
|
average_response_time = sum(m.response_time for m in self.metrics) / total_calls if total_calls > 0 else 0
|
|
|
|
# Service breakdown
|
|
service_breakdown = {}
|
|
for service_type in AIServiceType:
|
|
service_metrics = [m for m in self.metrics if m.service_type == service_type]
|
|
if service_metrics:
|
|
service_breakdown[service_type.value] = {
|
|
'total_calls': len(service_metrics),
|
|
'success_rate': (len([m for m in service_metrics if m.success]) / len(service_metrics)) * 100,
|
|
'average_response_time': sum(m.response_time for m in service_metrics) / len(service_metrics)
|
|
}
|
|
|
|
return {
|
|
'total_calls': total_calls,
|
|
'success_rate': success_rate,
|
|
'average_response_time': average_response_time,
|
|
'service_breakdown': service_breakdown,
|
|
'last_updated': datetime.utcnow().isoformat()
|
|
}
|
|
|
|
async def health_check(self) -> Dict[str, Any]:
|
|
"""
|
|
Health check for the AI service manager.
|
|
|
|
Returns:
|
|
Health status information
|
|
"""
|
|
try:
|
|
logger.info("Performing health check for AIServiceManager")
|
|
|
|
# Test AI functionality with a simple prompt
|
|
test_prompt = "Hello, this is a health check test."
|
|
try:
|
|
test_response = llm_text_gen(test_prompt)
|
|
ai_status = "operational" if test_response else "degraded"
|
|
except Exception as e:
|
|
ai_status = "error"
|
|
logger.warning(f"AI health check failed: {str(e)}")
|
|
|
|
# Get performance metrics
|
|
performance_metrics = self.get_performance_metrics()
|
|
|
|
health_status = {
|
|
'service': 'AIServiceManager',
|
|
'status': 'healthy',
|
|
'capabilities': {
|
|
'content_gap_analysis': 'operational',
|
|
'market_position_analysis': 'operational',
|
|
'keyword_analysis': 'operational',
|
|
'performance_prediction': 'operational',
|
|
'strategic_intelligence': 'operational',
|
|
'content_quality_assessment': 'operational',
|
|
'ai_integration': ai_status
|
|
},
|
|
'performance_metrics': performance_metrics,
|
|
'prompts_loaded': len(self.prompts),
|
|
'schemas_loaded': len(self.schemas),
|
|
'configuration': self.config,
|
|
'timestamp': datetime.utcnow().isoformat()
|
|
}
|
|
|
|
logger.info("AIServiceManager health check passed")
|
|
return health_status
|
|
|
|
except Exception as e:
|
|
logger.error(f"AIServiceManager health check failed: {str(e)}")
|
|
return {
|
|
'service': 'AIServiceManager',
|
|
'status': 'unhealthy',
|
|
'error': str(e),
|
|
'timestamp': datetime.utcnow().isoformat()
|
|
}
|
|
|
|
async def _emit_educational_content(self, service_type: AIServiceType, status: str, error_message: str = None, processing_time: float = None):
|
|
"""
|
|
Emit educational content for frontend during AI calls.
|
|
|
|
Args:
|
|
service_type: Type of AI service being called
|
|
status: Current status (start, success, error)
|
|
error_message: Error message if applicable
|
|
processing_time: Processing time if applicable
|
|
"""
|
|
try:
|
|
educational_content = self._get_educational_content(service_type, status, error_message, processing_time)
|
|
|
|
# Emit to any connected SSE clients
|
|
# This would integrate with your SSE system
|
|
logger.info(f"📚 Emitting educational content for {service_type.value}: {status}")
|
|
|
|
# For now, just log the educational content
|
|
# In a real implementation, this would be sent to connected SSE clients
|
|
logger.debug(f"Educational content: {educational_content}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error emitting educational content: {e}")
|
|
|
|
def _get_educational_content(self, service_type: AIServiceType, status: str, error_message: str = None, processing_time: float = None) -> Dict[str, Any]:
|
|
"""
|
|
Generate educational content based on service type and status.
|
|
|
|
Args:
|
|
service_type: Type of AI service being called
|
|
status: Current status (start, success, error)
|
|
error_message: Error message if applicable
|
|
processing_time: Processing time if applicable
|
|
|
|
Returns:
|
|
Dictionary with educational content
|
|
"""
|
|
base_content = {
|
|
"service_type": service_type.value,
|
|
"status": status,
|
|
"timestamp": datetime.utcnow().isoformat()
|
|
}
|
|
|
|
if status == "start":
|
|
content_map = {
|
|
AIServiceType.STRATEGIC_INTELLIGENCE: {
|
|
"title": "🧠 Strategic Intelligence Analysis",
|
|
"description": "AI is analyzing your market position and identifying strategic opportunities.",
|
|
"details": [
|
|
"🎯 Market positioning analysis",
|
|
"💡 Opportunity identification",
|
|
"📈 Growth potential assessment",
|
|
"🎪 Competitive advantage mapping"
|
|
],
|
|
"insight": "Strategic insights help you understand where you stand in the market and how to differentiate.",
|
|
"ai_prompt_preview": "Analyzing market position, identifying strategic opportunities, assessing growth potential, and mapping competitive advantages...",
|
|
"estimated_time": "15-20 seconds"
|
|
},
|
|
AIServiceType.MARKET_POSITION_ANALYSIS: {
|
|
"title": "🔍 Competitive Intelligence Analysis",
|
|
"description": "AI is analyzing your competitors to identify gaps and opportunities.",
|
|
"details": [
|
|
"🏢 Competitor content strategies",
|
|
"📊 Market gap analysis",
|
|
"🎯 Differentiation opportunities",
|
|
"📈 Industry trend analysis"
|
|
],
|
|
"insight": "Understanding your competitors helps you find unique angles and underserved market segments.",
|
|
"ai_prompt_preview": "Analyzing competitor content strategies, identifying market gaps, finding differentiation opportunities, and assessing industry trends...",
|
|
"estimated_time": "20-25 seconds"
|
|
},
|
|
AIServiceType.PERFORMANCE_PREDICTION: {
|
|
"title": "📊 Performance Forecasting",
|
|
"description": "AI is predicting content performance and ROI based on industry data.",
|
|
"details": [
|
|
"📈 Traffic growth projections",
|
|
"💰 ROI predictions",
|
|
"🎯 Conversion rate estimates",
|
|
"📊 Engagement metrics forecasting"
|
|
],
|
|
"insight": "Performance predictions help you set realistic expectations and optimize resource allocation.",
|
|
"ai_prompt_preview": "Analyzing industry benchmarks, predicting traffic growth, estimating ROI, forecasting conversion rates, and projecting engagement metrics...",
|
|
"estimated_time": "15-20 seconds"
|
|
},
|
|
AIServiceType.CONTENT_SCHEDULE_GENERATION: {
|
|
"title": "📅 Content Calendar Creation",
|
|
"description": "AI is building a comprehensive content schedule optimized for your audience.",
|
|
"details": [
|
|
"📝 Content piece generation",
|
|
"📅 Optimal publishing schedule",
|
|
"🎯 Audience engagement timing",
|
|
"🔄 Content repurposing strategy"
|
|
],
|
|
"insight": "A well-planned content calendar ensures consistent engagement and maximizes content ROI.",
|
|
"ai_prompt_preview": "Generating content pieces, optimizing publishing schedule, determining audience engagement timing, and planning content repurposing...",
|
|
"estimated_time": "25-30 seconds"
|
|
}
|
|
}
|
|
|
|
content = content_map.get(service_type, {
|
|
"title": "🤖 AI Analysis in Progress",
|
|
"description": "AI is processing your data and generating insights.",
|
|
"details": ["Processing data", "Analyzing patterns", "Generating insights"],
|
|
"insight": "AI analysis provides data-driven insights to improve your strategy.",
|
|
"estimated_time": "15-20 seconds"
|
|
})
|
|
|
|
return {**base_content, **content}
|
|
|
|
elif status == "success":
|
|
return {
|
|
**base_content,
|
|
"title": f"✅ {service_type.value.replace('_', ' ').title()} Complete",
|
|
"description": f"Successfully completed {service_type.value.replace('_', ' ')} analysis.",
|
|
"achievement": f"Completed in {processing_time:.1f} seconds",
|
|
"next_step": "Moving to next analysis component..."
|
|
}
|
|
|
|
elif status == "error":
|
|
return {
|
|
**base_content,
|
|
"title": f"⚠️ {service_type.value.replace('_', ' ').title()} Issue",
|
|
"description": f"We encountered an issue with {service_type.value.replace('_', ' ')} analysis.",
|
|
"error": error_message,
|
|
"fallback": "Will use industry best practices for this component."
|
|
}
|
|
|
|
return base_content
|
|
|
|
def _record_metrics(self, service_type: AIServiceType, processing_time: float, success: bool, error_message: str = None):
|
|
"""
|
|
Record metrics for AI service calls.
|
|
|
|
Args:
|
|
service_type: Type of AI service being called
|
|
processing_time: Time taken for the call
|
|
success: Whether the call was successful
|
|
error_message: Error message if applicable
|
|
"""
|
|
try:
|
|
metrics = AIServiceMetrics(
|
|
service_type=service_type,
|
|
response_time=processing_time,
|
|
success=success,
|
|
error_message=error_message
|
|
)
|
|
self.metrics.append(metrics)
|
|
|
|
# Log metrics for monitoring
|
|
if success:
|
|
logger.debug(f"📊 AI metrics recorded for {service_type.value}: {processing_time:.2f}s")
|
|
else:
|
|
logger.warning(f"📊 AI metrics recorded for {service_type.value}: {processing_time:.2f}s (failed)")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error recording AI metrics: {e}") |