updated request body

app/data_sources/wikidata.py

@@ -143,6 +143,71 @@ class WikidataClient:
             
         return result.get("entities", {}).get(entity_id, {})
 
+    async def get_related_entities(
+        self,
+        entity_id: str,
+        relation_type: str = "competitor",
+        language: str = "en",
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Get entities related to the specified entity by a specific relation type.
+        
+        Args:
+            entity_id: The Wikidata entity ID (e.g., "Q478214")
+            relation_type: Type of relation to look for (default: "competitor")
+            language: Language code for labels (default: "en")
+            limit: Maximum number of related entities to return (default: 5)
+            
+        Returns:
+            List of related entities with their details
+        """
+        # Map relation types to Wikidata property IDs
+        relation_properties = {
+            "competitor": "P1592",  # competitor
+            "parent_company": "P749",  # parent organization
+            "subsidiary": "P355",  # subsidiary
+            "industry": "P452",  # industry
+            "product": "P1056"  # product or material produced
+        }
+        
+        property_id = relation_properties.get(relation_type, "P1592")  # Default to competitor
+        
+        # First, get all claims for the entity
+        entity = await self.get_entity_details(entity_id, language=language, properties=["claims"])
+        if "error" in entity:
+            self.logger.error(f"Failed to get entity details: {entity['error']}")
+            return []
+        
+        # Find claims with the specified property
+        claims = entity.get("claims", {}).get(property_id, [])
+        
+        # Extract related entity IDs
+        related_ids = []
+        for claim in claims[:limit]:  # Limit the number of results
+            if claim.get("mainsnak", {}).get("datatype") == "wikibase-item":
+                value = claim.get("mainsnak", {}).get("datavalue", {}).get("value")
+                if value and isinstance(value, dict) and value.get("id"):
+                    related_ids.append(value["id"])
+        
+        if not related_ids:
+            return []
+        
+        # Get details for each related entity
+        related_entities = []
+        for rel_id in related_ids:
+            try:
+                details = await self.get_entity_details(
+                    rel_id,
+                    language=language,
+                    properties=["labels", "descriptions", "claims"]
+                )
+                if details and "error" not in details:
+                    related_entities.append(details)
+            except Exception as e:
+                self.logger.warning(f"Failed to get details for related entity {rel_id}: {str(e)}")
+        
+        return related_entities
+
     async def get_company_info(self, company_name: str, language: str = "en") -> Dict[str, Any]:
         """Get structured information about a company.
         

app/main.py

@@ -45,9 +45,58 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Constants for research modes
+RESEARCH_MODES = {
+    "quick": {
+        "max_tokens": 1000,
+        "time_estimate": "2-3 minutes",
+        "description": "Quick snapshot for rapid insights"
+    },
+    "standard": {
+        "max_tokens": 2500,
+        "time_estimate": "5-7 minutes",
+        "description": "Balanced overview with key insights"
+    },
+    "deep": {
+        "max_tokens": 5000,
+        "time_estimate": "12-15 minutes",
+        "description": "Comprehensive research with detailed analysis"
+    },
+    "custom": {
+        "base_tokens": 1000,
+        "per_insight_tokens": 200,
+        "time_estimate": "Variable",
+        "description": "Custom research based on selected areas"
+    }
+}
+
 # Helper functions
-async def build_system_prompt(company_name: str, insight_selection: List[str], deep_dive: Optional[List[str]] = None) -> str:
-    """Build a robust system prompt for the LLM to generate a single formatted summary."""
+async def build_system_prompt(
+    company_name: str, 
+    insight_selection: List[str], 
+    research_mode: str = "standard",
+    deep_dive: Optional[List[str]] = None
+) -> str:
+    """Build a robust system prompt for the LLM to generate a single formatted summary.
+    
+    Args:
+        company_name: Name of the company to analyze
+        insight_selection: List of insight categories to include
+        research_mode: One of 'quick', 'standard', 'deep', or 'custom'
+        deep_dive: Optional list of categories for deeper analysis
+    """
+    # Validate research mode
+    if research_mode not in RESEARCH_MODES:
+        research_mode = "standard"
+        
+    mode_info = RESEARCH_MODES[research_mode]
+    
+    # Calculate token budget for custom mode
+    if research_mode == "custom":
+        max_tokens = mode_info["base_tokens"] + (len(insight_selection) * mode_info["per_insight_tokens"])
+    else:
+        max_tokens = mode_info["max_tokens"]
+    
     categories = ", ".join(insight_selection)
     deep_dive_text = f"\nFor deeper analysis, focus on: {', '.join(deep_dive)}." if deep_dive else ""
     
@@ -77,27 +126,55 @@ async def build_system_prompt(company_name: str, insight_selection: List[str], d
     )
 
 
-async def generate_insights(company: CompanyData, categories: list, business_name: str = "your business") -> CompetitorInsight:
+async def generate_insights(
+    company: CompanyData, 
+    categories: list, 
+    business_name: str = "your business",
+    research_mode: str = "standard"
+) -> CompetitorInsight:
     """Generate insights for a single company using the LLM.
     
     Args:
         company: The company data to analyze
         categories: List of categories to focus the analysis on
         business_name: Name of the business being analyzed (for context in the prompt)
+        research_mode: One of 'quick', 'standard', 'deep', or 'custom'
     """
     try:
-        system_prompt = await build_system_prompt(company.name, categories)
+        system_prompt = await build_system_prompt(company.name, categories, research_mode)
+        
+        # Get research mode details
+        mode_info = RESEARCH_MODES.get(research_mode, RESEARCH_MODES["standard"])
+        
+        # Prepare context based on research mode
+        analysis_scope = {
+            "quick": "Provide a concise analysis focusing on key highlights and immediate insights.",
+            "standard": "Provide a balanced analysis with key insights and recommendations.",
+            "deep": "Provide a comprehensive, detailed analysis with in-depth insights and strategic recommendations.",
+            "custom": f"Provide analysis focusing on the selected categories: {', '.join(categories)}."
+        }.get(research_mode, "Provide a balanced analysis.")
         
         # Prepare user prompt with company data
         user_prompt = (
-            f"You must ONLY analyze: **{company.name}**\n\n"
-            f"Description: {company.description or 'No description available'}\n"
-            f"Metrics: {company.metrics or 'No metrics available'}\n"
-            f"Notes: {', '.join(company.notes) if company.notes else 'No notes available'}\n\n"
-            f"Please analyze this company's competitive position in the following areas:\n"
+            f"# Company Analysis: {company.name}\n\n"
+            f"## Research Mode: {research_mode.capitalize()}\n"
+            f"{analysis_scope}\n\n"
+            f"## Company Overview\n"
+            f"**Description**: {company.description or 'No description available'}\n"
+            f"**Industry**: {getattr(company, 'industry', 'Not specified')}\n"
+            f"**Location**: {getattr(company, 'location', 'Not specified')}\n"
+            f"**CEO**: {getattr(company, 'ceo', 'Not specified')}\n"
+            f"**Founded**: {getattr(company, 'founded', 'Not available')}\n\n"
+            f"## Analysis Categories\n"
+            f"Please analyze this company's position in the following areas:\n"
             f"• {chr(10)+'• '.join(categories)}\n\n"
-            f"Focus on specific, data-driven insights and actionable recommendations. "
-            f"Compare with {business_name} where relevant."
+            f"## Additional Context\n"
+            f"- Compare with {business_name} where relevant\n"
+            f"- Focus on specific, data-driven insights\n"
+            f"- Include actionable recommendations\n"
+            f"- Be concise yet comprehensive\n\n"
+            f"## Output Format\n"
+            f"Please structure your response with clear headings for each category."
         )
         
         logger.info(f"Generating insights for {company.name}...")
@@ -174,19 +251,51 @@ async def get_company_details(request: CompanyDetailsRequest):
             detail=f"Failed to fetch company details: {str(e)}"
         )
 
+class CompanyAnalysisRequest(BaseModel):
+    """Request model for company analysis."""
+    company_info: Dict[str, Any]
+    research_mode: str = "standard"
+    insight_selection: List[str]
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "company_info": {
+                    "name": "Tesla, Inc.",
+                    "location": "Austin, Texas, USA",
+                    "industry": "Automotive & Energy",
+                    "ceo": "Elon Musk",
+                    "founded": 2003
+                },
+                "research_mode": "standard",
+                "insight_selection": [
+                    "company_profile",
+                    "financials",
+                    "market_position",
+                    "competitors"
+                ]
+            }
+        }
+
 @app.post("/api/v1/analyze", response_model=ReportResponse)
 async def analyze_competitors(
-    payload: UserPayload,
+    payload: CompanyAnalysisRequest,
     background_tasks: BackgroundTasks
 ):
     """
-    Main endpoint for competitor analysis using Wikidata as the data source.
+    Main endpoint for company analysis with configurable research depth.
     
     This endpoint:
-    1. Searches for the company on Wikidata
-    2. Finds competitors through Wikidata's entity relationships
-    3. Fetches detailed information for each competitor
-    4. Generates insights using the LLM
+    1. Validates the research mode and insight selection
+    2. Searches for the company on Wikidata
+    3. Fetches detailed information based on selected insights
+    4. Generates insights using the LLM with appropriate detail level
+    
+    Research Modes:
+    - quick: Brief overview (2-3 minutes)
+    - standard: Balanced analysis (5-7 minutes)
+    - deep: Comprehensive research (12-15 minutes)
+    - custom: Tailored to selected insights (variable time)
     """
     # Initialize Wikidata client
     wikidata = WikidataClient()
@@ -194,10 +303,32 @@ async def analyze_competitors(
     # Generate a unique request ID
     request_id = str(uuid.uuid4())
     
+    # Validate research mode
+    if payload.research_mode not in RESEARCH_MODES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid research mode. Must be one of: {', '.join(RESEARCH_MODES.keys())}"
+        )
+    
+    # Validate insight selection
+    if not payload.insight_selection:
+        raise HTTPException(
+            status_code=400,
+            detail="At least one insight category must be selected"
+        )
+    
     # Get company info
-    company_name = payload.company_info.name
+    company_info = payload.company_info
+    company_name = company_info.get('name')
+    
+    if not company_name:
+        raise HTTPException(
+            status_code=400,
+            detail="Company name is required in company_info"
+        )
     
     try:
+        # Step 1: Search for the company on Wikidata
         # Step 1: Search for the company on Wikidata
         company_search = await wikidata.search_entity(company_name, limit=1)
         if not company_search:
@@ -208,146 +339,164 @@ async def analyze_competitors(
         
         company_id = company_search[0]['id']
         
-        # Step 2: Get company details
+        # Step 2: Get company details with all available properties
         company_details = await wikidata.get_entity_details(company_id)
         
-        # Step 3: Find competitors through Wikidata relationships
+        # Prepare company data for analysis
+        company_data = {
+            'name': str(company_info.get('name', '')),
+            'description': str(company_info.get('description') or 
+                            company_details.get('descriptions', {}).get('en', {}).get('value', '')),
+            'industry': str(company_info.get('industry') or 
+                          ', '.join(company_details.get('industry', []))),
+            'founded': str(company_info.get('founded') or 
+                          company_details.get('inception', 'Not available')),
+            'location': str(company_info.get('location') or 
+                           company_details.get('location', 'Not specified')),
+            'ceo': str(company_info.get('ceo') or 
+                      company_details.get('ceo', 'Not specified')),
+            'website': str(company_details.get('official_website', '')),
+            'metrics': {
+                'revenue': company_details.get('revenue'),
+                'employees': company_details.get('number_of_employees')
+            }
+        }
+        
+        # Step 3: Get competitors if in insight selection
         competitors = []
-        if payload.competitor_choice and payload.competitor_choice.competitors:
-            # Use manually provided competitors
-            for comp_name in payload.competitor_choice.competitors:
-                comp_search = await wikidata.search_entity(comp_name, limit=1)
-                if comp_search:
-                    competitors.append(comp_search[0])
-        else:
-            # Auto-discover competitors
+        if 'competitors' in payload.insight_selection:
             competitors = await wikidata.get_related_entities(
                 company_id, 
                 relation_type='competitor',  # P1592
                 limit=min(5, getattr(settings, 'MAX_COMPETITORS', 5))
             )
+            
+            # Add competitor data to company data
+            company_data['competitors'] = [
+                comp.get('labels', {}).get('en', {}).get('value', 'Unknown')
+                for comp in competitors[:5]  # Limit to top 5
+            ]
         
-        if not competitors:
-            raise HTTPException(
-                status_code=404,
-                detail="No competitors found for analysis"
-            )
-        
-        # Step 4: Get details for each competitor
-        competitor_details = []
-        for comp in competitors:
-            try:
-                details = await wikidata.get_entity_details(comp['id'])
-                competitor_details.append(details)
-            except Exception as e:
-                logger.warning(f"Failed to get details for competitor {comp.get('id')}: {str(e)}")
+        # Step 4: Generate insights using the LLM
+        company_insight = await generate_insights(
+            company=CompanyData(**company_data),
+            categories=payload.insight_selection,
+            business_name=company_name,
+            research_mode=payload.research_mode
+        )
         
-        # Step 5: Generate insights using the LLM
-        tasks = []
-        for comp in competitor_details:
-            # Format the data for the LLM
-            company_data = {
-                'name': comp.get('labels', {}).get('en', {}).get('value', 'Unknown'),
-                'description': comp.get('descriptions', {}).get('en', {}).get('value', ''),
-                'industry': ', '.join(comp.get('industry', [])),
-                'founded': comp.get('inception', ''),
-                'location': comp.get('location', 'Unknown'),
-                'website': comp.get('official_website', '')
-            }
+        # Step 5: Generate competitor insights if needed
+        competitor_insights = []
+        if 'competitors' in payload.insight_selection and competitors:
+            competitor_tasks = []
+            for comp in competitors[:3]:  # Limit to top 3 competitors for analysis
+                try:
+                    comp_details = await wikidata.get_entity_details(comp['id'])
+                    comp_data = {
+                        'name': str(comp.get('labels', {}).get('en', {}).get('value', 'Unknown')),
+                        'description': str(comp_details.get('descriptions', {}).get('en', {}).get('value', '')),
+                        'industry': str(', '.join(comp_details.get('industry', []))),
+                        'founded': str(comp_details.get('inception', '')),
+                        'location': str(comp_details.get('location', 'Unknown')),
+                        'website': str(comp_details.get('official_website', '')),
+                        'metrics': {
+                            'revenue': comp_details.get('revenue'),
+                            'employees': comp_details.get('number_of_employees')
+                        }
+                    }
+                    
+                    task = generate_insights(
+                        company=CompanyData(**comp_data),
+                        categories=payload.insight_selection,
+                        business_name=company_name,
+                        research_mode=payload.research_mode
+                    )
+                    competitor_tasks.append(task)
+                except Exception as e:
+                    logger.warning(f"Failed to process competitor {comp.get('id')}: {str(e)}")
             
-            # Generate insights for this competitor
-            task = generate_insights(
-                company=CompanyData(**company_data),
-                categories=payload.insight_selection,
-                business_name=company_name
-            )
-            tasks.append(task)
+            # Run competitor analysis in parallel
+            if competitor_tasks:
+                competitor_insights = await asyncio.gather(*competitor_tasks, return_exceptions=True)
+                competitor_insights = [ci for ci in competitor_insights if not isinstance(ci, Exception)]
     
-        # Run all tasks concurrently
-        insights = await asyncio.gather(*tasks, return_exceptions=True)
+        # Prepare the response with company and competitor insights
+        combined_summary = f"# {company_name} Analysis Report\n\n"
         
-        # Handle any errors
-        valid_insights = []
-        for i, insight in enumerate(insights):
-            if isinstance(insight, Exception):
-                logger.error(f"Error processing competitor: {str(insight)}")
-            else:
-                valid_insights.append(insight)
+        # Add report metadata
+        mode_info = RESEARCH_MODES.get(payload.research_mode, {})
+        combined_summary += f"## Report Overview\n"
+        combined_summary += f"- **Research Mode**: {payload.research_mode.capitalize()} ({mode_info.get('description', '')})\n"
+        combined_summary += f"- **Generated At**: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}\n"
+        combined_summary += f"- **Analysis Scope**: {', '.join(payload.insight_selection)}\n\n"
         
-        if not valid_insights:
-            raise HTTPException(
-                status_code=500,
-                detail="Failed to generate insights for any competitors"
-            )
-    
-        # Combine all insights into a single, well-formatted summary
-        combined_summary = f"📊 **Competitive Analysis Report**\n\n"
+        # Add company insights
+        combined_summary += "## Company Analysis\n\n"
+        combined_summary += company_insight.summary + "\n\n"
         
-        # Add company and timestamp
-        combined_summary += f"📌 **Company**: {company_name}\n"
-        combined_summary += f"📅 **Date**: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}\n"
-        combined_summary += f"🌐 **Data Source**: Wikidata\n\n"
+        # Add competitor insights if available
+        if competitor_insights:
+            combined_summary += "## Competitive Analysis\n\n"
+            for i, insight in enumerate(competitor_insights, 1):
+                if insight and insight.summary:
+                    combined_summary += f"### {insight.company.name}\n"
+                    # Add a brief summary of the competitor
+                    combined_summary += f"*{insight.company.description or 'No description available'}*\n\n"
+                    
+                    # Add key insights (first 2-3 bullet points)
+                    points = [line.strip() for line in insight.summary.split('•') if line.strip()][:3]
+                    if points:
+                        combined_summary += "**Key Insights**:\n"
+                        for point in points:
+                            combined_summary += f"• {point.strip()}\n"
+                        combined_summary += "\n"
         
-        # Add company details section
-        combined_summary += "## 🏢 Company Overview\n"
-        combined_summary += f"**Name**: {company_details.get('labels', {}).get('en', {}).get('value', company_name)}\n"
-        if 'descriptions' in company_details and 'en' in company_details['descriptions']:
-            combined_summary += f"**Description**: {company_details['descriptions']['en']['value']}\n"
-        if 'inception' in company_details:
-            combined_summary += f"**Founded**: {company_details['inception']}\n"
-        combined_summary += "\n"
+        # Add summary and recommendations
+        combined_summary += "## Summary & Recommendations\n\n"
         
-        # Add competitive landscape section
-        combined_summary += "## 🏆 Competitive Landscape\n"
-        combined_summary += f"Analyzed {len(valid_insights)} competitors in the {payload.business_category} industry.\n\n"
+        # Generate a summary based on research mode
+        if payload.research_mode == "quick":
+            combined_summary += "### Quick Snapshot\n"
+            combined_summary += f"Key highlights and immediate insights about {company_name}.\n\n"
+        elif payload.research_mode == "standard":
+            combined_summary += "### Standard Analysis\n"
+            combined_summary += f"A balanced overview of {company_name}'s position with key insights.\n\n"
+        elif payload.research_mode == "deep":
+            combined_summary += "### Deep Dive Analysis\n"
+            combined_summary += f"Comprehensive research on {company_name} with detailed insights and strategic recommendations.\n\n"
+        else:  # custom
+            combined_summary += f"### Custom Analysis\n"
+            combined_summary += f"Analysis focused on: {', '.join(payload.insight_selection)}.\n\n"
         
-        # Add insights section
-        combined_summary += "## 🔍 Key Insights\n"
-        for i, insight in enumerate(valid_insights[:3]):  # Top 3 competitors
-            if insight.summary:
-                combined_summary += f"### {insight.company.name}\n"
-                # Extract the first 3 bullet points from the summary
-                points = [line.strip() for line in insight.summary.split('•') if line.strip()][:3]
-                for point in points:
-                    combined_summary += f"• {point.strip()}\n"
-                combined_summary += "\n"
+        # Add data sources section
+        combined_summary += "## Data Sources\n\n"
+        combined_summary += "This report was generated using data from the following sources:\n"
+        combined_summary += "1. **Wikidata** - Free and open knowledge base\n"
+        combined_summary += "2. **Public Company Data** - Various public sources\n\n"
         
-        # Add recommendations section
-        combined_summary += "## 💡 Strategic Recommendations\n"
-        for i, insight in enumerate(valid_insights[:3]):  # Top 3 recommendations
-            if insight.category_breakdown:
-                category = next(iter(insight.category_breakdown.keys()), 'their operations')
-                combined_summary += f"{i+1}. Consider {insight.company.name}'s approach to {category}\n"
-        combined_summary += "\n"
+        # Add disclaimer
+        combined_summary += "*Note: This report is for informational purposes only and should not be considered as financial or investment advice.*\n"
         
-        # Add data sources section
-        combined_summary += "## 🔗 Data Sources\n"
-        combined_summary += "This analysis was generated using data from the following sources:\n"
-        combined_summary += "1. Wikidata - Free and open knowledge base\n"
-        combined_summary += "2. Additional public data sources\n\n"
+        # Check if PDF export is requested
+        pdf_url = None
+        if hasattr(payload, 'preferences') and payload.preferences and hasattr(payload.preferences, 'export_format') and payload.preferences.export_format == 'pdf':
+            pdf_url = f"/api/v1/exports/{request_id}.pdf"
+            # In a real implementation, you would generate the PDF here
+            # background_tasks.add_task(generate_pdf_export, request_id, combined_summary, [])
         
-        # Prepare the final response with the combined summary
+        # Prepare the final response
         report = ReportResponse(
             request_id=request_id,
             company_name=company_name,
             generated_at=datetime.utcnow().isoformat(),
             summary=combined_summary,
-            metrics=[],  # Not used in this implementation
-            insights=[],  # Not used in this implementation
-            recommendations=[],  # Not used in this implementation
+            metrics=company_insight.metrics if hasattr(company_insight, 'metrics') else [],
+            insights=[],  # Individual insights are included in the summary
+            recommendations=[],  # Recommendations are included in the summary
             sources=[],  # Sources are included in the summary
-            pdf_url=f"/api/v1/exports/{request_id}.pdf" if (payload.preferences and payload.preferences.export_format == 'pdf') else None
+            pdf_url=pdf_url
         )
         
-        # Handle export if requested
-        if payload.preferences and payload.preferences.export_format:
-            export_format = payload.preferences.export_format.lower()
-            logger.info(f"Export requested in format: {export_format}")
-            
-            if export_format == 'pdf':
-                # In a real implementation, generate PDF here
-                report.pdf_url = f"/api/v1/exports/{request_id}.pdf"
-        
         return report
         
     except HTTPException: