diff --git a/backend/api/analysis_templates.py b/backend/api/analysis_templates.py index 1b2a0ec..22abe1c 100644 --- a/backend/api/analysis_templates.py +++ b/backend/api/analysis_templates.py @@ -31,6 +31,154 @@ logger = logging.getLogger(__name__) router = APIRouter(prefix="/api/templates", tags=["Analysis Templates"]) +# Response models (defined before endpoint decorators) +class MultiTemplateAnalysisResult(BaseModel): + """Result from analyzing content with multiple templates.""" + template_set_id: str + template_set_name: str + results: Dict[str, TemplateAnalysisResult] + synthesis_result: Optional[TemplateAnalysisResult] = None + total_processing_time_seconds: float + +# Request/Response models (defined before endpoints that use them) +class TestEducationalRequest(BaseModel): + content: str = Field(..., min_length=50, description="Content to analyze") + +class AnalyzeWithTemplateSetRequest(BaseModel): + """Request to analyze content with a template set.""" + content: str = Field(..., description="Content to analyze", min_length=10) + template_set_id: str = Field(..., description="Template set ID to use") + context: Dict[str, Any] = Field(default_factory=dict, description="Additional context variables") + include_synthesis: bool = Field(default=True, description="Whether to include synthesis of results") + video_id: Optional[str] = Field(None, description="Video ID if analyzing video content") + +# Dependencies (defined before endpoints that use them) +async def get_template_agent() -> TemplateDrivenAgent: + """Get template-driven agent instance.""" + return TemplateDrivenAgent(template_registry=DEFAULT_REGISTRY) + +# Test endpoint without auth for development +@router.post("/test-educational", summary="Test educational analysis (no auth)") +async def test_educational_analysis( + request: TestEducationalRequest +): + """Test educational analysis without authentication - DEVELOPMENT ONLY.""" + try: + # Use the educational template set + from ..services.template_driven_agent import TemplateDrivenAgent + + # Create agent with registry (will automatically use multi-key services) + agent = TemplateDrivenAgent(template_registry=DEFAULT_REGISTRY) + + # Process templates using analyze_with_template_set (will run in parallel with separate keys) + results = await agent.analyze_with_template_set( + content=request.content, + template_set_id="educational_perspectives", # The ID of the educational template set + context={ + "content_type": "video content", + "topic": "the analyzed topic" + } + ) + + # Format results for response + formatted_results = {} + for template_id, result in results.items(): + formatted_results[template_id] = { + "template_name": result.template_name, + "summary": result.analysis[:200] + "..." if len(result.analysis) > 200 else result.analysis, + "key_insights": result.key_insights[:3] if result.key_insights else [], + "confidence": result.confidence_score + } + + # Try to synthesize results if we have them + synthesis_summary = None + if len(results) == 3: # All three educational perspectives + synthesis_summary = f"Successfully analyzed content from {len(results)} educational perspectives: Beginner's Lens, Expert's Lens, and Scholar's Lens." + + return { + "status": "success", + "perspectives": formatted_results, + "synthesis": synthesis_summary, + "message": f"Educational orchestration is working! Processed {len(results)} templates successfully." + } + except Exception as e: + logger.error(f"Test analysis failed: {e}") + return {"status": "error", "message": str(e)} + + +# Educational analysis endpoint with authentication and full synthesis +@router.post("/analyze-educational", response_model=MultiTemplateAnalysisResult) +async def analyze_educational_content( + request: AnalyzeWithTemplateSetRequest, + background_tasks: BackgroundTasks, + agent: TemplateDrivenAgent = Depends(get_template_agent), + current_user: User = Depends(get_current_user) +): + """ + Analyze content with educational perspectives (Beginner, Expert, Scholar). + Uses multi-key parallel processing for optimal performance. + """ + try: + import time + start_time = time.time() + + # Force educational template set + template_set_id = "educational_perspectives" + + # Analyze with educational template set (parallel with 3 API keys) + results = await agent.analyze_with_template_set( + content=request.content, + template_set_id=template_set_id, + context={ + **request.context, + "content_type": request.context.get("content_type", "video content"), + "topic": request.context.get("topic", "the subject matter") + }, + video_id=request.video_id + ) + + # Always synthesize educational results with dedicated timeout + synthesis_result = None + if len(results) >= 2: # Synthesize even with partial results + try: + # Start synthesis immediately when we have results, with full 180s timeout + logger.info(f"Starting synthesis for {len(results)} perspectives - user {current_user.id}") + synthesis_result = await agent.synthesize_results( + results=results, + template_set_id=template_set_id, + context=request.context + ) + logger.info(f"Educational synthesis completed successfully for user {current_user.id}") + except Exception as syn_err: + logger.warning(f"Synthesis failed but continuing: {syn_err}") + # Continue without synthesis rather than failing completely + + total_processing_time = time.time() - start_time + + # Get template set info + template_set = DEFAULT_REGISTRY.get_template_set(template_set_id) + template_set_name = template_set.name if template_set else "Educational Perspectives" + + # Store analysis in database if requested + if request.context.get("store_results", False) and request.video_id: + # TODO: Store template analysis with video summary + pass + + result = MultiTemplateAnalysisResult( + template_set_id=template_set_id, + template_set_name=template_set_name, + results=results, + synthesis_result=synthesis_result, + total_processing_time_seconds=total_processing_time + ) + + logger.info(f"Educational analysis completed in {total_processing_time:.2f}s for user {current_user.id}") + return result + + except Exception as e: + logger.error(f"Educational analysis failed for user {current_user.id}: {e}") + raise HTTPException(status_code=500, detail=str(e)) + # Request/Response Models class AnalyzeWithTemplateRequest(BaseModel): @@ -41,22 +189,8 @@ class AnalyzeWithTemplateRequest(BaseModel): video_id: Optional[str] = Field(None, description="Video ID if analyzing video content") -class AnalyzeWithTemplateSetRequest(BaseModel): - """Request to analyze content with a template set.""" - content: str = Field(..., description="Content to analyze", min_length=10) - template_set_id: str = Field(..., description="Template set ID to use") - context: Dict[str, Any] = Field(default_factory=dict, description="Additional context variables") - include_synthesis: bool = Field(default=True, description="Whether to include synthesis of results") - video_id: Optional[str] = Field(None, description="Video ID if analyzing video content") -class MultiTemplateAnalysisResult(BaseModel): - """Result from analyzing content with multiple templates.""" - template_set_id: str - template_set_name: str - results: Dict[str, TemplateAnalysisResult] - synthesis_result: Optional[TemplateAnalysisResult] = None - total_processing_time_seconds: float class CreateTemplateRequest(BaseModel): @@ -127,9 +261,6 @@ class OrchestrationResultResponse(BaseModel): # Dependencies -async def get_template_agent() -> TemplateDrivenAgent: - """Get template-driven agent instance.""" - return TemplateDrivenAgent(template_registry=DEFAULT_REGISTRY) async def get_enhanced_orchestrator() -> EnhancedMultiAgentOrchestrator: diff --git a/backend/services/template_driven_agent.py b/backend/services/template_driven_agent.py index 08384dd..2725929 100644 --- a/backend/services/template_driven_agent.py +++ b/backend/services/template_driven_agent.py @@ -48,8 +48,44 @@ class TemplateDrivenAgent: """Initialize the template-driven agent.""" self.ai_service = ai_service or DeepSeekService() self.template_registry = template_registry or DEFAULT_REGISTRY + + # Create separate AI services for parallel processing with different API keys + self._ai_services = self._initialize_multi_key_services() self._usage_stats: Dict[str, int] = {} + def _initialize_multi_key_services(self) -> Dict[str, DeepSeekService]: + """Initialize multiple DeepSeek services with different API keys for parallel processing.""" + import os + from dotenv import load_dotenv + + # Ensure environment variables are loaded + load_dotenv() + + services = {} + + # Map specific templates to specific API keys for load balancing + template_key_mapping = { + "educational_beginner": os.getenv("DEEPSEEK_API_KEY_1"), + "educational_expert": os.getenv("DEEPSEEK_API_KEY_2"), + "educational_scholarly": os.getenv("DEEPSEEK_API_KEY_3") + } + + logger.info(f"Initializing multi-key services...") + logger.info(f"Available API keys: {[k for k, v in template_key_mapping.items() if v]}") + + for template_id, api_key in template_key_mapping.items(): + if api_key: + try: + services[template_id] = DeepSeekService(api_key=api_key) + logger.info(f"Initialized dedicated AI service for {template_id} with key: {api_key[:10]}...") + except Exception as e: + logger.warning(f"Failed to initialize AI service for {template_id}: {e}") + else: + logger.warning(f"No API key found for {template_id}") + + logger.info(f"Successfully initialized {len(services)} dedicated AI services") + return services + async def analyze_with_template( self, request: TemplateAnalysisRequest @@ -80,13 +116,16 @@ class TemplateDrivenAgent: # Create analysis prompt analysis_prompt = self._create_analysis_prompt(template, request.content, analysis_context) + # Use dedicated AI service for this template if available, otherwise use default + ai_service = self._ai_services.get(request.template_id, self.ai_service) + # Generate analysis using AI service - ai_response = await self.ai_service.generate_summary({ - "prompt": analysis_prompt, - "system_prompt": system_prompt, - "max_tokens": 2000, - "temperature": 0.7 - }) + ai_response = await ai_service.generate_response( + prompt=analysis_prompt, + system_prompt=system_prompt, + max_tokens=2000, + temperature=0.7 + ) # Parse the response to extract insights key_insights = self._extract_insights(ai_response, template) @@ -112,7 +151,9 @@ class TemplateDrivenAgent: ) except Exception as e: + import traceback logger.error(f"Error in template analysis {request.template_id}: {e}") + logger.error(f"Full traceback for {request.template_id}: {traceback.format_exc()}") raise ServiceError(f"Template analysis failed: {str(e)}") async def analyze_with_template_set( @@ -150,7 +191,8 @@ class TemplateDrivenAgent: template_ids = [t.id for t in template_set.templates.values() if t.is_active] for i, result in enumerate(parallel_results): if isinstance(result, Exception): - logger.error(f"Template {template_ids[i]} failed: {result}") + logger.error(f"Template {template_ids[i]} failed with exception: {type(result).__name__}: {str(result)}") + logger.error(f"Full error details for {template_ids[i]}: {result}") else: results[template_ids[i]] = result else: @@ -182,22 +224,78 @@ class TemplateDrivenAgent: """Synthesize results from multiple template analyses.""" template_set = self.template_registry.get_template_set(template_set_id) if not template_set or not template_set.synthesis_template: + logger.warning(f"No synthesis template found for template set: {template_set_id}") return None + logger.info(f"Starting synthesis for {len(results)} results using template: {template_set.synthesis_template.id}") + # Prepare synthesis context synthesis_context = context or {} for result_id, result in results.items(): synthesis_context[f"{result_id}_analysis"] = result.analysis synthesis_context[f"{result_id}_insights"] = result.key_insights - # Perform synthesis - request = TemplateAnalysisRequest( - content="", # Synthesis works with previous results - template_id=template_set.synthesis_template.id, - context=synthesis_context - ) + # Perform synthesis with dedicated timeout and original API key + start_time = datetime.utcnow() - return await self.analyze_with_template(request) + try: + # Use the original AI service (not multi-key services) for synthesis to ensure proper timeout + template = template_set.synthesis_template + + # Prepare context with content and template variables + analysis_context = { + **template.variables, + **synthesis_context, + "content": "", # Synthesis works with previous results + "video_id": synthesis_context.get("video_id", "unknown") + } + + # Render the system prompt with context + system_prompt = template.render_prompt(analysis_context) + + # Create analysis prompt for synthesis + synthesis_prompt = self._create_synthesis_prompt(template, results, analysis_context) + + logger.info(f"Synthesis using original AI service with full 180s timeout") + + # Generate synthesis using original AI service (with 180s timeout) + ai_response = await self.ai_service.generate_response( + prompt=synthesis_prompt, + system_prompt=system_prompt, + max_tokens=2500, # Longer for synthesis + temperature=0.7 + ) + + # Parse the response to extract insights + key_insights = self._extract_insights(ai_response, template) + + # Calculate processing time + processing_time = (datetime.utcnow() - start_time).total_seconds() + + # Update usage statistics + self._update_usage_stats(template.id) + + # Calculate confidence score based on response quality + confidence_score = self._calculate_confidence_score(ai_response, template) + + logger.info(f"Synthesis completed in {processing_time:.2f}s") + + return TemplateAnalysisResult( + template_id=template.id, + template_name=template.name, + analysis=ai_response, + key_insights=key_insights, + confidence_score=confidence_score, + processing_time_seconds=processing_time, + context_used=analysis_context, + template_variables=template.variables + ) + + except Exception as e: + import traceback + logger.error(f"Synthesis failed after {(datetime.utcnow() - start_time).total_seconds():.2f}s: {e}") + logger.error(f"Full synthesis traceback: {traceback.format_exc()}") + raise ServiceError(f"Synthesis failed: {str(e)}") def _create_analysis_prompt( self, @@ -224,6 +322,51 @@ Analysis Instructions: Expected Output Format: {template.output_format} +""" + + def _create_synthesis_prompt( + self, + template: AnalysisTemplate, + results: Dict[str, TemplateAnalysisResult], + context: Dict[str, Any] + ) -> str: + """Create the synthesis prompt for combining multiple analyses.""" + + # Build synthesis input from all results + synthesis_input = [] + for result_id, result in results.items(): + template_name = result.template_name + synthesis_input.append(f"## {template_name} Analysis") + synthesis_input.append(result.analysis) + synthesis_input.append("\n### Key Insights:") + for insight in result.key_insights: + synthesis_input.append(f"- {insight}") + synthesis_input.append("") # Empty line between analyses + + return f""" +You are tasked with synthesizing multiple educational perspective analyses into a unified comprehensive understanding. + +## Input Analyses +{chr(10).join(synthesis_input)} + +## Synthesis Instructions: +- Combine insights from all perspectives into a unified educational journey +- Identify common themes and complementary viewpoints +- Resolve any apparent contradictions by providing nuanced explanations +- Create a progressive learning path from beginner to advanced understanding +- Generate between {template.min_insights} and {template.max_insights} unified insights +- Target audience: {template.target_audience} +- Tone: {template.tone} +- Depth: {template.depth} +- Focus areas: {', '.join(template.analysis_focus)} + +{'Include practical examples that bridge different learning levels.' if template.include_examples else ''} +{'Provide actionable learning recommendations.' if template.include_recommendations else ''} + +## Expected Output Format: +{template.output_format} + +Create a synthesis that honors the unique value of each perspective while creating a cohesive educational experience. """ def _extract_insights(self, response: str, template: AnalysisTemplate) -> List[str]: diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 0e48f5f..4a153dc 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -25,6 +25,7 @@ import TemplateDemo from '@/pages/TemplateDemo'; import { VideoChatPage } from '@/pages/VideoChatPage'; import { TranscriptionView } from '@/pages/TranscriptionView'; import { ConditionalProtectedRoute } from '@/components/auth/ConditionalProtectedRoute'; +import EducationalAnalysisView from '@/components/EducationalAnalysisView'; const queryClient = new QueryClient({ defaultOptions: { @@ -59,6 +60,13 @@ function App() { } /> } /> + {/* Educational Analysis - Protected route with new multi-agent system */} + + + + } /> + {/* Main app routes - conditionally protected */} diff --git a/frontend/src/api/templatesAPI.ts b/frontend/src/api/templatesAPI.ts new file mode 100644 index 0000000..b1d4d30 --- /dev/null +++ b/frontend/src/api/templatesAPI.ts @@ -0,0 +1,158 @@ +/** + * API client for template-based analysis endpoints + */ +import { apiClient } from './client'; + +export interface TemplateAnalysisRequest { + content: string; + template_set_id?: string; + include_synthesis?: boolean; + context?: Record; + video_id?: string; +} + +export interface TemplateAnalysisResult { + template_id: string; + template_name: string; + analysis: string; + key_insights: string[]; + confidence_score: number; + processing_time_seconds: number; +} + +export interface MultiTemplateAnalysisResult { + template_set_id: string; + template_set_name: string; + results: Record; + synthesis_result?: TemplateAnalysisResult; + total_processing_time_seconds: number; +} + +export interface Template { + id: string; + name: string; + description: string; + template_type: string; + complexity_level?: string; + target_audience: string; + tone: string; + depth: string; + tags: string[]; +} + +export interface TemplateSet { + id: string; + name: string; + description: string; + template_type: string; + templates: Record; +} + +class TemplatesAPI { + /** + * Analyze content with educational perspectives (authenticated) + * Uses multi-key parallel processing for optimal performance + */ + async analyzeEducational(request: TemplateAnalysisRequest): Promise { + const response = await apiClient.post('/api/templates/analyze-educational', { + ...request, + template_set_id: 'educational_perspectives', // Force educational template set + include_synthesis: true, // Always synthesize for educational analysis + }); + return response.data; + } + + /** + * Analyze content with a specific template set (authenticated) + */ + async analyzeWithTemplateSet(request: TemplateAnalysisRequest): Promise { + const response = await apiClient.post('/api/templates/analyze-set', request); + return response.data; + } + + /** + * Analyze content with a single template (authenticated) + */ + async analyzeWithTemplate( + content: string, + template_id: string, + context: Record = {}, + video_id?: string + ): Promise { + const response = await apiClient.post('/api/templates/analyze', { + content, + template_id, + context, + video_id, + }); + return response.data; + } + + /** + * Get list of available templates + */ + async listTemplates(template_type?: string, active_only: boolean = true): Promise { + const params = new URLSearchParams(); + if (template_type) params.append('template_type', template_type); + if (active_only) params.append('active_only', 'true'); + + const response = await apiClient.get(`/api/templates/list?${params.toString()}`); + return response.data; + } + + /** + * Get list of available template sets + */ + async listTemplateSets(template_type?: string, active_only: boolean = true): Promise { + const params = new URLSearchParams(); + if (template_type) params.append('template_type', template_type); + if (active_only) params.append('active_only', 'true'); + + const response = await apiClient.get(`/api/templates/sets?${params.toString()}`); + return response.data; + } + + /** + * Get a specific template by ID + */ + async getTemplate(template_id: string): Promise