upload app folder

app/config/domain_mapping.yaml

@@ -0,0 +1,718 @@
+STARTUP_SECTOR_GROUPS:
+  "Healthcare & MedTech":
+    - HealthTech
+    - MedTech
+    - Health
+    - Digital Health
+    - Telehealth
+    - Telemedicine
+    - Mental Health
+    - Clinical AI
+    - Medical
+    - Medical Admin
+    - Medical Coding
+    - Medical Imaging
+    - Doctor Booking
+    - Hospital Mgmt
+    - Hospital System
+    - Home Health
+    - Chronic Care
+    - Diagnostics
+    - Dental
+    - Dental Tech
+    - Elderly Care
+    - FemTech
+    - Health Data
+    - Health IT
+    - Health Insurance
+    - Community Health
+    - Public Health
+    - Pharmacy
+    - e-Pharmacy
+    - Home Care
+    - Mobile Health
+    - Patient Engagement
+    - Patient Comm
+    - Patient Support
+    - Teleradiology
+    - Wearable
+    - Nutrition
+    - Queue Mgmt
+    - Queue Management
+    - Scheduling
+    - Appointment Booking
+    - Booking
+    - Booking Software
+
+  "FinTech & Finance":
+    - FinTech
+    - Finance
+    - Banking
+    - Banking API
+    - Neobank
+    - Core Banking
+    - Payments
+    - Payments API
+    - Mobile Payments
+    - Global Payments
+    - Cross-Border Payments
+    - Crypto
+    - DeFi
+    - Lending
+    - P2P Lending
+    - Micro-Lending
+    - BNPL
+    - Insurance
+    - InsureTech
+    - Payroll
+    - Tax
+    - Personal Finance
+    - Wealth Tech
+    - Robo-Advisor
+    - Accounting
+    - Invoicing
+    - Billing
+    - Expense Management
+    - Corporate Card
+    - Cash Flow Mgmt
+    - Investment Platform
+    - Stock Trading
+    - Crypto Trading
+
+  "Developer Tools":
+    - DevTools
+    - Dev
+    - API
+    - API Platform
+    - Backend
+    - CI/CD
+    - Cloud
+    - Cloud Computing
+    - Cloud Hosting
+    - Cloud Infrastructure
+    - Code Gen
+    - Coding
+    - Database
+    - DevOps
+    - Framework
+    - Frontend
+    - GraphQL Engine
+    - IDE
+    - Infrastructure
+    - Kubernetes
+    - Monitoring
+    - Open Source
+    - Serverless Database
+    - Testing
+    - Version Control
+    - Error Monitoring
+
+  "AI & Automation":
+    - AI
+    - AI API
+    - AI Agent
+    - AI Analytics
+    - AI Assistant
+    - AI Automation
+    - AI Builder
+    - AI Content
+    - AI Design
+    - AI Infrastructure
+    - AI Writing
+    - AI workflows
+    - Automation
+    - Autonomous Agents
+    - Generative AI
+    - LLM
+    - LLM API
+    - Machine Learning
+    - ML Ops
+    - NLP
+    - Deep Learning
+    - Edge AI
+    - No-Code AI
+    - Industrial AI
+    - Real-Time AI
+
+  "Marketing & Sales":
+    - MarketingTech
+    - Marketing
+    - Marketing Automation
+    - Marketing Suite
+    - Digital Marketing
+    - Email Marketing
+    - SMS Marketing
+    - SEO
+    - SEO AI
+    - SEO Tool
+    - CRM
+    - CRM Automation
+    - Sales AI
+    - Sales Automation
+    - Lead Gen
+    - Lead Generation
+    - Ad Tech
+    - Ad Automation
+    - Content
+    - Content AI
+    - Content Creation
+    - Copywriting
+    - Conversion
+
+  "HR & Recruitment":
+    - HR Tech
+    - HRIS
+    - HRMS
+    - HCM
+    - HR Software
+    - Global HR
+    - Recruitment
+    - Recruitment AI
+    - Hiring
+    - Staffing
+    - Payroll
+    - Employee Engagement
+    - Employee Experience
+    - Performance Mgmt
+    - People Analytics
+    - L&D
+    - LMS
+    - Skill Development
+    - Career
+    - Career Coaching
+    - Onboarding
+    - Workforce Management
+
+  "E-commerce & Retail":
+    - E-commerce
+    - Ecommerce
+    - Retail
+    - Headless Commerce
+    - Social Commerce
+    - Live Shopping
+    - Quick Commerce
+    - On-Demand Delivery
+    - Delivery App
+    - Food Delivery
+    - Marketplace
+    - Inventory
+    - Checkout
+    - Shopping
+    - Price Comparison
+    - Loyalty
+    - Loyalty Program
+    - Store Builder
+    - B2B Retail
+
+  "Productivity & PM":
+    - Productivity
+    - Project Management
+    - Task Management
+    - Work Management
+    - Workflow
+    - Workflow Automation
+    - Calendar
+    - Scheduling
+    - Enterprise Scheduling
+    - Time Tracking
+    - Collaboration
+    - Team Chat
+    - Team Workspace
+    - Note Taking
+    - Knowledge
+    - Knowledge Management
+    - Document Management
+    - Document AI
+    - Forms
+    - Kanban Boards
+    - OKRs
+    - Goal Management
+
+  "Education & Learning":
+    - EdTech
+    - Education
+    - E-learning
+    - Learning
+    - LMS
+    - Course Platform
+    - Tutoring
+    - AI Tutor
+    - K-12 Education
+    - Language Learning
+    - Coding Bootcamp
+    - Microlearning
+    - Virtual Classroom
+    - Teacher Assistant
+
+  "Travel & Tourism":
+    - TravelTech
+    - Travel
+    - Flight Booking
+    - Hotel Tech
+    - OTA
+    - Tour Marketplace
+    - Trip Planning
+    - Accommodation
+    - Short-Term Rentals
+    - Vacation Rentals
+    - Hospitality
+    - Adventure Travel
+    - Business Travel
+    - AI Travel Agent
+    - AI Trip Planner
+
+  "Logistics & Supply Chain":
+    - Logistics
+    - Supply Chain
+    - Last-Mile
+    - Last-Mile Delivery
+    - Freight
+    - Freight Marketplace
+    - Trucking Marketplace
+    - Shipping Services
+    - Cargo Tech
+    - Inventory Mgmt
+    - Procurement
+    - WMS
+    - TMS
+
+  "Real Estate & Construction":
+    - Real Estate
+    - Real Estate Marketplace
+    - Property Management
+    - Property Mgmt
+    - Property Inspection
+    - Fractional Real Estate
+    - Rental Management
+    - Student Housing
+    - Flexible Housing
+    - Construction
+    - Construction Tech
+    - Facility Management
+
+  "Social & Community":
+    - Social Media
+    - Social Network
+    - Community
+    - Community Platform
+    - Community Builder
+    - Community Management
+    - Niche Community
+    - Professional Network
+    - Professional Networking
+    - Non-Profit
+    - Impact Investing
+    - Civic Tech
+    - Democracy
+    - Humanitarian Aid
+
+  "Design & Creative":
+    - Design Tools
+    - Design
+    - UI Design
+    - UI Builder
+    - UI/UX Design
+    - Graphic Design
+    - Vector Design
+    - Animation
+    - 3D Design
+    - 3D Printing
+    - Video Editing
+    - Photo Editing
+    - Image Gen
+    - Creative Automation
+    - Motion Design
+    - Illustration
+    - Presentation AI
+    - Diagramming
+    - Whiteboard
+
+  "Agriculture & Environment":
+    - AgriTech
+    - Agriculture
+    - Sustainable Agriculture
+    - Farm Management
+    - Precision Farming
+    - Fisheries
+    - Environment
+    - CleanTech
+    - Solar Energy
+    - Energy Management
+    - Carbon Accounting
+    - Sustainability
+    - Waste Mgmt
+    - Water
+    - Green Finance
+    - Recycling
+
+  "Government & Public Services":
+    - Civic Tech
+    - GovTech
+    - e-Governance
+    - Public Health
+    - Public Safety
+    - Digital Identity
+    - Open Data
+    - Geospatial
+    - GIS
+    - Urban Planning
+    - Smart Cities
+    - Smart Infrastructure
+    - Mass Transit
+    - Smart Mobility
+
+  "Mobility & Transportation":
+    - MobilityTech
+    - Mobility
+    - Ride Hailing
+    - Carpooling
+    - Car Sharing
+    - Car Rental
+    - EV
+    - Charging
+    - Connected Car
+    - Air Mobility
+    - eVTOL
+    - Maritime Tracking
+    - Drones
+    - Navigation
+    - Traffic App
+    - Transport Booking
+
+  "Food & Beverage":
+    - FoodTech
+    - Food Delivery
+    - Restaurant
+    - Restaurant Tech
+    - Cloud Kitchens
+    - E-Grocery
+    - Meal Planning
+    - Nutrition
+    - Cooking
+    - B2B Food Supply
+
+  "Security & Privacy":
+    - Cybersecurity
+    - Security
+    - Cloud Security
+    - Privacy
+    - Privacy AI
+    - Privacy Compliance
+    - Authentication
+    - Identity Verification
+    - Secure Messaging
+    - Compliance
+    - Fraud Prevention
+    - Safety
+    - Public Safety
+
+  "Media & Entertainment":
+    - Media
+    - Entertainment
+    - Music
+    - Music Streaming
+    - Podcasting
+    - Video
+    - Video Streaming
+    - Live Streaming
+    - Gaming
+    - Gamification
+    - Books
+    - E-books
+    - Audiobooks
+    - News
+    - Newsletter
+    - Digital Publishing
+
+
+PROBLEM_TO_STARTUP_GROUPS:
+  Healthcare:
+    - Healthcare & MedTech
+    - AI & Automation
+  Health:
+    - Healthcare & MedTech
+    - AI & Automation
+  healthcare:
+    - Healthcare & MedTech
+    - AI & Automation
+  "Tourism / Healthcare":
+    - Healthcare & MedTech
+    - Travel & Tourism
+  "Healthcare / Education":
+    - Healthcare & MedTech
+    - Education & Learning
+  "Environment / Health":
+    - Healthcare & MedTech
+    - Agriculture & Environment
+  Veterinary:
+    - Healthcare & MedTech
+  Finance:
+    - FinTech & Finance
+    - AI & Automation
+  Fintech:
+    - FinTech & Finance
+    - AI & Automation
+  "Finance / Legal":
+    - FinTech & Finance
+    - Government & Public Services
+  "Finance / Real Estate":
+    - FinTech & Finance
+    - Real Estate & Construction
+  "Insurance / Fintech":
+    - FinTech & Finance
+  "Financial Services":
+    - FinTech & Finance
+  Economy:
+    - FinTech & Finance
+  Transportation:
+    - Mobility & Transportation
+    - Logistics & Supply Chain
+  transportation:
+    - Mobility & Transportation
+    - Logistics & Supply Chain
+  Transport:
+    - Mobility & Transportation
+    - Logistics & Supply Chain
+  Logistics:
+    - Logistics & Supply Chain
+    - Mobility & Transportation
+  "Supply Chain":
+    - Logistics & Supply Chain
+  "Tourism / Transport":
+    - Mobility & Transportation
+    - Travel & Tourism
+  Automotive:
+    - Mobility & Transportation
+  Auto:
+    - Mobility & Transportation
+  Education:
+    - Education & Learning
+    - AI & Automation
+  education:
+    - Education & Learning
+    - AI & Automation
+  "Education / Employment":
+    - Education & Learning
+    - HR & Recruitment
+  "Education / Innovation":
+    - Education & Learning
+    - AI & Automation
+  "Education / Research":
+    - Education & Learning
+  "Family / Education":
+    - Education & Learning
+  Government:
+    - Government & Public Services
+    - AI & Automation
+  GovTech:
+    - Government & Public Services
+  "GovTech / Legal":
+    - Government & Public Services
+  "Public Services":
+    - Government & Public Services
+  "public administration":
+    - Government & Public Services
+  "Public Administration":
+    - Government & Public Services
+  "Smart City":
+    - Government & Public Services
+  "Smart Cities":
+    - Government & Public Services
+  "Urban Planning":
+    - Government & Public Services
+  "Urban Infrastructure":
+    - Government & Public Services
+  "urban infrastructure":
+    - Government & Public Services
+  Agriculture:
+    - Agriculture & Environment
+    - AI & Automation
+  agriculture:
+    - Agriculture & Environment
+  "Agriculture / Industry":
+    - Agriculture & Environment
+  "Energy / Agriculture":
+    - Agriculture & Environment
+  Agri:
+    - Agriculture & Environment
+  Environment:
+    - Agriculture & Environment
+  environment:
+    - Agriculture & Environment
+  Energy:
+    - Agriculture & Environment
+  "Energy/Mining":
+    - Agriculture & Environment
+  Waste:
+    - Agriculture & Environment
+  Water:
+    - Agriculture & Environment
+  "Real Estate":
+    - Real Estate & Construction
+  Construction:
+    - Real Estate & Construction
+  Housing:
+    - Real Estate & Construction
+  "Real Estate / Services":
+    - Real Estate & Construction
+  "Real Estate / Hospitality":
+    - Real Estate & Construction
+    - Travel & Tourism
+  "Housing / Legal":
+    - Real Estate & Construction
+  Retail:
+    - E-commerce & Retail
+  Commerce:
+    - E-commerce & Retail
+  commerce:
+    - E-commerce & Retail
+  Trade:
+    - E-commerce & Retail
+  Legal:
+    - Government & Public Services
+    - AI & Automation
+  Law:
+    - Government & Public Services
+  "Technology / Legal":
+    - Developer Tools
+    - Government & Public Services
+  "Business / Legal":
+    - Government & Public Services
+  Employment:
+    - HR & Recruitment
+    - AI & Automation
+  "Gig Economy":
+    - HR & Recruitment
+  Labor:
+    - HR & Recruitment
+  HR:
+    - HR & Recruitment
+  "Food & Beverage":
+    - Food & Beverage
+    - E-commerce & Retail
+  Food:
+    - Food & Beverage
+  Hospitality:
+    - Food & Beverage
+    - Travel & Tourism
+  Tourism:
+    - Travel & Tourism
+  Travel:
+    - Travel & Tourism
+  Recreation:
+    - Travel & Tourism
+    - Media & Entertainment
+  Manufacturing:
+    - AI & Automation
+    - Logistics & Supply Chain
+  Industry:
+    - AI & Automation
+    - Logistics & Supply Chain
+  "Industry / Manufacturing":
+    - AI & Automation
+    - Logistics & Supply Chain
+  Technology:
+    - Developer Tools
+    - AI & Automation
+  Tech:
+    - Developer Tools
+    - AI & Automation
+  "digital & telecom":
+    - Developer Tools
+    - Media & Entertainment
+  Telecommunications:
+    - Developer Tools
+    - Media & Entertainment
+  Telecom:
+    - Developer Tools
+    - Media & Entertainment
+  Social:
+    - Social & Community
+  Non-Profit:
+    - Social & Community
+  "Social Impact":
+    - Social & Community
+  "Social Services":
+    - Social & Community
+  "Social Protection":
+    - Social & Community
+  Creative:
+    - Design & Creative
+    - Media & Entertainment
+  "Creative Services":
+    - Design & Creative
+  "Creative Industries":
+    - Design & Creative
+  Media:
+    - Media & Entertainment
+  Entertainment:
+    - Media & Entertainment
+  "Arts / Culture":
+    - Design & Creative
+    - Media & Entertainment
+  Arts:
+    - Design & Creative
+  Sports:
+    - Media & Entertainment
+  "Sports / Recreation":
+    - Media & Entertainment
+  Safety:
+    - Security & Privacy
+  Marketing:
+    - Marketing & Sales
+  Business:
+    - Productivity & PM
+    - Marketing & Sales
+  "Business Services":
+    - Productivity & PM
+  Services:
+    - Productivity & PM
+  "Startup Ecosystem":
+    - Productivity & PM
+    - FinTech & Finance
+  Utilities:
+    - Government & Public Services
+  utilities:
+    - Government & Public Services
+  "Public Sector":
+    - Government & Public Services
+  "Urban Living":
+    - Real Estate & Construction
+  Wellness:
+    - Healthcare & MedTech
+  Lifestyle:
+    - Healthcare & MedTech
+    - Media & Entertainment
+  Fashion:
+    - E-commerce & Retail
+    - Design & Creative
+  Beauty:
+    - E-commerce & Retail
+  Family:
+    - Social & Community
+  "Family / Tech":
+    - Social & Community
+    - AI & Automation
+  Science:
+    - Developer Tools
+    - AI & Automation
+  Research:
+    - Developer Tools
+    - AI & Automation
+  Events:
+    - Marketing & Sales
+    - Productivity & PM
+  Insurance:
+    - FinTech & Finance
+  Fisheries:
+    - Agriculture & Environment
+  Mining:
+    - Agriculture & Environment
+  Parks:
+    - Travel & Tourism
+
+BOILERPLATE_SIGNALS : 
+    - the program addresses these needs by offering targeted interventions
+    - may currently rely on manual workarounds or a patchwork of generic tools
+    - ecosystem engagement, founder readiness training
+    - this makes it easier for people to stay organized

app/config/logging_config.yaml

@@ -0,0 +1,22 @@
+version: 1
+disable_existing_loggers: false
+
+formatters:
+  default:
+    format: "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+
+handlers:
+  console:
+    class: logging.StreamHandler
+    level: INFO
+    formatter: default
+
+  file:
+    class: logging.FileHandler
+    filename: app.log
+    level: WARNING
+    formatter: default
+
+root:
+  level: DEBUG
+  handlers: [console, file]

app/config/model_config.yaml

@@ -0,0 +1,3 @@
+encoder_model: all-mpnet-base-v2
+reranker: cross-encoder/ms-marco-MiniLM-L-6-v2
+sparse_model : Qdrant/bm25

app/main.py

@@ -0,0 +1,30 @@
+from dotenv import load_dotenv
+
+from app.src.engine.core.reasoning_router import route_reasoning
+load_dotenv(".env")
+
+from app.src.chat_schemas.response_schema import ChatRequest, ChatResponse
+from fastapi import FastAPI
+
+from app.src.engine.core.reasoning_router import route_reasoning
+from app.src.engine.core.logger import setup_logging
+
+setup_logging()
+
+app = FastAPI(title="Startup AI Service")
+
+@app.post("/chat", response_model=ChatResponse)
+def chat_endpoint(request: ChatRequest):
+    result = route_reasoning(
+        user_input=request.content,
+        data=request.data,
+        isNewConversation=request.isNewConversation,
+        conversationId=request.conversationId,
+        domain=request.domain
+    )
+
+    return result
+
+
+
+    

app/src/chat_schemas/response_schema.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+
+class IntentSchema(BaseModel):
+    primary_intent: str
+    secondary_intents: List[str] = []
+
+class ChatResponse(BaseModel):
+    content: str
+    conversationId: str
+    conversation_title:Optional[str]
+    role: str = 'ai',
+    is_idea_saved: bool = False
+    is_full_idea: bool
+    data: Optional[Dict] = None
+    inspired_by: Optional[List[str]] = None
+
+
+class ChatRequest(BaseModel):
+    content: str
+    conversationId: str
+    isNewConversation: bool 
+    clientMessageId: str = None
+    domain: Optional[str] = None
+    data: Optional[Dict] = None
+
+

app/src/engine/core/intent_classification.py

@@ -0,0 +1,160 @@
+import json
+import re
+from typing import Dict
+from app.src.llm.groq_provider import groq_provider
+from app.src.prompt_Engineering.tamplates import INTENTS_DETECTION_TEMPLATE
+import logging
+
+logger = logging.getLogger(__name__)
+
+llm_provider = groq_provider()
+
+def classify_intent(message: str) -> Dict:
+    """
+    Classify user intent from message using LLM
+    """
+    logger.info("Classifying intent")
+    try:
+        response = llm_provider.generate([
+            {"role": "user", "content": INTENTS_DETECTION_TEMPLATE.format(user_message=message)}
+        ])
+        
+        logger.debug(f"Raw LLM response: {response}")
+
+        cleaned_response = clean_json_response(response)
+        parsed = json.loads(cleaned_response)
+        
+        logger.info("Intent classification succeeded")
+
+        return parsed
+    
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON parsing failed in classify_intent: {e}")
+        return get_default_intent(message)
+    
+    except Exception as e:
+        logger.exception(f"Unexpected error in classify_intent: {type(e).__name__}: {e}")
+        return get_default_intent(message)
+
+
+def extract_problem_and_requirements(user_input: str) -> Dict:
+
+    logger.info("Extracting problem and requirements") 
+
+    extraction_prompt = f"""Extract information from this input. Return ONLY valid JSON.
+
+User input: "{user_input}"
+
+Return this exact JSON format (no other text):
+{{"core_problem": "", "requirements": [], "references_previous": false, "questions": [], "constraints": []}}
+
+Fill the fields based on the user input. If a field is empty, use empty string or empty list."""
+    
+    try:
+        response = llm_provider.generate([
+            {"role": "user", "content": extraction_prompt}
+        ])
+        
+        logger.debug(f"Raw extraction response: {response}")
+
+        cleaned_response = extract_json_only(response)
+        
+        parsed = json.loads(cleaned_response)
+        
+        logger.info("Extraction succeeded")
+
+        return {
+            "core_problem": parsed.get("core_problem", ""),
+            "requirements": parsed.get("requirements", []),
+            "references_previous": parsed.get("references_previous", False),
+            "questions": parsed.get("questions", []),
+            "constraints": parsed.get("constraints", [])
+        }
+    
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON Parse Error: {e}")
+        return get_default_extraction(user_input)
+    
+    except Exception as e:
+        logger.exception(f"Error: {type(e).__name__}: {e}")
+        return get_default_extraction(user_input)
+
+
+def extract_json_only(text: str) -> str:
+    """
+    Extract ONLY the first valid JSON object from text
+    """
+    import re
+    
+    # Remove markdown
+    text = re.sub(r'```.*?```', '', text, flags=re.DOTALL)
+    
+    # Find first '{'
+    start = text.find('{')
+    if start == -1:
+        return '{}'
+    
+    # Count braces to find matching '}'
+    count = 0
+    for i in range(start, len(text)):
+        if text[i] == '{':
+            count += 1
+        elif text[i] == '}':
+            count -= 1
+            if count == 0:
+                return text[start:i+1]
+    
+    return '{}'
+
+def clean_json_response(response: str) -> str:
+    """
+    Clean LLM response by removing markdown and extra text
+    """
+    import re
+    
+    # Remove markdown code block markers
+    response = re.sub(r'```(?:json|python|text)?\s*\n?', '', response)
+    response = re.sub(r'\n?```', '', response)
+    
+    # Remove any text before first '{'
+    json_start = response.find('{')
+    if json_start != -1:
+        response = response[json_start:]
+    
+    # Remove any text after last '}'
+    json_end = response.rfind('}')
+    if json_end != -1:
+        response = response[:json_end + 1]
+    
+    return response.strip()
+
+
+def get_default_intent(user_input: str) -> Dict:
+    """
+    Return default intent when LLM parsing fails
+    """
+    return {
+        "detected_intents": [
+            {
+                "intent": "general_chat",
+                "confidence": "high",
+                "relevant_text": user_input,
+                "priority": 1
+            }
+        ],
+        "primary_intent": "general_chat",
+        "secondary_intents": []
+    }
+
+
+def get_default_extraction(user_input: str) -> Dict:
+    """
+    Return default extraction when parsing fails
+    """
+    return {
+        "core_problem": "",
+        "requirements": [],
+        "references_previous": False,
+        "questions": [user_input],
+        "constraints": []
+    }

app/src/engine/core/logger.py

@@ -0,0 +1,12 @@
+import logging
+import logging.config
+import yaml
+from pathlib import Path
+
+def setup_logging():
+    config_path = "app/config/logging_config.yaml"
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        config = yaml.safe_load(f)
+
+    logging.config.dictConfig(config)

app/src/engine/core/providers/embedding_provider.py

@@ -0,0 +1,39 @@
+import os
+from huggingface_hub import InferenceClient
+
+
+class HFEmbeddingProvider:
+    """
+    Remote embedding model (no local download)
+    """
+
+    def __init__(self):
+        self.client = InferenceClient(token=os.getenv("HF_TOKEN"))
+        self.model = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+
+    def encode(self, text: str):
+        if not text:
+            return []
+
+        result = self.client.feature_extraction(
+            model=self.model,
+            text=text
+        )
+
+        # 🧠 الحل الصح
+        import numpy as np
+
+        # لو numpy array
+        if isinstance(result, np.ndarray):
+            return result.tolist()
+
+        # لو nested list
+        if isinstance(result, list) and isinstance(result[0], list):
+            return result[0]
+
+        # لو list عادي
+        if isinstance(result, list):
+            return result
+
+        # fallback
+        return list(result)

app/src/engine/core/providers/providers_factory.py

@@ -0,0 +1,22 @@
+import os
+from app.src.engine.core.providers.embedding_provider import HFEmbeddingProvider
+from app.src.engine.core.providers.reranker_provider import HFRerankerProvider
+from app.src.engine.core.providers.sparse_provider import SparseProvider
+import yaml
+
+
+def load_model_config():
+    path = "app/config/model_config.yaml"
+    with open(path, "r") as f:
+        return yaml.safe_load(f)
+
+
+class ProviderFactory:
+    def __init__(self):
+        config = load_model_config()
+
+        self.embedding = HFEmbeddingProvider()
+        self.reranker = HFRerankerProvider()
+        self.sparse = SparseProvider(
+            model_name=config["sparse_model"]
+        )

app/src/engine/core/providers/reranker_provider.py

@@ -0,0 +1,31 @@
+import os
+import json
+from huggingface_hub import InferenceClient
+
+class HFRerankerProvider:
+    def __init__(self):
+        self.client = InferenceClient(token=os.getenv("HF_TOKEN"))
+        self.model = "BAAI/bge-reranker-base"
+
+    def score(self, query: str, doc: str) -> float:
+        if not query or not doc:
+            return 0.0
+        try:
+            response = self.client.post(
+                json={
+                    "inputs": {
+                        "text": query,
+                        "text_pair": doc
+                    }
+                },
+                model=self.model,
+            )
+            result = json.loads(response)
+            # بيرجع list of dicts زي: [{"label": "LABEL_0", "score": 0.98}]
+            if isinstance(result, list) and len(result) > 0:
+                if isinstance(result[0], list):  # nested list
+                    return float(result[0][0].get("score", 0.0))
+                return float(result[0].get("score", 0.0))
+        except Exception as e:
+            return 0.0
+        return 0.0

app/src/engine/core/providers/sparse_provider.py

@@ -0,0 +1,17 @@
+from fastembed import SparseTextEmbedding
+
+
+class SparseProvider:
+    """
+    Local sparse model (خفيف ومش محتاج سيرفر)
+    """
+
+    def __init__(self, model_name: str):
+        self.model = SparseTextEmbedding(model_name=model_name)
+
+    def encode(self, text: str):
+        """
+        Returns sparse vector (indices + values)
+        """
+        result = list(self.model.embed([text]))[0]
+        return result

app/src/engine/core/reasoning_router.py

@@ -0,0 +1,165 @@
+import json
+from typing import Dict, List
+import pandas as pd
+from app.src.chat_schemas.response_schema import ChatResponse, IntentSchema
+from app.src.engine.core.intent_classification import (
+    classify_intent, 
+    extract_problem_and_requirements
+)
+from app.src.engine.rag.retriver import retrieve_topk
+from app.src.prompt_Engineering.tamplates import FULL_IDEA_TEMPLATE
+from app.src.prompt_Engineering.tamplates import build_unified_prompt
+from app.src.llm.groq_provider import groq_provider
+import logging
+
+logger = logging.getLogger(__name__)
+
+llm_provider = groq_provider()
+
+def route_reasoning(
+    user_input: str, 
+    data: Dict, 
+    domain: str, 
+    isNewConversation: bool,
+    conversationId: str
+) -> Dict:
+   
+    
+    logger.debug(f"\nProcessing user input: {user_input}")
+    
+    structured_data = None
+    new_data = None
+    
+    # Step 1: Detect intents
+    intents_response = classify_intent(user_input)
+    logger.debug(f"Detected intents: {intents_response['detected_intents']}")
+    
+    # Step 2: Extract problem and requirements
+    if intents_response["primary_intent"] == "random_solution":
+        # Filter problems by domain
+        try:
+            df = pd.read_excel('data/raw/Problems.xlsx')
+            random_domain_based_problem = df[
+                df['problem_sector'].str.lower() == domain.lower()
+            ].sample(n=1)['problem_description'].values[0]
+            extracted = extract_problem_and_requirements(random_domain_based_problem)
+            print(f"Random domain based problem: {random_domain_based_problem}\n")
+        except Exception as e:
+            print(f"Error reading problems: {e}")
+            extracted = extract_problem_and_requirements(user_input)
+    else:
+        extracted = extract_problem_and_requirements(user_input)
+    
+    logger.debug(f"Extracted data: {extracted}")
+    
+    # Step 3: Get context from retriever layer
+    def make_context_cards(points):
+     logger.info("Making The Context Cards")
+     cards = []
+     for i, p in enumerate(points, 1):
+        pl = p.payload or {}
+        cards.append(f"""[{i}]
+        name: {pl.get("name","")}
+        domain: {pl.get("domain","")}
+        use_case: {pl.get("use_case","")}
+        solution: {pl.get("solution","")}
+        link: {pl.get("link","") or pl.get("site","")}""".strip())
+     return "\n\n".join(cards)
+     
+    
+    points = retrieve_topk(
+        problem_text=extracted.get('core_problem', 'Problem not clearly specified'),
+        sector=domain
+    )
+    context = make_context_cards(points)
+    inspired_by = [point.payload.get("name","") for point in points] if points else None
+
+    logger.info(f"Inspired by: {inspired_by}")
+
+    logger.debug(f"The Context {context}")
+    
+    # Step 4: Generate or retrieve idea data
+    primary_intent = intents_response['primary_intent']
+    
+    if primary_intent in ["problem_solving", "random_solution"]:
+        # Generate new idea
+        logger.debug(f"Generating new startup idea...")
+        core_problem = extracted.get('core_problem', 'Problem not clearly specified')
+        new_data = llm_provider.generate([
+            {"role": "user", "content": FULL_IDEA_TEMPLATE.format(core_problem=core_problem)}
+        ])
+    
+    elif primary_intent == "alternative_idea":
+        logger.info(f"Generating alternative startup idea...")
+        problem = data.get('problem_description', extracted.get('core_problem', 'Problem not clearly specified'))
+        new_data = llm_provider.generate([
+            {"role": "user", "content": FULL_IDEA_TEMPLATE.format(core_problem=problem)}
+        ])
+    
+    else:
+        logger.debug(f"Using existing idea data...")
+        new_data = data
+    
+    if new_data:
+        try:
+            structured_data = json.loads(new_data) if isinstance(new_data, str) else new_data
+            logger.info(f"Structured data parsed")
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.exception(f"Failed to parse structured data: {e}")
+            structured_data = {
+                "raw_text": str(new_data),
+                "parse_error": str(e)
+            }
+    else:
+        structured_data = {
+            "raw_text": "No idea data generated"
+        }
+    
+    # Step 5: Build unified prompt (to generate the response's content)
+    logger.info(f"Building unified prompt...")
+    
+    final_prompt = build_unified_prompt(
+        detected_intents=intents_response['detected_intents'],
+        extracted_data=extracted,
+        context=context,
+        primary_intent=primary_intent,
+        idea_data=structured_data
+    )
+    
+    # Step 6: Call LLM with the final prompt to generate response
+    logger.info(f"Generating response...")
+    
+    content = llm_provider.generate([
+        {"role": "user", "content": final_prompt}
+    ])
+    
+    logger.info(f"Response received")
+    
+    # Determine if this is an idea response
+    is_idea = primary_intent in ["problem_solving", "random_solution", "alternative_idea"]
+    
+    # Step 7: Return response
+    if isNewConversation:
+        conversation_title = extracted.get('core_problem', 'New Conversation')
+        
+        return ChatResponse(
+            content=content,
+            conversationId=conversationId,
+            conversation_title=conversation_title,
+            role='ai',
+            is_idea_saved=False,
+            is_full_idea=is_idea,
+            data=structured_data,
+            inspired_by= inspired_by
+        ).dict()
+    
+    else:
+        return ChatResponse(
+            content=content,
+            conversationId=conversationId,
+            role='ai',
+            is_idea_saved=False,
+            is_full_idea=is_idea,
+            data=structured_data,
+            inspired_by= inspired_by
+        ).dict()

app/src/engine/rag/retriver.py

@@ -0,0 +1,168 @@
+
+import os
+
+from qdrant_client import QdrantClient, models
+from qdrant_client.models import Prefetch, FusionQuery, Fusion
+from deep_translator import GoogleTranslator
+import langdetect
+
+import yaml
+import logging
+
+from app.src.engine.core.providers.providers_factory import ProviderFactory
+
+logger = logging.getLogger(__name__)
+
+from dotenv import load_dotenv
+load_dotenv(".env")
+
+def load_sector_mappings():
+    path = "app/config/domain_mapping.yaml"
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    return (
+        data["STARTUP_SECTOR_GROUPS"],
+        data["PROBLEM_TO_STARTUP_GROUPS"],
+        data["BOILERPLATE_SIGNALS"]
+    )
+
+def load_models_names():
+    path = "app/config/model_config.yaml"
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    return (
+        data["encoder_model"],
+        data["reranker"],
+        data["sparse_model"]
+    )
+
+STARTUP_SECTOR_GROUPS, PROBLEM_TO_STARTUP_GROUPS, BOILERPLATE_SIGNALS  = load_sector_mappings()
+
+def get_startup_sectors_for_problem(problem_sector: str) -> list[str]:
+    logger.info(f"problem Sector mapping")
+    group_names = PROBLEM_TO_STARTUP_GROUPS.get(problem_sector, [])
+    sectors = []
+    for g in group_names:
+        sectors.extend(STARTUP_SECTOR_GROUPS.get(g, []))
+    return list(set(sectors))
+
+encoder_model_name, reranker_name, sparse_model_name = load_models_names()
+
+providers = ProviderFactory()
+
+embedding_provider = providers.embedding
+reranker_provider = providers.reranker
+sparse_provider = providers.sparse
+
+
+def is_boilerplate(payload: dict) -> bool:
+    text = " ".join([payload.get("use_case",""), payload.get("solution",""), payload.get("description","")]).lower()
+    return any(s in text for s in BOILERPLATE_SIGNALS)
+
+def translate_to_english(text: str) -> str:
+    try:
+        if langdetect.detect(text) == "ar":
+            translated = GoogleTranslator(source="ar", target="en").translate(text)
+            logger.debug(f"Translated: {translated}")
+            return translated
+    except Exception:
+        pass
+    return text
+
+qdrant_client= QdrantClient(url=os.getenv("QDRANT_URL"), api_key=os.getenv("QDRANT_API_KEY"))
+
+def retrieve_topk(
+    problem_text: str,
+    k: int = 5,
+    sector: str | None = None,
+    topN: int = 150,
+    debug: bool = True
+):
+    logger.info(f"Getting The top 5 Startups")
+    problem_en = translate_to_english(problem_text)
+    ce_query   = f"{sector}: {problem_en}" if sector else problem_en
+
+    dense_vec  = embedding_provider.encode(problem_en)
+    sparse_vec = sparse_provider.encode(problem_en)
+
+    # Soft sector filter (SHOULD = boost, not hard exclusion)
+    startup_sectors = get_startup_sectors_for_problem(sector) if sector else []
+    soft_filter = None
+    if startup_sectors:
+        soft_filter = models.Filter(
+            should=[models.FieldCondition(
+                key="sector",
+                match=models.MatchAny(any=startup_sectors[:50])
+            )]
+        )
+        if debug:
+            logger.debug(f"'{sector}' → {len(startup_sectors)} startup sectors boosted")
+    else:
+        if debug:
+            logger.warning(f"No mapping for '{sector}' — searching without sector boost")
+
+    def run_query(use_filter):
+        return qdrant_client.query_points(
+            collection_name= os.getenv("COLLECTION"),
+            prefetch=[
+                Prefetch(query=dense_vec,  using="dense",  limit=topN, filter=use_filter),
+                Prefetch(
+                    query=models.SparseVector(
+                        indices=sparse_vec.indices.tolist(),
+                        values=sparse_vec.values.tolist()
+                    ),
+                    using="sparse", limit=topN, filter=use_filter
+                ),
+            ],
+            query=FusionQuery(fusion=Fusion.RRF),
+            limit=topN,
+            with_payload=True,
+        )
+
+    results = run_query(soft_filter)
+
+    # Fallback: if fewer than k results, retry without filter
+    if len(results.points) < k and soft_filter is not None:
+        if debug:
+            logger.warning(f"Only {len(results.points)} results with filter — retrying without")
+        results = run_query(None)
+
+    # Clean: remove boilerplate + dedup by name
+    seen, clean, skipped = set(), [], 0
+    for p in results.points:
+        # if is_boilerplate(p.payload):
+        #     skipped += 1
+        #     continue
+        name = (p.payload.get("name") or "").strip().lower()
+        if name not in seen:
+            seen.add(name)
+            clean.append(p)
+
+    if debug:
+        logger.debug(f"{len(results.points)} retrieved → {skipped} boilerplate removed → {len(clean)} unique clean")
+        logger.debug(f"{len(results.points)}  → {len(clean)} unique clean")
+
+    # Cross-encoder rerank
+    pairs = [[ce_query, " | ".join(filter(bool, [
+        p.payload.get("use_case",""),
+        p.payload.get("solution",""),
+        p.payload.get("description",""),
+        p.payload.get("sector",""),
+    ]))] for p in clean]
+
+    cross_scores = [
+        reranker_provider.score(q, d)
+        for q, d in pairs
+    ]
+    ranked = sorted(zip(cross_scores, clean), key=lambda x: x[0], reverse=True)
+
+    if debug:
+        logger.debug(f"\n=== TOP-{k} ===")
+        for score, p in ranked[:k]:
+            pl = p.payload
+            logger.debug(f"  {round(float(score),3):>7} | {pl.get('name',''):<28} | {pl.get('sector',''):<22} | {pl.get('domain','')}")
+            logger.debug(f"           {str(pl.get('use_case',''))[:110]}")
+
+    return [p for _, p in ranked[:k]]

app/src/llm/base.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+class BaseLLM(ABC):
+
+    @abstractmethod
+    def generate(self, message: list):
+        pass
+
+    @abstractmethod
+    def stream(self, message : list):
+        pass

app/src/llm/groq_provider.py

@@ -0,0 +1,37 @@
+import os
+from groq import Groq
+from app.src.llm.base import BaseLLM
+
+from dotenv import load_dotenv
+load_dotenv(".env")
+
+class groq_provider(BaseLLM):
+  def __init__(self):
+        self.client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+  def generate(self, messages: list) -> str:
+        """
+        Generate response from Groq
+        """
+        if isinstance(messages, str):
+            messages = [{"role": "user", "content": messages}]
+        
+        response = self.client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=messages, 
+            temperature=0.2,
+        )
+        return response.choices[0].message.content
+    
+
+
+
+  def stream(self , message: list):
+   stream = self.client.chat.completions.create(
+       model="llama-3.1-8b-instant",
+    messages = message,
+    stream=True
+  )
+   return stream
+
+  

app/src/prompt_Engineering/tamplates.py

@@ -0,0 +1,335 @@
+from typing import List, Dict
+
+# INTENTS DETECTION TEMPLATE
+INTENTS_DETECTION_TEMPLATE = """You are an intent classification expert.
+
+User input: "{user_message}"
+
+Analyze this user input and detect ALL applicable intents.
+
+CRITICAL DISTINCTIONS:
+- problem_solving: User describes a SPECIFIC problem and wants a startup solution
+  Examples: "I want to solve expensive education", "transportation in Cairo is bad"
+  
+- random_solution: User asks for ANY startup idea WITHOUT describing a problem
+  Examples: "Give me a startup idea", "What's a good business"
+  
+- follow_up: User continues discussion on a PREVIOUS idea
+  Examples: "Tell me more about that idea", "How can we improve it?"
+  
+- alternative_idea: User wants a DIFFERENT solution for the SAME problem
+  Examples: "Another approach to education", "Different solution"
+  
+- details: User asks for more information/details
+  Examples: "Explain more", "Give me details"
+  
+- feasibility: User asks about viability/feasibility
+  Examples: "Is it feasible?", "Can we implement this?"
+  
+- novelty: User asks about innovation/uniqueness
+  Examples: "Is it innovative?", "Is it unique?"
+  
+- general_chat: General conversation with no specific startup request
+  Examples: "Hi how can you help me?", "How is the market?", "What's trending?"
+
+RULES:
+1. If user mentions a SPECIFIC problem → problem_solving
+2. If user asks for ANY startup WITHOUT mentioning a problem → random_solution
+3. If user references PREVIOUS discussion → follow_up or alternative_idea
+4. If user asks for MORE about something already discussed → details
+5. If user questions FEASIBILITY → feasibility
+6. If user questions INNOVATION → novelty
+7. If it's GENERAL conversation → general_chat
+
+Return ONLY valid JSON (no explanations):
+{{"detected_intents": [{{"intent": "intent_name", "confidence": "high/medium/low", "relevant_text": "the relevant part", "priority": 1}}], "primary_intent": "main_intent", "secondary_intents": ["other_intents"]}}
+
+Examples:
+
+Input: "Hi how can you help me"
+Output: {{"detected_intents": [{{"intent": "general_chat", "confidence": "high", "relevant_text": "Hi how can you help me", "priority": 1}}], "primary_intent": "general_chat", "secondary_intents": []}}
+
+Input: "I want to solve expensive education in Egypt"
+Output: {{"detected_intents": [{{"intent": "problem_solving", "confidence": "high", "relevant_text": "solve expensive education", "priority": 1}}], "primary_intent": "problem_solving", "secondary_intents": []}}
+
+Input: "Give me a startup idea"
+Output: {{"detected_intents": [{{"intent": "random_solution", "confidence": "high", "relevant_text": "Give me a startup idea", "priority": 1}}], "primary_intent": "random_solution", "secondary_intents": []}}
+"""
+
+FULL_IDEA_TEMPLATE = """
+    You are an expert in entrepreneurship and startup innovation focused on the MENA region.
+    
+     Your task is to generate a complete startup concept based on the given problem:
+      {core_problem}
+        
+
+        Requirements:
+        - Focus on realistic and practical solutions.
+        - Adapt the idea for the Egypt or MENA market.
+        - Use concise and clear text.
+        - Provide multiple items for list fields when possible.
+
+        Important Rules:
+        - Return ONLY valid JSON.
+        - Do NOT write any text outside JSON.
+        - Do NOT add explanations or comments.
+        - Follow the exact data types:
+        - Text fields → string
+        - Lists → array
+        - Nested sections → object
+        - novelty_score → number between 0 and 100
+        - business_model MUST be an object (not a string).
+        - feasibility MUST be an object.
+        - market_analysis MUST be an object.
+        - impact MUST be an object.
+        - mvp_plan MUST be an object.
+
+        Return the response using this exact structure:
+
+        {{
+        "problem_title": "",
+        "problem_description": "",
+        "root_cause": "",
+        "target_users": "",
+        "market_region": "Egypt or MENA",
+        "why_now": "",
+        "evidence_signals": [],
+
+        "solution_name": "",
+        "solution_description": "",
+        "how_it_works": [],
+        "key_features": [],
+        "technology_stack": [],
+
+        "business_model": {{
+            "value_proposition": "",
+            "revenue_streams": [],
+            "pricing_model": "",
+            "customer_acquisition": []
+        }},
+
+        "market_analysis": {{
+            "market_size": "",
+            "competitors": [],
+            "competitive_advantage": ""
+        }},
+
+        "feasibility": {{
+            "technical_feasibility": "Low",
+            "market_feasibility": "Low",
+            "risk_factors": []
+        }},
+
+        "novelty_score": 0,
+
+        "impact": {{
+            "economic_impact": "",
+            "social_impact": ""
+        }},
+
+        "mvp_plan": {{
+            "mvp_features": [],
+            "first_steps": []
+        }}
+        }}
+        Important:
+        Return ONLY valid JSON.
+        Do not repeat any section.
+        Do not truncate the response.
+        If you are unsure, return a shorter but complete JSON.
+        If you cannot complete the JSON correctly, return a shorter but valid JSON.
+        Never cut arrays or objects.
+        Never leave fields incomplete.
+"""
+
+import json
+from typing import List, Dict
+
+def build_unified_prompt(
+    detected_intents: List[Dict],
+    extracted_data: Dict,
+    context: str = None,
+    primary_intent: str = None,
+    idea_data: Dict = None
+) -> str:
+
+    if not primary_intent:
+        sorted_intents = sorted(detected_intents, key=lambda x: x.get("priority", 999))
+        primary_intent = sorted_intents[0]["intent"]
+
+    prompt = """
+You are an expert in entrepreneurship and startup innovation focused on the MENA region.
+
+Always answer clearly and practically.
+Use the provided idea data as reference.
+Base your response on the idea data provided.
+"""
+
+    # -------------------------
+    # EXISTING IDEA CONTEXT
+    # -------------------------
+
+    if idea_data:
+        idea_json = json.dumps(idea_data, indent=2)
+
+        prompt += f"""
+
+STARTUP IDEA DATA (REFERENCE):
+
+{idea_json}
+
+Important rules:
+- Use this data as your source of truth when answering.
+- Extract information from this data to answer user questions.
+- Do NOT generate new ideas if this data exists.
+- Base all your answers on this data.
+"""
+
+    prompt += f"\n\nPRIMARY REQUEST ({primary_intent}):\n"
+
+
+    if primary_intent in ["problem_solving", "random_solution" , "alternative_idea"]:
+
+        prompt += """
+The user is asking for a startup idea solution.
+
+Your task:
+- Describe the startup solution in a clear, compelling way
+- Use the idea data provided above as your reference
+- Return ONLY the description of the solution (not the full JSON)
+
+Format your response as clear paragraphs or bullet points.
+Make it practical and actionable for the Egypt/MENA market.
+"""
+
+
+
+    elif primary_intent == "follow_up":
+
+        user_questions = extracted_data.get('questions', ['General questions about the idea'])
+        questions_str = ', '.join(user_questions) if isinstance(user_questions, list) else user_questions
+
+        prompt += f"""
+The user is following up with questions about the existing idea.
+
+User's questions/requests:
+{questions_str}
+
+Your task:
+- Answer based on the idea data provided above
+- Expand or clarify specific aspects
+- Provide detailed explanations
+- Return a clear narrative response (not JSON)
+
+Focus on the aspects the user is asking about.
+"""
+
+
+    elif primary_intent == "details":
+
+        prompt += """
+The user wants more detailed information about the startup idea.
+
+Your task:
+- Provide comprehensive details based on the idea data
+- Expand on implementation, business model, and execution
+- Return a detailed narrative response (not JSON)
+- Cover:
+  * Detailed problem analysis
+  * Complete solution description
+  * Implementation steps and timeline
+  * Business model breakdown
+  * Target customer segments
+  * Revenue streams and pricing
+  * Required resources and team
+  * Key success metrics
+
+Format as detailed sections or bullet points.
+Be specific and practical.
+"""
+
+
+    elif primary_intent == "general_chat":
+
+        topic = extracted_data.get('core_problem', 'general startup topics')
+
+        prompt += f"""
+The user wants to have a general discussion about: {topic}
+
+Your task:
+- Provide thoughtful insights and analysis
+- Use the idea data as context if available
+- Return a conversational, informative response
+- Be helpful and engaging
+
+Format as clear narrative paragraphs.
+"""
+
+
+    secondary_intents = extracted_data.get("secondary_intents", [])
+
+    if secondary_intents:
+
+        prompt += "\n\nADDITIONAL ASPECTS TO ADDRESS:\n"
+
+        for intent in secondary_intents:
+
+            if intent == "details":
+
+                prompt += """
+- Include more detailed information about:
+  * Implementation steps and timeline
+  * Business model specifics
+  * Target customers
+  * Revenue streams and pricing strategy
+  * Team and resources needed
+"""
+
+            elif intent == "feasibility":
+
+                prompt += """
+- Analyze and discuss feasibility:
+  * Technical feasibility based on the idea data
+  * Market feasibility in Egypt/MENA region
+  * Risk factors and mitigation strategies
+  * Resource requirements
+  * Realistic timeline to MVP
+  * Success probability
+"""
+
+            elif intent == "novelty":
+
+                prompt += """
+- Evaluate innovation and uniqueness:
+  * What's new and innovative about this solution
+  * Competitive advantages over existing solutions
+  * Unique value proposition
+  * Market differentiation factors
+  * Why customers would choose this
+"""
+
+    context_text = context or "Startup discussion focused on solving real problems in Egypt and the MENA region."
+
+    prompt += f"""
+
+CONTEXT:
+{context_text}
+
+USER REQUIREMENTS:
+{', '.join(extracted_data.get('requirements', ['comprehensive analysis']))}
+
+CONSTRAINTS:
+{', '.join(extracted_data.get('constraints', ['Egypt/MENA market focus']))}
+
+IMPORTANT INSTRUCTIONS:
+- Return a clear, practical, narrative response (NOT JSON or code)
+- Base everything on the idea data provided
+- Keep language simple and actionable
+- Focus on Egypt/MENA market realities
+- Be specific with examples where possible
+- Do NOT return the raw JSON data
+- Format response as readable text or bullet points
+- Make it engaging and professional
+"""
+
+    return prompt