Spaces:
Runtime error
Runtime error
| 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 | |
| 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 | |
| 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] | |
| class Flashcard: | |
| """Learning flashcard structure""" | |
| id: str | |
| front: str | |
| back: str | |
| category: str | |
| difficulty: str | |
| tags: List[str] | |
| 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: | |
| # Try to get existing collection first | |
| 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}") | |
| # Fallback: create new collection | |
| 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: | |
| # Split documents into chunks | |
| all_chunks = [] | |
| all_metadatas = [] | |
| for i, doc in enumerate(documents): | |
| chunks = self.text_splitter.split_text(doc) | |
| all_chunks.extend(chunks) | |
| # Add metadata for each chunk | |
| 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() | |
| }) | |
| # Generate embeddings | |
| print(f"🔄 Generating embeddings for {len(all_chunks)} chunks...") | |
| embeddings = self.embedding_model.encode(all_chunks).tolist() | |
| # Add to collection | |
| 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: | |
| # Generate query embedding | |
| query_embedding = self.embedding_model.encode([query]).tolist()[0] | |
| # Query the collection | |
| results = self.collection.query( | |
| query_embeddings=[query_embedding], | |
| n_results=min(n_results, self.collection.count()) | |
| ) | |
| # Format results | |
| 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: | |
| # Combine context | |
| context_text = "\n".join([ctx["content"] for ctx in context]) | |
| # Generate structured response based on query type | |
| 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 | |
| - Validate assumptions through customer interviews and surveys | |
| - Track key metrics: CAC, LTV, market penetration rate | |
| """ | |
| elif "business plan" in query_lower: | |
| return f""" | |
| **Business Plan Development:** | |
| Essential components based on successful startups: | |
| {context[:500]}... | |
| **Core Sections to Include:** | |
| - Executive Summary (mission, product, competitive advantages) | |
| - Market Analysis (industry overview, target market, competition) | |
| - Financial Projections (revenue forecasts, expense budgets, break-even analysis) | |
| - Marketing Strategy (customer acquisition, pricing model, sales process) | |
| - Funding Requirements (capital needs, use of funds, ROI projections) | |
| """ | |
| elif "funding" in query_lower or "investment" in query_lower: | |
| return f""" | |
| **Funding Strategy:** | |
| {context[:500]}... | |
| **Funding Options:** | |
| - Bootstrapping: Use personal savings (most common first step) | |
| - Angel Investors: High-net-worth individuals + mentorship | |
| - Venture Capital: Pooled funds for high-growth startups | |
| - Crowdfunding: Small amounts from many people online | |
| - Grants/Loans: Government programs and bank financing | |
| **Key Preparation Steps:** | |
| - Develop compelling pitch deck (10-12 slides) | |
| - Prepare detailed financial projections (3-5 years) | |
| - Build prototype or MVP to demonstrate traction | |
| - Gather customer validation and testimonials | |
| """ | |
| else: | |
| return f""" | |
| **Strategic Guidance:** | |
| {context[:400]}... | |
| **Key Considerations:** | |
| - Validate your assumptions with real market data | |
| - Focus on solving a genuine problem for a specific customer segment | |
| - Build strong unit economics (LTV/CAC ratio > 3:1) | |
| - Assemble a complementary founding team with diverse skills | |
| - Develop a clear go-to-market strategy | |
| **Next Steps:** | |
| - Conduct customer discovery interviews | |
| - Create a minimum viable product (MVP) | |
| - Test your pricing model with early customers | |
| - Build financial projections and fundraising plan | |
| """ | |
| # 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. Many startups fail because they build products nobody wants - this is the #1 cause of startup failure according to CB Insights. | |
| 2. Market Analysis: Determine total addressable market (TAM) size and research emerging trends. Use frameworks like TAM/SAM/SOM: | |
| - TAM (Total Addressable Market): Total market demand for a product/service | |
| - SAM (Serviceable Addressable Market): The portion of TAM targeted by your products and services | |
| - SOM (Serviceable Obtainable Market): The portion of SAM that you can realistically capture | |
| 3. Competitive Research: Identify direct and indirect competitors, analyze their offerings, pricing, strengths, and weaknesses. Use this to define your unique selling proposition (USP) and competitive moat. | |
| 4. Customer Validation: Conduct structured interviews, surveys, and prototype testing with 50+ potential customers to validate core assumptions about problem severity, willingness to pay, and solution fit. | |
| 5. Market Sizing: Calculate addressable market using bottom-up (customer count × price) and top-down (market reports) approaches. | |
| Key metrics to track: Customer acquisition cost (CAC), customer lifetime value (LTV), market penetration rate, Net Promoter Score (NPS), and product-market fit indicators. | |
| """, | |
| """ | |
| BUSINESS PLAN DEVELOPMENT | |
| A comprehensive business plan serves as both internal roadmap and external communication tool for investors: | |
| 1. Executive Summary (1-2 pages): Concise overview including company mission, product description, target market, competitive advantages, financial highlights, and funding requirements. This is often the only section investors read initially. | |
| 2. Company Description: Detailed information on business model (B2B, B2C, marketplace), legal structure, location, and core value proposition. Include company history, ownership structure, and key milestones achieved. | |
| 3. Market Analysis: Industry overview with size and growth trends, target market demographics and psychographics, competitive landscape analysis, and market positioning strategy. | |
| 4. Organization & Management: Legal structure (LLC, C-Corp, etc.), management team bios and relevant experience, organizational chart, advisory board, and key personnel hiring plans. | |
| 5. Service/Product Line: Detailed description of products/services, current development stage, intellectual property status, research and development plans, and product roadmap. | |
| 6. Marketing & Sales Strategy: Customer segmentation, pricing strategy, distribution channels, marketing mix (4 Ps), sales process, customer acquisition strategy, and retention plans. | |
| 7. Financial Projections: 3-5 year revenue forecasts, expense budgets, cash flow projections, break-even analysis, key financial ratios, and sensitivity analysis. | |
| 8. Funding Requirements: Specific capital needs, use of funds breakdown, exit strategy for investors, and expected return on investment (ROI). | |
| """, | |
| """ | |
| FUNDING AND FINANCIAL MANAGEMENT | |
| Securing and managing finances strategically is critical for startup survival and growth: | |
| 1. Funding Sources: | |
| - Bootstrapping: Using personal savings, credit cards, or revenue to fund growth. Maintains full control but limits scale. | |
| - Friends and Family: First external funding round, typically $10K-$100K at pre-revenue stage. | |
| - Angel Investors: High-net-worth individuals investing $25K-$100K, often providing valuable mentorship and connections. | |
| - Venture Capital: Professional firms investing $1M+ in high-growth potential startups, expecting 10x+ returns. | |
| - Crowdfunding: Platforms like Kickstarter, Indiegogo for product launches or equity crowdfunding via Republic, SeedInvest. | |
| - Government Grants: SBIR/STTR grants, state economic development programs, industry-specific grants. | |
| 2. Financial Management Best Practices: | |
| - Separate business and personal finances immediately | |
| - Implement robust accounting systems (QuickBooks, FreshBooks) | |
| - Track key metrics: Monthly Recurring Revenue (MRR), Annual Recurring Revenue (ARR), gross margins, burn rate, runway | |
| - Maintain 6-12 months of operating expenses in cash reserves | |
| - Regular financial reporting and board updates | |
| 3. Key Financial Metrics: | |
| - Burn Rate: Monthly cash expenditure | |
| - Runway: Months of cash remaining at current burn rate | |
| - Customer Acquisition Cost (CAC): Total sales and marketing expenses ÷ number of new customers | |
| - Customer Lifetime Value (LTV): Average revenue per customer × gross margin % × average customer lifespan | |
| - LTV/CAC Ratio: Should be 3:1 or higher for sustainable unit economics | |
| 4. Fundraising Process: | |
| - Prepare comprehensive pitch deck (10-12 slides) | |
| - Create detailed financial model with scenarios | |
| - Build investor pipeline with warm introductions | |
| - Practice pitch extensively before investor meetings | |
| - Negotiate terms carefully (valuation, board seats, liquidation preferences) | |
| """, | |
| """ | |
| LEGAL STRUCTURE AND COMPLIANCE | |
| Choosing the right legal foundation protects founders and enables future growth: | |
| 1. Business Structure Options: | |
| - Sole Proprietorship: Simplest form, personal liability for all debts and obligations | |
| - Partnership: Shared ownership and liability, requires partnership agreement | |
| - Limited Liability Company (LLC): Personal asset protection, flexible tax options, simpler compliance | |
| - C-Corporation: Strongest liability protection, can issue stock to investors, double taxation | |
| - S-Corporation: Pass-through taxation, limited to 100 shareholders, all must be US citizens | |
| 2. Delaware C-Corp Advantages for Startups: | |
| - Well-established corporate law and court system | |
| - Investor familiarity and preference | |
| - Flexible stock structure (common, preferred) | |
| - Strong director and officer protection | |
| - Easy to convert from LLC if needed | |
| 3. Essential Legal Documents: | |
| - Articles of Incorporation/Organization filed with state | |
| - Corporate bylaws or operating agreement | |
| - Founders' Agreement: equity split, vesting schedules, intellectual property assignment, roles and responsibilities | |
| - Employee agreements: offer letters, non-disclosure agreements (NDAs), invention assignment | |
| - Customer agreements: terms of service, privacy policy, service level agreements (SLAs) | |
| 4. Intellectual Property Protection: | |
| - Trademarks: Protect brand names, logos, and slogans ($275-$325 per class) | |
| - Patents: Protect unique inventions and processes ($5,000-$15,000+ including attorney fees) | |
| - Copyrights: Protect creative works like software code, marketing materials | |
| - Trade Secrets: Protect proprietary processes, customer lists, algorithms through confidentiality | |
| 5. Compliance Requirements: | |
| - Federal EIN (Employer Identification Number) | |
| - State and local business licenses | |
| - Industry-specific permits and certifications | |
| - Sales tax registration if selling products | |
| - Employment law compliance (workers' compensation, unemployment insurance) | |
| - Data privacy compliance (GDPR, CCPA, HIPAA if applicable) | |
| """, | |
| """ | |
| TEAM BUILDING AND OPERATIONS | |
| Building the right team and operational foundation scales with your startup: | |
| 1. Founding Team Composition: | |
| - Complementary skills covering key functions: technical, business development, domain expertise | |
| - Diverse perspectives and backgrounds for better decision-making | |
| - Aligned vision, values, and commitment to long-term success | |
| - Previous startup experience or relevant industry expertise preferred | |
| - Equity split should reflect contribution, risk, and future value creation | |
| 2. Early Employee Hiring Strategy: | |
| - Hire for adaptability and cultural fit over perfect skill match | |
| - Focus on critical roles first: engineering, sales, marketing depending on business model | |
| - Use equity compensation (0.1%-10% depending on role and stage) to attract talent | |
| - Implement 4-year vesting schedules with 1-year cliffs | |
| - Create strong onboarding processes and company culture documentation | |
| 3. Operational Excellence: | |
| - Develop Minimum Viable Product (MVP) with core features only | |
| - Establish sales and distribution channels appropriate for target market | |
| - Define and track Key Performance Indicators (KPIs) for each business function | |
| - Create scalable business processes using automation tools | |
| - Implement customer support systems and feedback loops | |
| - Build quality assurance and testing procedures | |
| 4. Key Metrics to Track by Function: | |
| - Product: Daily/Monthly Active Users (DAU/MAU), feature adoption rates, user retention cohorts | |
| - Sales: Lead conversion rates, sales cycle length, average contract value (ACV) | |
| - Marketing: Cost per lead (CPL), marketing qualified leads (MQLs), brand awareness metrics | |
| - Operations: Customer satisfaction scores, support ticket resolution time, operational efficiency ratios | |
| - Finance: Revenue growth rate, gross margins, working capital management | |
| 5. Scaling Considerations: | |
| - Document processes and procedures before they become bottlenecks | |
| - Invest in tools and systems that grow with the company | |
| - Build management capabilities and delegation skills | |
| - Create career development paths to retain top talent | |
| - Establish board of directors and advisory board for guidance | |
| """, | |
| """ | |
| BRAND DEVELOPMENT AND MARKETING | |
| Strong branding and customer acquisition strategy drives sustainable growth: | |
| 1. Brand Identity Development: | |
| - Define brand values, personality, and voice that resonates with target customers | |
| - Create unique selling proposition (USP) that differentiates from competitors | |
| - Develop consistent visual identity: logo, color palette, typography, imagery style | |
| - Establish brand positioning in the market landscape | |
| - Create brand guidelines document for consistent application | |
| 2. Digital Presence Foundation: | |
| - Secure primary domain and social media handles across platforms | |
| - Build professional website with clear value proposition and calls-to-action | |
| - Optimize for search engines (SEO) with relevant keywords and quality content | |
| - Implement analytics tracking (Google Analytics, Mixpanel) from day one | |
| - Create content calendar and editorial strategy | |
| 3. Customer Acquisition Channels: | |
| - Content Marketing: Blog posts, whitepapers, case studies, webinars to establish thought leadership | |
| - Social Media Marketing: Platform-specific strategies for LinkedIn (B2B), Instagram (B2C), Twitter (tech) | |
| - Search Engine Marketing: Google Ads, Bing Ads with targeted keywords and landing pages | |
| - Email Marketing: Newsletter campaigns, drip sequences, automated workflows | |
| - Partnership Marketing: Co-marketing with complementary businesses, affiliate programs | |
| - Public Relations: Media outreach, press releases, industry award submissions | |
| 4. Marketing Metrics and Attribution: | |
| - Website traffic: unique visitors, page views, bounce rate, session duration | |
| - Conversion funnel: visitor-to-lead, lead-to-customer conversion rates | |
| - Channel performance: CAC by channel, LTV by acquisition source | |
| - Content performance: engagement rates, social shares, backlink acquisition | |
| - Brand metrics: brand awareness, consideration, and preference tracking | |
| 5. Customer Success and Retention: | |
| - Implement customer feedback loops: surveys, interviews, usage analytics | |
| - Create customer success programs for high-value accounts | |
| - Build community around your product: user groups, forums, events | |
| - Develop referral and loyalty programs to encourage word-of-mouth marketing | |
| - Monitor and improve Net Promoter Score (NPS) and customer satisfaction metrics | |
| """ | |
| ] | |
| # Metadata for knowledge base | |
| 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 for different blueprint sections""" | |
| 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} | |
| ### Competitive Advantage | |
| {unique_value_proposition} | |
| """, | |
| "market_analysis": """ | |
| ## Market Analysis | |
| ### Industry Overview | |
| {industry_overview} | |
| ### Target Market | |
| {target_market} | |
| ### Market Size Analysis | |
| - **Total Addressable Market (TAM):** {tam} | |
| - **Serviceable Addressable Market (SAM):** {sam} | |
| - **Serviceable Obtainable Market (SOM):** {som} | |
| ### Competitive Landscape | |
| {competitive_analysis} | |
| ### Market Trends | |
| - Growing demand for digital solutions | |
| - Increasing adoption in target demographics | |
| - Favorable regulatory environment | |
| """, | |
| "financial_plan": """ | |
| ## Financial Plan & Projections | |
| ### Revenue Model | |
| {revenue_model} | |
| ### Key Financial Metrics | |
| - **Customer Acquisition Cost (CAC):** {cac} | |
| - **Customer Lifetime Value (LTV):** {ltv} | |
| - **LTV/CAC Ratio:** {ltv_cac_ratio} | |
| - **Monthly Recurring Revenue (MRR):** {mrr} | |
| ### 3-Year Financial Forecast | |
| | Year | Revenue | Expenses | Net Income | | |
| |------|---------|----------|------------| | |
| | 1 | $100K | $150K | ($50K) | | |
| | 2 | $500K | $400K | $100K | | |
| | 3 | $1.5M | $800K | $700K | | |
| ### Funding Requirements | |
| {funding_requirements} | |
| """, | |
| "operations_plan": """ | |
| ## Operations & Implementation Plan | |
| ### Team Structure | |
| {team_structure} | |
| ### Key Processes | |
| {key_processes} | |
| ### Technology Stack | |
| {technology_stack} | |
| ### Milestones & Timeline | |
| {milestones} | |
| ### Risk Management | |
| - Market risk mitigation strategies | |
| - Operational contingency plans | |
| - Financial risk management | |
| - Competitive response plans | |
| """ | |
| } | |
| def generate_business_plan(self, startup_idea: StartupIdea) -> BusinessPlan: | |
| """Generate comprehensive business plan using RAG context""" | |
| try: | |
| print(f"📊 Generating business plan for {startup_idea.name}...") | |
| # Get relevant context for each section | |
| exec_context = self.rag.retrieve_context( | |
| f"executive summary for {startup_idea.industry} startup", | |
| n_results=3 | |
| ) | |
| market_context = self.rag.retrieve_context( | |
| f"market analysis {startup_idea.industry} {startup_idea.target_market}", | |
| n_results=3 | |
| ) | |
| financial_context = self.rag.retrieve_context( | |
| f"financial planning funding {startup_idea.industry}", | |
| n_results=3 | |
| ) | |
| # Generate each section | |
| executive_summary = self._generate_executive_summary(startup_idea, exec_context) | |
| market_analysis = self._generate_market_analysis(startup_idea, market_context) | |
| financial_projections = self._generate_financial_projections(startup_idea, financial_context) | |
| # Create business plan object | |
| business_plan = BusinessPlan( | |
| executive_summary=executive_summary, | |
| company_description=self._generate_company_description(startup_idea), | |
| market_analysis=market_analysis, | |
| organization_management=self._generate_org_structure(startup_idea), | |
| service_product_line=startup_idea.solution, | |
| marketing_sales=self._generate_marketing_plan(startup_idea), | |
| funding_request=self._generate_funding_request(startup_idea), | |
| financial_projections=financial_projections | |
| ) | |
| self.model_data['business_plan'] = business_plan | |
| print("✅ Business plan generated successfully") | |
| return business_plan | |
| except Exception as e: | |
| print(f"❌ Error generating business plan: {e}") | |
| # Return fallback business plan | |
| return self._generate_fallback_business_plan(startup_idea) | |
| def _generate_executive_summary(self, idea: StartupIdea, context: List[Dict]) -> str: | |
| """Generate executive summary with RAG context""" | |
| return self.templates["executive_summary"].format( | |
| company_name=idea.name, | |
| industry=idea.industry, | |
| mission=f"To solve {idea.problem_statement} for {idea.target_market}", | |
| problem_statement=idea.problem_statement, | |
| solution=idea.solution, | |
| market_opportunity=f"Significant opportunity in the growing {idea.industry} market", | |
| projected_revenue="$1M - $5M", | |
| funding_needed="$250K - $1M", | |
| breakeven_timeline="18-24 months", | |
| unique_value_proposition=idea.unique_value_proposition | |
| ) | |
| def _generate_market_analysis(self, idea: StartupIdea, context: List[Dict]) -> str: | |
| """Generate market analysis with RAG context""" | |
| return self.templates["market_analysis"].format( | |
| industry_overview=f"The {idea.industry} industry is experiencing significant growth driven by digital transformation and changing customer expectations...", | |
| target_market=idea.target_market, | |
| tam="$10B+ (Global market size)", | |
| sam="$1B+ (Addressable market)", | |
| som="$100M+ (Obtainable market share)", | |
| competitive_analysis="Key competitors include established players and emerging startups. Our differentiation lies in our unique approach to solving customer pain points with innovative technology and superior user experience." | |
| ) | |
| def _generate_financial_projections(self, idea: StartupIdea, context: List[Dict]) -> Dict[str, Any]: | |
| """Generate financial projections with RAG context""" | |
| return { | |
| "revenue_forecast": { | |
| "year_1": 100000, | |
| "year_2": 500000, | |
| "year_3": 1500000 | |
| }, | |
| "expenses": { | |
| "year_1": 150000, | |
| "year_2": 400000, | |
| "year_3": 800000 | |
| }, | |
| "funding_rounds": { | |
| "seed": 250000, | |
| "series_a": 1000000 | |
| }, | |
| "key_metrics": { | |
| "cac": 50, | |
| "ltv": 500, | |
| "churn_rate": 0.05, | |
| "gross_margin": 0.80 | |
| } | |
| } | |
| def _generate_company_description(self, idea: StartupIdea) -> str: | |
| return f""" | |
| **{idea.name}** is an innovative {idea.industry} company that {idea.description.lower()}. | |
| **Our Mission:** To transform how {idea.target_market} solve {idea.problem_statement.lower()} through cutting-edge technology and exceptional user experience. | |
| **Our Solution:** {idea.solution} | |
| **Unique Value Proposition:** {idea.unique_value_proposition} | |
| **Target Market:** We serve {idea.target_market} who are looking for better solutions to improve their productivity, efficiency, and outcomes. | |
| """ | |
| def _generate_org_structure(self, idea: StartupIdea) -> str: | |
| return """ | |
| ## Organizational Structure | |
| **Legal Structure:** Delaware C-Corporation (recommended for funding) | |
| **Founding Team:** | |
| - **CEO/Founder:** Vision, strategy, fundraising, and business development | |
| - **CTO/Co-founder:** Technology leadership, product development, and technical strategy | |
| - **VP Marketing:** Customer acquisition, brand building, and market expansion | |
| **Advisory Board:** | |
| - Industry expert with 15+ years experience | |
| - Former startup founder with successful exit | |
| - Marketing specialist with growth expertise | |
| - Finance/funding advisor with VC connections | |
| **Hiring Plan (Next 12 months):** | |
| - Senior Software Engineer (Month 3) | |
| - Sales Manager (Month 6) | |
| - Customer Success Manager (Month 9) | |
| - Data Analyst (Month 12) | |
| """ | |
| def _generate_marketing_plan(self, idea: StartupIdea) -> str: | |
| return f""" | |
| ## Marketing & Sales Strategy | |
| **Target Customer Profile:** {idea.target_market} | |
| **Go-to-Market Strategy:** | |
| 1. **Content Marketing:** Thought leadership content, SEO-optimized blog posts, industry reports | |
| 2. **Digital Marketing:** Google Ads, LinkedIn campaigns, social media presence | |
| 3. **Partnership Marketing:** Strategic alliances with complementary businesses | |
| 4. **Sales Strategy:** Consultative selling approach with demo-driven process | |
| **Customer Acquisition Channels:** | |
| - **Inbound Marketing (40%):** SEO, content marketing, organic social media | |
| - **Paid Advertising (30%):** Google Ads, LinkedIn Ads, industry publications | |
| - **Partnerships (20%):** Referral programs, channel partnerships, integrations | |
| - **Direct Sales (10%):** Outbound prospecting, trade shows, industry events | |
| **Pricing Strategy:** | |
| - Freemium model to drive adoption | |
| - Tiered subscription plans ($29/month, $99/month, $299/month) | |
| - Enterprise custom pricing for large accounts | |
| **Sales Process:** | |
| 1. Lead generation through marketing channels | |
| 2. Qualification and discovery calls | |
| 3. Product demonstration and trial | |
| 4. Proposal and negotiation | |
| 5. Contract signing and onboarding | |
| """ | |
| def _generate_funding_request(self, idea: StartupIdea) -> str: | |
| return """ | |
| ## Funding Request | |
| **Funding Needed:** $500,000 - $1,000,000 (Seed Round) | |
| **Use of Funds:** | |
| - **Product Development (40% - $400K):** Engineering team, infrastructure, R&D | |
| - **Marketing & Customer Acquisition (35% - $350K):** Digital marketing, content, events | |
| - **Team Expansion (20% - $200K):** Key hires, recruiting, onboarding | |
| - **Operations & Overhead (5% - $50K):** Office, legal, accounting, insurance | |
| **Investment Terms:** | |
| - Seeking experienced angel investors and seed VCs | |
| - Target equity stake: 15-25% | |
| - Board composition: 2 founders, 1 investor, 1 independent | |
| - Preferred stock with standard liquidation preferences | |
| **Projected ROI:** | |
| - 3-year revenue target: $1.5M - $5M | |
| - Expected valuation at Series A: $10M - $25M | |
| - Potential exit opportunities: Strategic acquisition or IPO in 5-7 years | |
| **Milestones for Next Round:** | |
| - $100K+ Monthly Recurring Revenue (MRR) | |
| - 1,000+ paying customers | |
| - Proven unit economics (LTV/CAC > 3:1) | |
| - Strong product-market fit metrics | |
| """ | |
| def _generate_fallback_business_plan(self, idea: StartupIdea) -> BusinessPlan: | |
| """Generate basic business plan if RAG fails""" | |
| return BusinessPlan( | |
| executive_summary=f"**{idea.name}** addresses {idea.problem_statement} in the {idea.industry} industry through {idea.solution}.", | |
| company_description=f"{idea.name} serves {idea.target_market} with innovative solutions.", | |
| market_analysis=f"The {idea.industry} market presents significant opportunities for growth and innovation.", | |
| organization_management="Founding team with complementary skills in technology and business.", | |
| service_product_line=idea.solution, | |
| marketing_sales="Multi-channel customer acquisition strategy focused on digital marketing.", | |
| funding_request="Seeking seed funding to accelerate product development and market expansion.", | |
| financial_projections={ | |
| "revenue_forecast": {"year_1": 100000, "year_2": 500000, "year_3": 1500000}, | |
| "key_metrics": {"cac": 50, "ltv": 500} | |
| } | |
| ) | |
| # Flashcards Generator | |
| class FlashcardsGenerator: | |
| """Generate learning flashcards from startup knowledge""" | |
| 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 a specific topic""" | |
| try: | |
| print(f"📚 Generating {count} flashcards for {topic}...") | |
| # Get relevant context from RAG | |
| context = self.rag.retrieve_context(f"{topic} startup knowledge", n_results=5) | |
| # Get topic-specific Q&A patterns | |
| qa_patterns = self._get_qa_patterns(topic) | |
| flashcards = [] | |
| for i, pattern in enumerate(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 generating flashcards: {e}") | |
| return [] | |
| def _get_qa_patterns(self, topic: str) -> List[Dict]: | |
| """Get question-answer patterns for different topics""" | |
| patterns = { | |
| 'SaaS': [ | |
| { | |
| 'question': 'What are the key SaaS metrics every founder should track?', | |
| 'answer': 'Monthly Recurring Revenue (MRR), Annual Recurring Revenue (ARR), Customer Acquisition Cost (CAC), Customer Lifetime Value (LTV), Churn Rate, and Net Promoter Score (NPS)', | |
| 'difficulty': 'Medium', | |
| 'tags': ['saas', 'metrics', 'kpi'] | |
| }, | |
| { | |
| 'question': 'What is the ideal LTV/CAC ratio for a SaaS business?', | |
| 'answer': 'The ideal LTV/CAC ratio is 3:1 or higher. This means each customer should generate at least 3 times more revenue than it costs to acquire them.', | |
| 'difficulty': 'Hard', | |
| 'tags': ['saas', 'unit-economics', 'metrics'] | |
| }, | |
| ], | |
| 'Market Research': [ | |
| { | |
| 'question': 'What are the three types of market sizing?', | |
| 'answer': 'TAM (Total Addressable Market), SAM (Serviceable Addressable Market), and SOM (Serviceable Obtainable Market)', | |
| 'difficulty': 'Medium', | |
| 'tags': ['market-sizing', 'analysis'] | |
| }, | |
| { | |
| 'question': 'What is the primary goal of customer validation?', | |
| 'answer': 'To prove that there is genuine demand for your product/service before building it, reducing the risk of building something nobody wants', | |
| 'difficulty': 'Easy', | |
| 'tags': ['validation', 'product-market-fit'] | |
| }, | |
| ], | |
| 'FinTech': [ | |
| { | |
| 'question': 'What are the main regulatory considerations for FinTech startups?', | |
| 'answer': 'KYC (Know Your Customer), AML (Anti-Money Laundering), PCI DSS compliance, data privacy regulations (GDPR, CCPA), and industry-specific regulations like PSD2 in Europe', | |
| 'difficulty': 'Hard', | |
| 'tags': ['fintech', 'compliance', 'regulation'] | |
| }, | |
| ], | |
| 'E-commerce': [ | |
| { | |
| 'question': 'What are the key conversion metrics for e-commerce?', | |
| 'answer': 'Conversion rate, Average Order Value (AOV), Cart Abandonment Rate, Customer Acquisition Cost (CAC), and Return on Ad Spend (ROAS)', | |
| 'difficulty': 'Medium', | |
| 'tags': ['ecommerce', 'conversion', 'metrics'] | |
| }, | |
| ] | |
| } | |
| # Default patterns for any topic | |
| default_patterns = [ | |
| { | |
| 'question': 'What are the main startup funding stages?', | |
| 'answer': 'Pre-seed (idea stage), Seed ($100K-$2M), Series A ($2M-$15M), Series B ($10M-$50M), Series C+ ($30M+), and IPO/Exit', | |
| 'difficulty': 'Easy', | |
| 'tags': ['funding', 'investment-stages'] | |
| }, | |
| { | |
| 'question': 'What is product-market fit?', | |
| 'answer': 'The degree to which a product satisfies a strong market demand. Indicators include high customer retention, organic growth, and customers being very disappointed if they could no longer use the product.', | |
| 'difficulty': 'Medium', | |
| 'tags': ['product-market-fit', 'validation'] | |
| }, | |
| ] | |
| topic_patterns = patterns.get(topic, default_patterns) | |
| return topic_patterns + default_patterns[:max(0, 10 - len(topic_patterns))] | |
| # Roadmap Generator | |
| class RoadmapGenerator: | |
| """Generate visual roadmaps for startup milestones and timelines""" | |
| def __init__(self, rag_system: RAGSystem): | |
| self.rag = rag_system | |
| self.roadmap_templates = self._load_roadmap_templates() | |
| def _load_roadmap_templates(self) -> Dict[str, List[Dict]]: | |
| """Load roadmap templates for different startup phases""" | |
| return { | |
| 'pre_launch': [ | |
| { | |
| 'phase': 'Ideation & Validation', | |
| 'duration': '1-2 months', | |
| 'milestones': [ | |
| 'Problem identification and customer interviews', | |
| 'Market research and competitive analysis', | |
| 'Initial MVP wireframes and user testing', | |
| 'Business model validation and pricing research' | |
| ] | |
| }, | |
| { | |
| 'phase': 'Business Planning', | |
| 'duration': '2-3 months', | |
| 'milestones': [ | |
| 'Comprehensive business plan development', | |
| 'Financial projections and funding strategy', | |
| 'Legal structure setup and IP protection', | |
| 'Founding team assembly and equity agreements' | |
| ] | |
| }, | |
| { | |
| 'phase': 'MVP Development', | |
| 'duration': '3-6 months', | |
| 'milestones': [ | |
| 'Technical architecture and tech stack selection', | |
| 'Core feature development and testing', | |
| 'User feedback integration and product iteration', | |
| 'Beta user recruitment and onboarding' | |
| ] | |
| } | |
| ], | |
| 'launch': [ | |
| { | |
| 'phase': 'Go-to-Market Preparation', | |
| 'duration': '1-2 months', | |
| 'milestones': [ | |
| 'Brand identity and marketing website development', | |
| 'Content marketing strategy and asset creation', | |
| 'Sales process design and CRM implementation', | |
| 'Launch campaign planning and PR strategy' | |
| ] | |
| }, | |
| { | |
| 'phase': 'Soft Launch', | |
| 'duration': '2-3 months', | |
| 'milestones': [ | |
| 'Limited beta release to select customers', | |
| 'Customer feedback collection and analysis', | |
| 'Product refinement and bug fixes', | |
| 'Initial traction metrics and KPI tracking' | |
| ] | |
| }, | |
| { | |
| 'phase': 'Full Market Launch', | |
| 'duration': '3-6 months', | |
| 'milestones': [ | |
| 'Public launch and press release distribution', | |
| 'Customer acquisition campaign execution', | |
| 'Revenue generation and growth tracking', | |
| 'Team expansion and operational scaling' | |
| ] | |
| } | |
| ], | |
| 'growth': [ | |
| { | |
| 'phase': 'Product-Market Fit', | |
| 'duration': '6-12 months', | |
| 'milestones': [ | |
| 'Strong retention and engagement metrics', | |
| 'Sustainable customer acquisition channels', | |
| 'Positive unit economics and profitability path', | |
| 'Product expansion and feature development' | |
| ] | |
| }, | |
| { | |
| 'phase': 'Scale & Expansion', | |
| 'duration': '12-24 months', | |
| 'milestones': [ | |
| 'Series A fundraising and investor relations', | |
| 'Market expansion and new customer segments', | |
| 'Team scaling and organizational development', | |
| 'Strategic partnerships and business development' | |
| ] | |
| } | |
| ] | |
| } | |
| def generate_roadmap(self, startup_idea: StartupIdea, phases: List[str] = None) -> Dict[str, Any]: | |
| """Generate customized roadmap based on startup idea""" | |
| try: | |
| print(f"🗺️ Generating roadmap for {startup_idea.name}...") | |
| if phases is None: | |
| phases = ['pre_launch', 'launch', 'growth'] | |
| # Get industry-specific context | |
| context = self.rag.retrieve_context( | |
| f"startup roadmap {startup_idea.industry} milestones timeline", | |
| n_results=3 | |
| ) | |
| roadmap = { | |
| 'startup_name': startup_idea.name, | |
| 'industry': startup_idea.industry, | |
| 'phases': [], | |
| 'total_timeline': '18-36 months', | |
| 'key_metrics': self._get_key_metrics(startup_idea), | |
| 'context_insights': [ctx['content'][:200] + '...' for ctx in context[:2]] | |
| } | |
| current_month = 0 | |
| for phase_name in phases: | |
| if phase_name in self.roadmap_templates: | |
| phase_data = self.roadmap_templates[phase_name].copy() | |
| # Customize based on industry | |
| customized_phases = self._customize_phases(phase_data, startup_idea, context) | |
| for phase in customized_phases: | |
| phase['start_month'] = current_month | |
| phase['end_month'] = current_month + self._parse_duration(phase['duration']) | |
| current_month = phase['end_month'] | |
| roadmap['phases'].append(phase) | |
| print("✅ Roadmap generated successfully") | |
| return roadmap | |
| except Exception as e: | |
| print(f"❌ Error generating roadmap: {e}") | |
| return self._generate_fallback_roadmap(startup_idea) | |
| def _customize_phases(self, phases: List[Dict], idea: StartupIdea, context: List[Dict]) -> List[Dict]: | |
| """Customize roadmap phases based on startup specifics""" | |
| customized = [] | |
| for phase in phases: | |
| customized_phase = phase.copy() | |
| # Add industry-specific considerations | |
| if idea.industry.lower() in ['saas', 'software', 'tech']: | |
| if 'MVP Development' in phase['phase']: | |
| customized_phase['milestones'].extend([ | |
| 'Cloud infrastructure and security implementation', | |
| 'API development and third-party integrations', | |
| 'Analytics and monitoring setup' | |
| ]) | |
| elif idea.industry.lower() in ['ecommerce', 'retail']: | |
| if 'Go-to-Market' in phase['phase']: | |
| customized_phase['milestones'].extend([ | |
| 'Inventory management and fulfillment setup', | |
| 'Payment processing and fraud prevention', | |
| 'Customer service and returns process' | |
| ]) | |
| elif idea.industry.lower() in ['fintech', 'financial']: | |
| if 'MVP Development' in phase['phase']: | |
| customized_phase['milestones'].extend([ | |
| 'Regulatory compliance and security audits', | |
| 'KYC/AML implementation', | |
| 'Banking partnerships and API integrations' | |
| ]) | |
| customized.append(customized_phase) | |
| return customized | |
| def _parse_duration(self, duration_str: str) -> int: | |
| """Parse duration string to months""" | |
| match = re.search(r'(\d+)', duration_str) | |
| return int(match.group(1)) if match else 1 | |
| def _get_key_metrics(self, idea: StartupIdea) -> List[str]: | |
| """Get key metrics to track for the startup""" | |
| base_metrics = [ | |
| 'Customer Acquisition Cost (CAC)', | |
| 'Customer Lifetime Value (LTV)', | |
| 'Monthly Recurring Revenue (MRR)', | |
| 'User Engagement Rate', | |
| 'Market Share Growth' | |
| ] | |
| # Add industry-specific metrics | |
| if idea.industry.lower() in ['saas', 'software']: | |
| base_metrics.extend([ | |
| 'Monthly Active Users (MAU)', | |
| 'Churn Rate', | |
| 'Net Promoter Score (NPS)', | |
| 'Feature Adoption Rate' | |
| ]) | |
| elif idea.industry.lower() in ['ecommerce']: | |
| base_metrics.extend([ | |
| 'Conversion Rate', | |
| 'Average Order Value (AOV)', | |
| 'Cart Abandonment Rate', | |
| 'Return on Ad Spend (ROAS)' | |
| ]) | |
| return base_metrics[:8] # Limit to 8 key metrics | |
| def _generate_fallback_roadmap(self, idea: StartupIdea) -> Dict[str, Any]: | |
| """Generate basic roadmap if main generation fails""" | |
| return { | |
| 'startup_name': idea.name, | |
| 'industry': idea.industry, | |
| 'phases': [ | |
| { | |
| 'phase': 'Planning & Validation', | |
| 'duration': '1-2 months', | |
| 'milestones': ['Market research', 'Business plan', 'MVP design'], | |
| 'start_month': 0, | |
| 'end_month': 2 | |
| }, | |
| { | |
| 'phase': 'Development & Launch', | |
| 'duration': '3-6 months', | |
| 'milestones': ['Product development', 'Testing', 'Market launch'], | |
| 'start_month': 2, | |
| 'end_month': 8 | |
| } | |
| ], | |
| 'total_timeline': '6-12 months', | |
| 'key_metrics': ['Revenue', 'Customers', 'Growth Rate'] | |
| } | |
| def export_roadmap(self, roadmap_data: Dict[str, Any], format: str = 'markdown') -> str: | |
| """Export roadmap in markdown format""" | |
| if format == 'markdown': | |
| md_content = f"# 🗺️ Startup Roadmap: {roadmap_data['startup_name']}\n\n" | |
| md_content += f"**Industry:** {roadmap_data['industry']} \n" | |
| md_content += f"**Total Timeline:** {roadmap_data['total_timeline']}\n\n" | |
| for phase in roadmap_data['phases']: | |
| md_content += f"## {phase['phase']}\n" | |
| md_content += f"**Duration:** {phase['duration']} \n" | |
| md_content += f"**Timeline:** Months {phase['start_month']}-{phase['end_month']}\n\n" | |
| md_content += "**Key Milestones:**\n" | |
| for milestone in phase['milestones']: | |
| md_content += f"- {milestone}\n" | |
| md_content += "\n" | |
| # Add key metrics section | |
| if 'key_metrics' in roadmap_data: | |
| md_content += "## 📊 Key Metrics to Track\n" | |
| for metric in roadmap_data['key_metrics']: | |
| md_content += f"- {metric}\n" | |
| return md_content | |
| else: | |
| return json.dumps(roadmap_data, indent=2) | |
| # Initialize Global Systems | |
| print("🚀 Starting AI Startup Roadmap Generator...") | |
| # Initialize RAG system | |
| try: | |
| rag_system = RAGSystem() | |
| rag_system.initialize_collection() | |
| # Populate knowledge base if empty | |
| 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} knowledge chunks to database") | |
| else: | |
| print(f"📚 Using existing knowledge base with {rag_system.collection.count() if rag_system.collection else 0} documents") | |
| except Exception as e: | |
| print(f"❌ Error initializing RAG system: {e}") | |
| print("🔄 Creating fallback system...") | |
| rag_system = None | |
| # Initialize generators | |
| 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("✅ All generators initialized successfully") | |
| except Exception as e: | |
| print(f"❌ Error initializing generators: {e}") | |
| # Main Gradio Interface Functions | |
| def generate_startup_blueprint(name, industry, target_market, problem, solution, value_prop): | |
| """Main function for Gradio interface""" | |
| if not all([name, industry, problem, solution]): | |
| return ( | |
| "❌ **Error:** Please fill in all required fields (Name, Industry, Problem, Solution).", | |
| "", "", "" | |
| ) | |
| try: | |
| # Create startup idea object | |
| 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 with unique market approach" | |
| ) | |
| print(f"🚀 Processing blueprint request for {name}") | |
| # Generate business plan | |
| if blueprint_generator: | |
| business_plan = blueprint_generator.generate_business_plan(idea) | |
| business_plan_text = business_plan.executive_summary | |
| else: | |
| business_plan_text = f"**Business Plan for {name}**\n\nExecutive Summary: {name} addresses {problem} in the {industry} market through {solution}." | |
| # Generate flashcards | |
| 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 = f"**Learning Materials for {industry}**\n\n**Q:** What is product-market fit?\n**A:** The degree to which a product satisfies strong market demand." | |
| # Generate roadmap | |
| 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 (Months 1-2)\n- Market research\n- Business plan development\n\n## Phase 2: Development (Months 3-6)\n- MVP development\n- User testing" | |
| # Create summary | |
| summary = f""" | |
| # 🚀 Startup Blueprint Generated Successfully! | |
| **Startup Name:** {name} | |
| **Industry:** {industry} | |
| **Target Market:** {target_market or f"{industry} customers"} | |
| ## 📊 Quick Assessment Score: 85/100 | |
| ### ✅ Strengths Identified: | |
| - Clear problem identification and market focus | |
| - Well-defined solution approach | |
| - Strong industry positioning | |
| - Comprehensive value proposition | |
| ### 💡 Recommendations for Success: | |
| 1. **Validate Early:** Conduct 50+ customer interviews to validate assumptions | |
| 2. **Build MVP:** Start with core features and iterate based on user feedback | |
| 3. **Track Metrics:** Focus on Customer Acquisition Cost (CAC) and Lifetime Value (LTV) | |
| 4. **Secure Funding:** Prepare for $250K-$1M seed round based on traction | |
| ### 🎯 Next Steps: | |
| - Review the detailed business plan below | |
| - Study the learning flashcards for key concepts | |
| - Follow the startup roadmap timeline | |
| - Begin customer validation interviews | |
| *Generated on {datetime.now().strftime("%B %d, %Y at %I:%M %p")}* | |
| """ | |
| print(f"✅ Blueprint generated successfully for {name}") | |
| return summary, business_plan_text, flashcards_text, roadmap_text | |
| except Exception as e: | |
| error_msg = f"❌ **Error generating blueprint:** {str(e)}\n\nPlease try again or contact support if the issue persists." | |
| print(f"❌ Error in generate_startup_blueprint: {e}") | |
| return error_msg, "", "", "" | |
| def generate_flashcards_only(category): | |
| """Generate flashcards for specific category""" | |
| 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"**Sample {category} Flashcards:**\n\n**Q:** What is customer validation?\n**A:** The process of testing your business idea with real potential customers to ensure market demand exists." | |
| except Exception as e: | |
| return f"❌ Error generating flashcards: {str(e)}" | |
| def generate_roadmap_only(startup_name, industry_type): | |
| """Generate roadmap for specific startup""" | |
| try: | |
| idea = StartupIdea( | |
| name=startup_name or "Sample Startup", | |
| description="Sample description", | |
| industry=industry_type, | |
| target_market="General market", | |
| problem_statement="Market problem to solve", | |
| solution="Innovative solution approach", | |
| unique_value_proposition="Unique market positioning" | |
| ) | |
| if roadmap_gen: | |
| roadmap = roadmap_gen.generate_roadmap(idea) | |
| return roadmap_gen.export_roadmap(roadmap, 'markdown') | |
| else: | |
| return f"# Roadmap for {startup_name or 'Your Startup'}\n\n## Phase 1: Foundation\n- Market research and validation\n- Business plan development\n- Team formation\n\n## Phase 2: Development\n- MVP creation\n- User testing\n- Product refinement" | |
| except Exception as e: | |
| return f"❌ Error generating roadmap: {str(e)}" | |
| # Create Gradio Interface | |
| print("🎨 Creating Gradio interface...") | |
| # Custom CSS for better styling | |
| custom_css = """ | |
| .gradio-container { | |
| max-width: 1200px !important; | |
| } | |
| .main-header { | |
| text-align: center; | |
| background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); | |
| -webkit-background-clip: text; | |
| -webkit-text-fill-color: transparent; | |
| background-clip: text; | |
| font-size: 2.5em; | |
| font-weight: bold; | |
| margin-bottom: 0.5em; | |
| } | |
| .feature-box { | |
| border: 1px solid #e1e5e9; | |
| border-radius: 8px; | |
| padding: 1rem; | |
| margin: 0.5rem 0; | |
| background: #f8f9fa; | |
| } | |
| """ | |
| with gr.Blocks( | |
| title="🚀 AI Startup Roadmap Generator", | |
| theme=gr.themes.Soft(), | |
| css=custom_css | |
| ) as demo: | |
| # Header | |
| gr.Markdown( | |
| """ | |
| <div class="main-header">🚀 AI Startup Roadmap Generator</div> | |
| ### Transform Your Startup Ideas into Comprehensive Business Plans | |
| **Powered by RAG Technology & ChromaDB** | Generate complete startup blueprints including business plans, learning materials, and roadmaps in minutes. | |
| <div class="feature-box"> | |
| 🎯 <strong>Features:</strong> Business Plan Generation • Market Analysis • Learning Flashcards • Startup Roadmaps • RAG-Enhanced Insights | |
| </div> | |
| """, | |
| elem_classes="main-header" | |
| ) | |
| with gr.Tabs(): | |
| # Main Blueprint Generator Tab | |
| with gr.TabItem("🏢 Complete Blueprint Generator", id="main"): | |
| gr.Markdown("### 📝 Enter Your Startup Information") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("#### Basic Information") | |
| startup_name = gr.Textbox( | |
| label="Startup Name *", | |
| placeholder="e.g., EcoTrack, HealthBridge, SmartLearn", | |
| info="Choose a memorable and descriptive name" | |
| ) | |
| industry = gr.Dropdown( | |
| choices=[ | |
| "SaaS", "E-commerce", "FinTech", "HealthTech", "EdTech", | |
| "FoodTech", "PropTech", "CleanTech", "AI/ML", "Other" | |
| ], | |
| label="Industry *", | |
| value="SaaS", | |
| info="Select the primary industry for your startup" | |
| ) | |
| target_market = gr.Textbox( | |
| label="Target Market", | |
| placeholder="e.g., Small businesses, Healthcare professionals, Students", | |
| lines=2, | |
| info="Describe your ideal customers and their characteristics" | |
| ) | |
| with gr.Column(scale=1): | |
| gr.Markdown("#### Problem & Solution") | |
| problem_statement = gr.Textbox( | |
| label="Problem Statement *", | |
| placeholder="What specific problem does your startup solve? Be detailed about pain points.", | |
| lines=3, | |
| info="Clear problem definition is crucial for startup success" | |
| ) | |
| solution = gr.Textbox( | |
| label="Solution *", | |
| placeholder="How does your product/service solve the problem? What makes it unique?", | |
| lines=3, | |
| info="Describe your solution approach and key features" | |
| ) | |
| value_proposition = gr.Textbox( | |
| label="Unique Value Proposition", | |
| placeholder="What makes your solution different from existing alternatives?", | |
| lines=2, | |
| info="Your competitive advantage and differentiation" | |
| ) | |
| with gr.Row(): | |
| generate_btn = gr.Button( | |
| "🚀 Generate Complete Startup Blueprint", | |
| variant="primary", | |
| size="lg", | |
| scale=2 | |
| ) | |
| gr.Markdown("*Processing typically takes 10-30 seconds*", scale=1) | |
| gr.Markdown("---") | |
| gr.Markdown("### 📊 Your Generated Startup Blueprint") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| summary_output = gr.Markdown( | |
| label="Executive Summary & Assessment", | |
| value="*Your startup summary will appear here after generation...*" | |
| ) | |
| with gr.Column(scale=1): | |
| business_plan_output = gr.Markdown( | |
| label="Business Plan Details", | |
| value="*Detailed business plan will appear here...*" | |
| ) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| flashcards_output = gr.Markdown( | |
| label="📚 Learning Flashcards", | |
| value="*Industry-specific learning materials will appear here...*" | |
| ) | |
| with gr.Column(scale=1): | |
| roadmap_output = gr.Markdown( | |
| label="🗺️ Startup Roadmap", | |
| value="*Your startup timeline and milestones will appear here...*" | |
| ) | |
| # Connect the generate button | |
| 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] | |
| ) | |
| # Flashcards Only Tab | |
| with gr.TabItem("📚 Learning Flashcards", id="flashcards"): | |
| gr.Markdown("### 📚 Generate Industry-Specific Learning Materials") | |
| gr.Markdown("Master startup concepts with AI-generated flashcards tailored to your industry.") | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| flashcard_category = gr.Dropdown( | |
| choices=[ | |
| 'Market Research', 'Business Planning', 'Financial Management', | |
| 'Legal Setup', 'Team Building', 'Marketing', 'SaaS', 'E-commerce', | |
| 'FinTech', 'HealthTech', 'EdTech' | |
| ], | |
| label="Learning Category", | |
| value="Market Research", | |
| info="Choose a topic to generate relevant flashcards" | |
| ) | |
| with gr.Column(scale=1): | |
| flashcard_btn = gr.Button("📚 Generate Flashcards", variant="primary") | |
| flashcard_only_output = gr.Markdown( | |
| value="*Select a category and click 'Generate Flashcards' to see learning materials...*" | |
| ) | |
| flashcard_btn.click( | |
| fn=generate_flashcards_only, | |
| inputs=[flashcard_category], | |
| outputs=[flashcard_only_output] | |
| ) | |
| # Roadmap Only Tab | |
| with gr.TabItem("🗺️ Startup Roadmap", id="roadmap"): | |
| gr.Markdown("### 🗺️ Generate Detailed Startup Roadmap") | |
| gr.Markdown("Create a comprehensive timeline with milestones tailored to your industry and startup type.") | |
| with gr.Row(): | |
| roadmap_startup_name = gr.Textbox( | |
| label="Startup Name", | |
| value="My Startup", | |
| info="Enter your startup name for personalization" | |
| ) | |
| roadmap_industry = gr.Dropdown( | |
| choices=["SaaS", "E-commerce", "FinTech", "HealthTech", "EdTech", "AI/ML"], | |
| label="Industry", | |
| value="SaaS", | |
| info="Select industry for customized milestones" | |
| ) | |
| roadmap_btn = gr.Button("🗺️ Generate Roadmap", variant="primary") | |
| roadmap_only_output = gr.Markdown( | |
| value="*Enter your startup details and click 'Generate Roadmap' to see your timeline...*" | |
| ) | |
| roadmap_btn.click( | |
| fn=generate_roadmap_only, | |
| inputs=[roadmap_startup_name, roadmap_industry], | |
| outputs=[roadmap_only_output] | |
| ) | |
| # Footer | |
| gr.Markdown( | |
| """ | |
| --- | |
| ### 💡 About This Tool | |
| This AI-powered startup blueprint generator uses **Retrieval-Augmented Generation (RAG)** technology with a curated knowledge base of startup best practices, industry insights, and proven frameworks. | |
| **🎯 Perfect for:** | |
| - First-time entrepreneurs planning their startup | |
| - Business students working on startup projects | |
| - Accelerator participants developing business plans | |
| - Anyone validating and structuring startup ideas | |
| **🔧 Technology Stack:** Gradio + ChromaDB + Sentence Transformers + LangChain | |
| **📚 Knowledge Base:** Covers market research, business planning, funding, legal setup, team building, and marketing strategies. | |
| --- | |
| <div style="text-align: center; color: #666;"> | |
| <strong>Disclaimer:</strong> This tool provides educational guidance based on startup best practices. | |
| Always consult with professionals for legal, financial, and strategic advice specific to your situation. | |
| </div> | |
| """ | |
| ) | |
| # Launch configuration | |
| if __name__ == "__main__": | |
| # Get port from environment (for deployment platforms) | |
| port = int(os.getenv("PORT", 7860)) | |
| print(f""" | |
| 🎉 AI Startup Roadmap Generator Ready! | |
| 🌐 Starting server on port {port} | |
| 📊 RAG system: {"✅ Active" if rag_system else "❌ Fallback mode"} | |
| 📚 Knowledge base: {"✅ Loaded" if rag_system and rag_system.collection else "❌ Empty"} | |
| 🚀 Launching application... | |
| """) | |
| # Launch the app | |
| demo.launch( | |
| server_name="0.0.0.0", # Allow external access | |
| server_port=port, | |
| share=False, # Set to True for temporary public links | |
| show_error=True, | |
| show_tips=True, | |
| enable_queue=True # Handle multiple users | |
| ) |