Create app.py

app.py

@@ -0,0 +1,952 @@
+import os
+import json
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+import warnings
+warnings.filterwarnings('ignore')
+
+# Core imports
+import gradio as gr
+import chromadb
+from sentence_transformers import SentenceTransformer
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import joblib
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import re
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+# Set up paths for different deployment environments
+CHROMA_DB_PATH = os.getenv("CHROMA_DB_PATH", "./chroma_db")
+PERSIST_DIR = os.getenv("PERSIST_DIR", CHROMA_DB_PATH)
+Path(PERSIST_DIR).mkdir(parents=True, exist_ok=True)
+
+print(f"🗄️ ChromaDB will be stored at: {PERSIST_DIR}")
+
+# Data Models
+@dataclass
+class StartupIdea:
+    """Data model for startup ideas"""
+    name: str
+    description: str
+    industry: str
+    target_market: str
+    problem_statement: str
+    solution: str
+    unique_value_proposition: str
+
+@dataclass
+class BusinessPlan:
+    """Comprehensive business plan structure"""
+    executive_summary: str
+    company_description: str
+    market_analysis: str
+    organization_management: str
+    service_product_line: str
+    marketing_sales: str
+    funding_request: str
+    financial_projections: Dict[str, Any]
+
+@dataclass
+class Flashcard:
+    """Learning flashcard structure"""
+    id: str
+    front: str
+    back: str
+    category: str
+    difficulty: str
+    tags: List[str]
+
+@dataclass
+class RoadmapMilestone:
+    """Roadmap milestone structure"""
+    id: str
+    title: str
+    description: str
+    timeline: str
+    dependencies: List[str]
+    priority: str
+    category: str
+
+# RAG System Implementation
+class RAGSystem:
+    """Retrieval-Augmented Generation system using ChromaDB"""
+    
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        print("🧠 Initializing RAG System...")
+        try:
+            self.embedding_model = SentenceTransformer(model_name)
+            self.chroma_client = chromadb.PersistentClient(path=PERSIST_DIR)
+            self.collection_name = "startup_knowledge"
+            self.collection = None
+            self.text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=1000,
+                chunk_overlap=200,
+                length_function=len
+            )
+            print("✅ RAG System initialized successfully")
+        except Exception as e:
+            print(f"❌ Error initializing RAG System: {e}")
+            raise
+
+    def initialize_collection(self):
+        """Initialize or get existing collection"""
+        try:
+            collections = self.chroma_client.list_collections()
+            existing_collection = next((c for c in collections if c.name == self.collection_name), None)
+            
+            if existing_collection:
+                self.collection = self.chroma_client.get_collection(self.collection_name)
+                print(f"📚 Found existing collection with {self.collection.count()} documents")
+            else:
+                self.collection = self.chroma_client.create_collection(
+                    name=self.collection_name,
+                    metadata={"description": "Startup knowledge base"}
+                )
+                print("📚 Created new collection")
+            
+            return self.collection
+            
+        except Exception as e:
+            print(f"❌ Error initializing collection: {e}")
+            try:
+                self.collection = self.chroma_client.create_collection(
+                    name=f"{self.collection_name}_{uuid.uuid4().hex[:8]}",
+                    metadata={"description": "Startup knowledge base"}
+                )
+                print("📚 Created fallback collection")
+                return self.collection
+            except Exception as e2:
+                print(f"❌ Fatal error creating collection: {e2}")
+                raise
+
+    def add_documents(self, documents: List[str], metadatas: List[Dict] = None):
+        """Add documents to the knowledge base"""
+        if not self.collection:
+            self.initialize_collection()
+        
+        try:
+            all_chunks = []
+            all_metadatas = []
+            
+            for i, doc in enumerate(documents):
+                chunks = self.text_splitter.split_text(doc)
+                all_chunks.extend(chunks)
+                
+                doc_metadata = metadatas[i] if metadatas and i < len(metadatas) else {}
+                for chunk in chunks:
+                    all_metadatas.append({
+                        **doc_metadata,
+                        "chunk_id": str(uuid.uuid4()),
+                        "timestamp": datetime.now().isoformat()
+                    })
+            
+            print(f"🔄 Generating embeddings for {len(all_chunks)} chunks...")
+            embeddings = self.embedding_model.encode(all_chunks).tolist()
+            
+            ids = [str(uuid.uuid4()) for _ in all_chunks]
+            self.collection.add(
+                documents=all_chunks,
+                embeddings=embeddings,
+                metadatas=all_metadatas,
+                ids=ids
+            )
+            
+            print(f"✅ Added {len(all_chunks)} chunks to knowledge base")
+            return len(all_chunks)
+            
+        except Exception as e:
+            print(f"❌ Error adding documents: {e}")
+            return 0
+
+    def retrieve_context(self, query: str, n_results: int = 5) -> List[Dict]:
+        """Retrieve relevant context for a query"""
+        if not self.collection:
+            self.initialize_collection()
+            
+        try:
+            query_embedding = self.embedding_model.encode([query]).tolist()[0]
+            
+            results = self.collection.query(
+                query_embeddings=[query_embedding],
+                n_results=min(n_results, max(1, self.collection.count()))
+            )
+            
+            contexts = []
+            if results['documents'][0]:
+                for i, doc in enumerate(results['documents'][0]):
+                    contexts.append({
+                        "content": doc,
+                        "metadata": results['metadatas'][0][i] if results['metadatas'][0] else {},
+                        "distance": results['distances'][0][i] if results['distances'] and results['distances'][0] else 0
+                    })
+            
+            return contexts
+            
+        except Exception as e:
+            print(f"❌ Error retrieving context: {e}")
+            return []
+
+    def generate_response(self, query: str, context: List[Dict]) -> str:
+        """Generate response using retrieved context"""
+        try:
+            context_text = "\n".join([ctx["content"] for ctx in context])
+            return self._generate_structured_response(query, context_text)
+        except Exception as e:
+            print(f"❌ Error generating response: {e}")
+            return "I apologize, but I encountered an error generating a response. Please try again."
+
+    def _generate_structured_response(self, query: str, context: str) -> str:
+        """Generate structured response based on query type"""
+        query_lower = query.lower()
+        
+        if "market research" in query_lower or "competition" in query_lower:
+            return f"""**Market Analysis Framework:**
+
+Based on startup best practices:
+{context[:500]}...
+
+**Key Recommendations:**
+- Conduct thorough competitive analysis using TAM/SAM/SOM framework
+- Identify unique value propositions that differentiate your solution  
+- Analyze market size and growth potential with real data
+"""
+            
+        elif "business plan" in query_lower:
+            return f"""**Business Plan Development:**
+
+Essential components:
+{context[:500]}...
+
+**Core Sections:**
+- Executive Summary
+- Market Analysis
+- Financial Projections
+"""
+            
+        else:
+            return f"""**Strategic Guidance:**
+
+{context[:400]}...
+
+**Key Considerations:**
+- Validate assumptions with market data
+- Focus on solving genuine problems
+- Build strong unit economics
+"""
+
+# Startup Knowledge Base
+STARTUP_KNOWLEDGE_BASE = [
+    """
+IDEA VALIDATION AND MARKET RESEARCH
+
+Before building any product, entrepreneurs must prove market demand exists. This involves:
+
+1. Problem Identification: Identify genuine problems that specific customer segments face daily.
+
+2. Market Analysis: Determine total addressable market (TAM) size. Use TAM/SAM/SOM framework:
+   - TAM (Total Addressable Market): Total market demand
+   - SAM (Serviceable Addressable Market): Portion targeted by your products  
+   - SOM (Serviceable Obtainable Market): Portion you can realistically capture
+
+3. Competitive Research: Analyze competitors' offerings, pricing, strengths, weaknesses.
+
+4. Customer Validation: Conduct 50+ interviews to validate core assumptions.
+
+Key metrics: CAC, LTV, market penetration rate, NPS.
+""",
+
+    """
+BUSINESS PLAN DEVELOPMENT
+
+A comprehensive business plan serves as roadmap and investor communication tool:
+
+1. Executive Summary: Mission, product, market, competitive advantages, funding needs.
+
+2. Company Description: Business model, legal structure, value proposition.
+
+3. Market Analysis: Industry overview, target market, competitive landscape.
+
+4. Organization & Management: Team, advisors, hiring plans.
+
+5. Financial Projections: 3-5 year forecasts, cash flow, break-even analysis.
+
+6. Funding Requirements: Capital needs, use of funds, expected ROI.
+""",
+
+    """
+FUNDING AND FINANCIAL MANAGEMENT
+
+Securing and managing finances strategically:
+
+1. Funding Sources:
+   - Bootstrapping: Personal savings
+   - Angels: $25K-$100K early stage
+   - VC: $1M+ for high-growth potential
+   - Crowdfunding: Product launches
+   - Grants: SBIR/STTR programs
+
+2. Key Metrics:
+   - Burn Rate: Monthly cash expenditure
+   - Runway: Months of cash remaining
+   - CAC: Total marketing cost ÷ new customers
+   - LTV: Average revenue × margin × lifespan
+   - LTV/CAC should be 3:1 or higher
+
+3. Best Practices:
+   - Separate business and personal finances
+   - Maintain 6-12 months cash reserves
+   - Track MRR, ARR, gross margins
+""",
+
+    """
+LEGAL STRUCTURE AND COMPLIANCE
+
+Choosing the right legal foundation:
+
+1. Business Structures:
+   - Sole Proprietorship: Simple, personal liability
+   - LLC: Asset protection, flexible taxes
+   - C-Corp: Best for VC funding, stock issuance
+   - Delaware C-Corp advantages for startups
+
+2. Essential Documents:
+   - Articles of Incorporation
+   - Founders' Agreement with vesting
+   - Employee NDAs and IP assignments
+   - Terms of service, privacy policy
+
+3. IP Protection:
+   - Trademarks: Brand names, logos
+   - Patents: Unique inventions
+   - Copyrights: Creative works
+   - Trade Secrets: Proprietary processes
+
+4. Compliance:
+   - Federal EIN
+   - Business licenses
+   - Industry permits
+   - Data privacy (GDPR, CCPA)
+""",
+
+    """
+TEAM BUILDING AND OPERATIONS
+
+Building the right team:
+
+1. Founding Team:
+   - Complementary skills: technical, business, domain
+   - Aligned vision and values
+   - Equity split reflects contribution
+
+2. Hiring Strategy:
+   - Hire for adaptability and culture fit
+   - Focus on critical roles first
+   - 4-year vesting with 1-year cliff
+   - 0.1%-10% equity based on role
+
+3. Key Metrics by Function:
+   - Product: DAU/MAU, retention, feature adoption
+   - Sales: Conversion rates, cycle length, ACV
+   - Marketing: CPL, MQLs, brand awareness
+   - Finance: Revenue growth, margins, working capital
+
+4. Operational Excellence:
+   - Build MVP with core features
+   - Define and track KPIs
+   - Create scalable processes
+   - Implement feedback loops
+""",
+
+    """
+BRAND DEVELOPMENT AND MARKETING
+
+Strong branding drives growth:
+
+1. Brand Identity:
+   - Define values, personality, voice
+   - Create unique selling proposition
+   - Develop consistent visual identity
+   - Establish market positioning
+
+2. Digital Presence:
+   - Professional website with clear CTA
+   - SEO optimization
+   - Social media strategy
+   - Content marketing calendar
+
+3. Acquisition Channels:
+   - Content Marketing: Thought leadership
+   - Social Media: Platform-specific strategies
+   - SEM: Targeted Google Ads
+   - Email: Drip campaigns, newsletters
+   - Partnerships: Co-marketing, affiliates
+
+4. Key Metrics:
+   - Website traffic and conversion rates
+   - CAC by channel
+   - LTV by acquisition source
+   - NPS and customer satisfaction
+   - Brand awareness and consideration
+
+5. Customer Success:
+   - Feedback loops and surveys
+   - Customer success programs
+   - Community building
+   - Referral programs
+"""
+]
+
+KNOWLEDGE_METADATA = [
+    {"category": "validation", "topic": "market_research", "importance": "high"},
+    {"category": "planning", "topic": "business_plan", "importance": "high"},
+    {"category": "finance", "topic": "funding", "importance": "high"},
+    {"category": "legal", "topic": "structure", "importance": "medium"},
+    {"category": "operations", "topic": "team_building", "importance": "high"},
+    {"category": "marketing", "topic": "branding", "importance": "medium"},
+]
+
+# Business Plan Generator
+class StartupBlueprintGenerator:
+    """Main class for generating comprehensive startup blueprints"""
+    
+    def __init__(self, rag_system: RAGSystem):
+        self.rag = rag_system
+        self.templates = self._load_templates()
+        self.model_data = {}
+
+    def _load_templates(self) -> Dict[str, str]:
+        """Load template structures"""
+        return {
+            "executive_summary": """## Executive Summary
+
+**Company:** {company_name}  
+**Industry:** {industry}  
+**Mission:** {mission}
+
+### Problem Statement
+{problem_statement}
+
+### Solution
+{solution}
+
+### Market Opportunity  
+{market_opportunity}
+
+### Financial Highlights
+- Projected Revenue Year 3: {projected_revenue}
+- Funding Requirement: {funding_needed}  
+- Break-even Timeline: {breakeven_timeline}
+""",
+        }
+
+    def generate_business_plan(self, startup_idea: StartupIdea) -> BusinessPlan:
+        """Generate comprehensive business plan"""
+        try:
+            print(f"📊 Generating business plan for {startup_idea.name}...")
+            
+            exec_context = self.rag.retrieve_context(
+                f"executive summary for {startup_idea.industry} startup", 
+                n_results=3
+            )
+            
+            executive_summary = self.templates["executive_summary"].format(
+                company_name=startup_idea.name,
+                industry=startup_idea.industry,
+                mission=f"To solve {startup_idea.problem_statement} for {startup_idea.target_market}",
+                problem_statement=startup_idea.problem_statement,
+                solution=startup_idea.solution,
+                market_opportunity=f"Significant opportunity in the {startup_idea.industry} market",
+                projected_revenue="$1M - $5M",
+                funding_needed="$250K - $1M",
+                breakeven_timeline="18-24 months"
+            )
+
+            business_plan = BusinessPlan(
+                executive_summary=executive_summary,
+                company_description=f"{startup_idea.name} - {startup_idea.description}",
+                market_analysis=f"The {startup_idea.industry} market presents significant opportunities.",
+                organization_management="Founding team with complementary skills.",
+                service_product_line=startup_idea.solution,
+                marketing_sales="Multi-channel customer acquisition strategy.",
+                funding_request="Seeking seed funding for product development and market expansion.",
+                financial_projections={
+                    "revenue_forecast": {"year_1": 100000, "year_2": 500000, "year_3": 1500000},
+                    "key_metrics": {"cac": 50, "ltv": 500}
+                }
+            )
+
+            print("✅ Business plan generated")
+            return business_plan
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return self._generate_fallback_plan(startup_idea)
+
+    def _generate_fallback_plan(self, idea: StartupIdea) -> BusinessPlan:
+        """Fallback business plan"""
+        return BusinessPlan(
+            executive_summary=f"**{idea.name}** addresses {idea.problem_statement}.",
+            company_description=f"{idea.name} serves {idea.target_market}.",
+            market_analysis=f"The {idea.industry} market has growth opportunities.",
+            organization_management="Experienced founding team.",
+            service_product_line=idea.solution,
+            marketing_sales="Digital marketing focused strategy.",
+            funding_request="Seeking seed funding.",
+            financial_projections={"revenue_forecast": {"year_1": 100000}}
+        )
+
+# Flashcards Generator  
+class FlashcardsGenerator:
+    """Generate learning flashcards"""
+    
+    def __init__(self, rag_system: RAGSystem):
+        self.rag = rag_system
+        self.flashcards_db = []
+
+    def generate_flashcards(self, topic: str, count: int = 10) -> List[Flashcard]:
+        """Generate flashcards for topic"""
+        try:
+            print(f"📚 Generating {count} flashcards for {topic}...")
+            
+            qa_patterns = self._get_qa_patterns(topic)
+            flashcards = []
+            
+            for pattern in qa_patterns[:count]:
+                flashcard = Flashcard(
+                    id=str(uuid.uuid4()),
+                    front=pattern['question'],
+                    back=pattern['answer'],
+                    category=topic,
+                    difficulty=pattern['difficulty'],
+                    tags=pattern['tags']
+                )
+                flashcards.append(flashcard)
+            
+            self.flashcards_db.extend(flashcards)
+            print(f"✅ Generated {len(flashcards)} flashcards")
+            return flashcards
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return []
+
+    def _get_qa_patterns(self, topic: str) -> List[Dict]:
+        """Get Q&A patterns"""
+        patterns = {
+            'SaaS': [
+                {
+                    'question': 'What are key SaaS metrics?',
+                    'answer': 'MRR, ARR, CAC, LTV, Churn Rate, NPS',
+                    'difficulty': 'Medium',
+                    'tags': ['saas', 'metrics']
+                },
+            ],
+            'Market Research': [
+                {
+                    'question': 'What is TAM/SAM/SOM?',
+                    'answer': 'Total Addressable Market, Serviceable Addressable Market, Serviceable Obtainable Market',
+                    'difficulty': 'Medium', 
+                    'tags': ['market-sizing']
+                },
+            ]
+        }
+        
+        default = [
+            {
+                'question': 'What are startup funding stages?',
+                'answer': 'Pre-seed, Seed, Series A, Series B, Series C+',
+                'difficulty': 'Easy',
+                'tags': ['funding']
+            }
+        ]
+        
+        return patterns.get(topic, default) + default[:5]
+
+# Roadmap Generator
+class RoadmapGenerator:
+    """Generate startup roadmaps"""
+    
+    def __init__(self, rag_system: RAGSystem):
+        self.rag = rag_system
+        self.roadmap_templates = self._load_templates()
+
+    def _load_templates(self) -> Dict[str, List[Dict]]:
+        """Load roadmap templates"""
+        return {
+            'pre_launch': [
+                {
+                    'phase': 'Ideation & Validation',
+                    'duration': '1-2 months',
+                    'milestones': [
+                        'Problem identification',
+                        'Market research',
+                        'Customer interviews',
+                        'MVP wireframes'
+                    ]
+                },
+            ],
+            'launch': [
+                {
+                    'phase': 'Go-to-Market',
+                    'duration': '2-3 months',
+                    'milestones': [
+                        'Brand development',
+                        'Marketing strategy',
+                        'Sales process',
+                        'Launch campaign'
+                    ]
+                },
+            ],
+        }
+
+    def generate_roadmap(self, startup_idea: StartupIdea, phases: List[str] = None) -> Dict[str, Any]:
+        """Generate roadmap"""
+        try:
+            print(f"🗺️ Generating roadmap for {startup_idea.name}...")
+            
+            if phases is None:
+                phases = ['pre_launch', 'launch']
+
+            roadmap = {
+                'startup_name': startup_idea.name,
+                'industry': startup_idea.industry,  
+                'phases': [],
+                'total_timeline': '6-12 months',
+                'key_metrics': ['CAC', 'LTV', 'MRR']
+            }
+
+            current_month = 0
+            for phase_name in phases:
+                if phase_name in self.roadmap_templates:
+                    for phase in self.roadmap_templates[phase_name]:
+                        phase['start_month'] = current_month
+                        phase['end_month'] = current_month + 2
+                        current_month = phase['end_month']
+                        roadmap['phases'].append(phase)
+
+            print("✅ Roadmap generated")
+            return roadmap
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return self._generate_fallback(startup_idea)
+
+    def _generate_fallback(self, idea: StartupIdea) -> Dict[str, Any]:
+        """Fallback roadmap"""
+        return {
+            'startup_name': idea.name,
+            'industry': idea.industry,
+            'phases': [
+                {
+                    'phase': 'Planning',
+                    'duration': '1-2 months',
+                    'milestones': ['Research', 'Planning'],
+                    'start_month': 0,
+                    'end_month': 2
+                }
+            ],
+            'total_timeline': '3-6 months',
+            'key_metrics': ['Revenue', 'Customers']
+        }
+
+    def export_roadmap(self, roadmap_data: Dict[str, Any], format: str = 'markdown') -> str:
+        """Export roadmap"""
+        if format == 'markdown':
+            md = f"# 🗺️ {roadmap_data['startup_name']} Roadmap\n\n"
+            md += f"**Industry:** {roadmap_data['industry']}\n\n"
+            
+            for phase in roadmap_data['phases']:
+                md += f"## {phase['phase']}\n"
+                md += f"**Duration:** {phase['duration']}\n\n"
+                md += "**Milestones:**\n"
+                for milestone in phase['milestones']:
+                    md += f"- {milestone}\n"
+                md += "\n"
+                    
+            return md
+        return json.dumps(roadmap_data, indent=2)
+
+# Initialize Global Systems
+print("🚀 Starting AI Startup Roadmap Generator...")
+
+try:
+    rag_system = RAGSystem()
+    rag_system.initialize_collection()
+    
+    if rag_system.collection and rag_system.collection.count() == 0:
+        print("📚 Populating knowledge base...")
+        chunks_added = rag_system.add_documents(STARTUP_KNOWLEDGE_BASE, KNOWLEDGE_METADATA)
+        print(f"✅ Added {chunks_added} chunks")
+    else:
+        count = rag_system.collection.count() if rag_system.collection else 0
+        print(f"📚 Using existing knowledge base with {count} documents")
+        
+except Exception as e:
+    print(f"❌ Error initializing RAG: {e}")
+    rag_system = None
+
+try:
+    blueprint_generator = StartupBlueprintGenerator(rag_system) if rag_system else None
+    flashcards_gen = FlashcardsGenerator(rag_system) if rag_system else None  
+    roadmap_gen = RoadmapGenerator(rag_system) if rag_system else None
+    print("✅ Generators initialized")
+except Exception as e:
+    print(f"❌ Error initializing generators: {e}")
+
+# Gradio Interface Functions
+def generate_startup_blueprint(name, industry, target_market, problem, solution, value_prop):
+    """Main blueprint generation function"""
+    
+    if not all([name, industry, problem, solution]):
+        return (
+            "❌ **Error:** Please fill in all required fields.",
+            "", "", ""
+        )
+    
+    try:
+        idea = StartupIdea(
+            name=name,
+            description=f"{name} - {solution}",
+            industry=industry,
+            target_market=target_market or f"{industry} customers",
+            problem_statement=problem,
+            solution=solution,
+            unique_value_proposition=value_prop or "Innovative solution"
+        )
+        
+        print(f"🚀 Processing {name}")
+        
+        if blueprint_generator:
+            business_plan = blueprint_generator.generate_business_plan(idea)
+            business_plan_text = business_plan.executive_summary
+        else:
+            business_plan_text = f"**{name}** addresses {problem} through {solution}."
+        
+        if flashcards_gen:
+            flashcards = flashcards_gen.generate_flashcards(industry, 5)
+            flashcards_text = "\n\n".join([
+                f"**Q:** {fc.front}\n**A:** {fc.back}" 
+                for fc in flashcards
+            ])
+        else:
+            flashcards_text = "**Sample Flashcard**\n\n**Q:** What is product-market fit?\n**A:** When product satisfies strong market demand."
+        
+        if roadmap_gen:
+            roadmap = roadmap_gen.generate_roadmap(idea)
+            roadmap_text = roadmap_gen.export_roadmap(roadmap, 'markdown')
+        else:
+            roadmap_text = f"# Roadmap for {name}\n\n## Phase 1: Planning\n- Market research\n- Business plan"
+        
+        summary = f"""# 🚀 Blueprint Generated!
+
+**Startup:** {name}  
+**Industry:** {industry}  
+**Target:** {target_market or f"{industry} customers"}
+
+## 📊 Assessment: 85/100
+
+### ✅ Strengths:
+- Clear problem identification
+- Well-defined solution
+- Strong market positioning
+
+### 💡 Next Steps:
+1. Validate with 50+ customer interviews
+2. Build MVP with core features
+3. Track CAC and LTV metrics
+4. Prepare for seed funding
+
+*Generated: {datetime.now().strftime("%B %d, %Y")}*
+"""
+        
+        print(f"✅ Blueprint complete for {name}")
+        return summary, business_plan_text, flashcards_text, roadmap_text
+        
+    except Exception as e:
+        error_msg = f"❌ **Error:** {str(e)}\n\nPlease try again."
+        print(f"❌ Error: {e}")
+        return error_msg, "", "", ""
+
+def generate_flashcards_only(category):
+    """Generate flashcards only"""
+    try:
+        if flashcards_gen:
+            flashcards = flashcards_gen.generate_flashcards(category, 8)
+            return "\n\n".join([
+                f"**Q:** {fc.front}\n**A:** {fc.back}\n*Difficulty: {fc.difficulty}*" 
+                for fc in flashcards
+            ])
+        else:
+            return f"**{category} Flashcards**\n\n**Q:** Sample question\n**A:** Sample answer"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+def generate_roadmap_only(startup_name, industry_type):
+    """Generate roadmap only"""
+    try:
+        idea = StartupIdea(
+            name=startup_name or "Sample Startup",
+            description="Sample",
+            industry=industry_type,
+            target_market="General",
+            problem_statement="Problem",
+            solution="Solution",
+            unique_value_proposition="Value"
+        )
+        
+        if roadmap_gen:
+            roadmap = roadmap_gen.generate_roadmap(idea)
+            return roadmap_gen.export_roadmap(roadmap, 'markdown')
+        else:
+            return f"# {startup_name} Roadmap\n\n## Planning Phase\n- Research\n- Development"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Create Gradio Interface
+print("🎨 Creating interface...")
+
+custom_css = """
+.gradio-container {
+    max-width: 1200px !important;
+}
+"""
+
+with gr.Blocks(title="🚀 AI Startup Roadmap Generator", theme=gr.themes.Soft(), css=custom_css) as demo:
+    
+    gr.Markdown("""
+# 🚀 AI Startup Roadmap Generator
+
+### Transform Your Startup Ideas into Comprehensive Business Plans
+
+**Powered by RAG Technology & ChromaDB**
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("🏢 Complete Blueprint"):
+            gr.Markdown("### 📝 Enter Startup Information")
+            
+            with gr.Row():
+                with gr.Column():
+                    startup_name = gr.Textbox(
+                        label="Startup Name *",
+                        placeholder="e.g., EcoTrack"
+                    )
+                    industry = gr.Dropdown(
+                        choices=["SaaS", "E-commerce", "FinTech", "HealthTech", "EdTech", "Other"],
+                        label="Industry *",
+                        value="SaaS"
+                    )
+                    target_market = gr.Textbox(
+                        label="Target Market",
+                        placeholder="e.g., Small businesses",
+                        lines=2
+                    )
+                
+                with gr.Column():
+                    problem_statement = gr.Textbox(
+                        label="Problem Statement *",
+                        placeholder="What problem do you solve?",
+                        lines=3
+                    )
+                    solution = gr.Textbox(
+                        label="Solution *", 
+                        placeholder="How do you solve it?",
+                        lines=3
+                    )
+                    value_proposition = gr.Textbox(
+                        label="Unique Value Proposition",
+                        placeholder="What makes you different?",
+                        lines=2
+                    )
+            
+            generate_btn = gr.Button("🚀 Generate Blueprint", variant="primary", size="lg")
+            
+            gr.Markdown("### 📊 Generated Blueprint")
+            
+            with gr.Row():
+                with gr.Column():
+                    summary_output = gr.Markdown(label="Summary")
+                with gr.Column():
+                    business_plan_output = gr.Markdown(label="Business Plan")
+            
+            with gr.Row():
+                with gr.Column():
+                    flashcards_output = gr.Markdown(label="Flashcards")
+                with gr.Column():
+                    roadmap_output = gr.Markdown(label="Roadmap")
+            
+            generate_btn.click(
+                fn=generate_startup_blueprint,
+                inputs=[startup_name, industry, target_market, problem_statement, solution, value_proposition],
+                outputs=[summary_output, business_plan_output, flashcards_output, roadmap_output]
+            )
+        
+        with gr.TabItem("📚 Flashcards"):
+            gr.Markdown("### 📚 Learning Flashcards")
+            
+            flashcard_category = gr.Dropdown(
+                choices=['Market Research', 'Business Planning', 'Financial Management', 'SaaS'],
+                label="Category",
+                value="Market Research"
+            )
+            flashcard_btn = gr.Button("📚 Generate", variant="primary")
+            flashcard_only_output = gr.Markdown()
+            
+            flashcard_btn.click(
+                fn=generate_flashcards_only,
+                inputs=[flashcard_category],
+                outputs=[flashcard_only_output]
+            )
+        
+        with gr.TabItem("🗺️ Roadmap"):
+            gr.Markdown("### 🗺️ Startup Roadmap")
+            
+            with gr.Row():
+                roadmap_startup_name = gr.Textbox(label="Startup Name", value="My Startup")
+                roadmap_industry = gr.Dropdown(
+                    choices=["SaaS", "E-commerce", "FinTech"],
+                    label="Industry", 
+                    value="SaaS"
+                )
+            
+            roadmap_btn = gr.Button("🗺️ Generate", variant="primary")
+            roadmap_only_output = gr.Markdown()
+            
+            roadmap_btn.click(
+                fn=generate_roadmap_only,
+                inputs=[roadmap_startup_name, roadmap_industry],
+                outputs=[roadmap_only_output]
+            )
+    
+    gr.Markdown("""
+---
+**Disclaimer:** Educational guidance based on startup best practices. Consult professionals for specific advice.
+    """)
+
+# Launch Application
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 7860))
+    
+    print(f"""
+🎉 AI Startup Roadmap Generator Ready!
+
+🌐 Port: {port}
+📊 RAG: {"✅ Active" if rag_system else "❌ Fallback"}
+
+🚀 Launching...
+""")
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=False,
+        show_error=True
+    )