push final

.dockerignore

@@ -0,0 +1,34 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.git
+.gitignore
+.vscode
+.idea
+*.swp
+*.swo
+*~
+.DS_Store
+.env
+.venv
+venv/
+env/
+*.log
+.pytest_cache
+.coverage
+htmlcov/
+*.md
+!README.md
+models/
+*.pdf
+*.docx
+*.pptx
+*.ppt
+

Dockerfile

@@ -0,0 +1,49 @@
+# Base Image
+FROM python:3.10-slim
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /code
+
+# System Dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    curl \
+    libopenblas-dev \
+    libomp-dev \
+    ffmpeg \
+    poppler-utils \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Hugging Face + model tools
+RUN pip install --no-cache-dir huggingface-hub sentencepiece accelerate
+
+# Hugging Face cache environment
+ENV HF_HOME=/models/huggingface \
+    TRANSFORMERS_CACHE=/models/huggingface \
+    HUGGINGFACE_HUB_CACHE=/models/huggingface \
+    HF_HUB_CACHE=/models/huggingface
+
+# Create cache dir and set permissions
+RUN mkdir -p /models/huggingface && chmod -R 777 /models/huggingface
+
+# Models will be downloaded at runtime (Zephyr is public, no token needed)
+
+# Copy project files
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+

app.py

@@ -0,0 +1,488 @@
+import torch
+import json
+import os
+import tempfile
+import io
+from pathlib import Path
+from typing import Optional, Tuple
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from pdfminer.high_level import extract_text as extract_pdf_text
+from docx import Document as DocxDocument
+from pptx import Presentation
+import logging
+from PIL import Image
+import pytesseract
+from pdf2image import convert_from_path
+import easyocr
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Deckgpt",
+    description="Upload your startup pitch deck (PDF, PPT, DOCX) and get an investor-style review",
+    version="1.0.0"
+)
+
+MODEL_ID = "HuggingFaceH4/zephyr-7b-beta"
+tokenizer = None
+model = None
+ocr_reader = None
+
+@app.on_event("startup")
+async def load_model():
+    """Load the model, tokenizer, and OCR reader on startup"""
+    global tokenizer, model, ocr_reader
+    try:
+        logger.info(f"Loading model: {MODEL_ID} ...")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_ID,
+            torch_dtype=torch.bfloat16,
+            device_map="auto"
+        )
+        logger.info("✅ Model loaded successfully!")
+        
+        logger.info("Loading OCR reader...")
+        try:
+            ocr_reader = easyocr.Reader(['en'], gpu=torch.cuda.is_available())
+            logger.info("✅ OCR reader loaded successfully!")
+        except Exception as e:
+            logger.warning(f"⚠️ EasyOCR failed to load, will use pytesseract fallback: {e}")
+            ocr_reader = None
+    except Exception as e:
+        logger.error(f"❌ Failed to load model: {e}")
+        raise
+
+
+def extract_text_with_ocr(image_path_or_image, use_easyocr: bool = True) -> str:
+    """Extract text from image using OCR"""
+    try:
+        if use_easyocr and ocr_reader is not None:
+            if isinstance(image_path_or_image, str):
+                result = ocr_reader.readtext(image_path_or_image)
+            else:
+                result = ocr_reader.readtext(image_path_or_image)
+            text_parts = [detection[1] for detection in result if detection[2] > 0.5]
+            return "\n".join(text_parts)
+        else:
+            if isinstance(image_path_or_image, str):
+                img = Image.open(image_path_or_image)
+            else:
+                img = image_path_or_image
+            text = pytesseract.image_to_string(img, lang='eng')
+            return text
+    except Exception as e:
+        logger.warning(f"OCR extraction failed: {e}")
+        return ""
+
+def extract_text_from_pdf(file_path: str, use_ocr: bool = True) -> str:
+    """Extract text from PDF file with OCR fallback"""
+    text_parts = []
+    
+    try:
+        text = extract_pdf_text(file_path)
+        if text and text.strip():
+            text_parts.append(text.strip())
+    except Exception as e:
+        logger.warning(f"PDF text extraction failed: {e}")
+    
+    if use_ocr:
+        try:
+            images = convert_from_path(file_path, dpi=300, first_page=1, last_page=50)
+            logger.info(f"Processing {len(images)} pages with OCR...")
+            
+            for i, img in enumerate(images):
+                ocr_text = extract_text_with_ocr(img, use_easyocr=True)
+                if ocr_text.strip():
+                    text_parts.append(f"\n--- Page {i+1} (OCR) ---\n{ocr_text}")
+        except Exception as e:
+            logger.warning(f"OCR processing failed: {e}")
+    
+    combined_text = "\n\n".join(text_parts)
+    if not combined_text or not combined_text.strip():
+        raise ValueError("No readable text found in PDF (tried both text extraction and OCR)")
+    return combined_text
+
+def extract_text_from_docx(file_path: str) -> str:
+    """Extract text from DOCX file"""
+    try:
+        doc = DocxDocument(file_path)
+        text_parts = []
+        for paragraph in doc.paragraphs:
+            if paragraph.text.strip():
+                text_parts.append(paragraph.text.strip())
+        
+        for table in doc.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    if cell.text.strip():
+                        text_parts.append(cell.text.strip())
+        
+        text = "\n".join(text_parts)
+        if not text or not text.strip():
+            raise ValueError("No readable text found in DOCX")
+        return text
+    except Exception as e:
+        raise ValueError(f"Error extracting text from DOCX: {str(e)}")
+
+def extract_text_from_ppt(file_path: str, use_ocr: bool = True) -> str:
+    """Extract text from PowerPoint file with OCR for images"""
+    text_parts = []
+    
+    try:
+        prs = Presentation(file_path)
+        
+        for slide_num, slide in enumerate(prs.slides, 1):
+            slide_text = []
+            
+            for shape in slide.shapes:
+                if hasattr(shape, "text") and shape.text.strip():
+                    slide_text.append(shape.text.strip())
+                elif hasattr(shape, "table"):
+                    for row in shape.table.rows:
+                        row_text = []
+                        for cell in row.cells:
+                            if cell.text.strip():
+                                row_text.append(cell.text.strip())
+                        if row_text:
+                            slide_text.append(" | ".join(row_text))
+                elif use_ocr and hasattr(shape, "image"):
+                    try:
+                        image = shape.image
+                        image_bytes = image.blob
+                        img = Image.open(io.BytesIO(image_bytes))
+                        ocr_text = extract_text_with_ocr(img, use_easyocr=True)
+                        if ocr_text.strip():
+                            slide_text.append(f"[Image OCR]: {ocr_text.strip()}")
+                    except Exception as e:
+                        logger.debug(f"OCR on slide {slide_num} image failed: {e}")
+            
+            if slide_text:
+                text_parts.append(f"Slide {slide_num}:\n" + "\n".join(slide_text))
+        
+        text = "\n\n".join(text_parts)
+        if not text or not text.strip():
+            raise ValueError("No readable text found in PPT")
+        return text
+    except Exception as e:
+        raise ValueError(f"Error extracting text from PPT: {str(e)}")
+
+def extract_text_from_file(file_path: str, file_extension: str) -> str:
+    """
+    Main extraction function that routes to appropriate extractor based on file type
+    """
+    extension = file_extension.lower()
+    
+    if extension == ".pdf":
+        return extract_text_from_pdf(file_path)
+    elif extension in [".docx", ".doc"]:
+        return extract_text_from_docx(file_path)
+    elif extension in [".pptx", ".ppt"]:
+        return extract_text_from_ppt(file_path)
+    else:
+        raise ValueError(f"Unsupported file type: {extension}. Supported: PDF, DOCX, PPT/PPTX")
+
+def review_pitchdeck(text: str) -> dict:
+    """
+    Send text to Zephyr model for VC-level review and return structured JSON
+    """
+    if not text or not text.strip():
+        raise ValueError("No text content provided for review")
+    
+    deck_text = text[:12000]
+    
+    prompt = f"""You are a senior venture capitalist with 15+ years of experience evaluating thousands of pitch decks. You know the patterns that lead to funding vs. ghosting. Based on extensive research analyzing hundreds of decks, these are the critical failure points:
+
+1. Beautiful decks missing commercial backbone (GTM, financials, market sizing, clear ask)
+2. Giant market claims without credibility - claiming $50B TAM instead of sharp, addressable market
+3. Mission over mechanics - purpose without profitable model
+4. No Go-To-Market strategy - "we'll figure it out" isn't a plan
+5. Traction theatre - vanity metrics instead of real growth (show % growth WOW, paid users, conversion rates)
+6. Team slide buried or weak - investors back founders at pre-seed, put team early
+7. Missing moat - can't explain defensibility in one clear line
+8. Unclear ask - vague "seeking partners" instead of specific: "Raising £400k to reach 10k users, £350k ARR"
+9. Overstuffed or underexplained - should be 12-14 slides, 1 key message per slide
+10. No financial logic - even pre-seed needs 3-year revenue/burn/milestone map
+
+THE 5 CRITICAL QUESTIONS every deck must answer clearly:
+1. What problem are you solving?
+2. Who's paying?
+3. How do you reach them?
+4. Why you?
+5. What do you need?
+
+Deck Content:
+{deck_text}
+
+TASK:
+Evaluate this deck against these real-world failure patterns. Check specifically for: commercial backbone, credible market sizing, GTM clarity, real traction metrics, team positioning, moat definition, specific ask, slide count/clarity, and financial logic.
+
+Produce ONLY valid JSON with these exact fields:
+
+{{
+  "verdict": "Invest" | "Follow-up" | "Pass",
+  "score": 0-100,
+  "grade": "A+" | "A" | "A-" | "B+" | "B" | "B-" | "C+" | "C" | "C-" | "D" | "F",
+  "top_line": "1-2 sentence executive summary from VC perspective",
+  "investment_readiness": "Ready" | "Near-ready" | "Needs-work" | "Not-ready",
+  "critical_questions_check": {{
+    "what_problem": "clear" | "unclear" | "missing",
+    "who_paying": "clear" | "unclear" | "missing",
+    "how_reach_them": "clear" | "unclear" | "missing",
+    "why_you": "clear" | "unclear" | "missing",
+    "what_need": "clear" | "unclear" | "missing"
+  }},
+  "common_failures": [
+    "failure pattern 1 (from top 10 list)",
+    "failure pattern 2"
+  ],
+  "deal_breakers": ["critical issue 1", "critical issue 2", ...],
+  "high_potential_signals": ["positive signal 1", "positive signal 2", ...],
+  "priority_questions": ["question 1", "question 2", "question 3"],
+  "scores": {{
+    "storyline_clarity": 0-100,
+    "problem_solution": 0-100,
+    "market_opportunity": 0-100,
+    "market_credibility": 0-100,
+    "go_to_market": 0-100,
+    "traction_quality": 0-100,
+    "business_model": 0-100,
+    "team": 0-100,
+    "moat_defensibility": 0-100,
+    "financials_ask": 0-100,
+    "ask_specificity": 0-100,
+    "design_communication": 0-100
+  }},
+  "slide_reviews": [
+    {{
+      "slide_no": 1,
+      "title": "slide title",
+      "investor_comment": "VC-style critique",
+      "severity": "critical" | "major" | "minor" | "good",
+      "rewrite_suggestion": "specific improvement recommendation"
+    }}
+  ],
+  "vc_insights": {{
+    "commercial_backbone": "assessment of GTM, financials, ask clarity",
+    "market_credibility": "assessment of market sizing realism",
+    "gtm_clarity": "assessment of distribution strategy",
+    "traction_reality": "assessment of metrics authenticity vs. vanity",
+    "investment_thesis": "why invest or pass"
+  }},
+  "slide_count": number,
+  "slide_count_assessment": "optimal (12-14)" | "too_many" | "too_few"
+}}
+
+Be brutally honest. Commercial clarity keeps doors open - GTM and financials get you funded. Emotion opens the door, but logic closes the deal.
+"""
+
+    try:
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=8192).to(model.device)
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=2000,
+            temperature=0.3,
+            do_sample=True,
+            top_p=0.9,
+            pad_token_id=tokenizer.eos_token_id
+        )
+        raw_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        start = raw_output.find('{')
+        end = raw_output.rfind('}') + 1
+        
+        if start == -1 or end == 0:
+            raise ValueError("No JSON object found in model output")
+        
+        parsed_json = json.loads(raw_output[start:end])
+        return parsed_json
+        
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON parsing error: {e}")
+        raise ValueError(f"Failed to parse JSON from model output: {str(e)}")
+    except Exception as e:
+        logger.error(f"Model generation error: {e}")
+        raise ValueError(f"Error during model inference: {str(e)}")
+
+def generate_improvement_pointers(review: dict) -> dict:
+    """Generate specific improvement pointers for decks below 80% or lacking clarity"""
+    score = review.get("score", 0)
+    storyline_clarity = review.get("scores", {}).get("storyline_clarity", 0)
+    
+    needs_improvement = score < 80 or storyline_clarity < 70
+    
+    if not needs_improvement:
+        return {
+            "needs_improvement": False,
+            "improvement_pointers": []
+        }
+    
+    improvement_prompt = f"""You are a pitch deck consultant with expertise from reviewing hundreds of founder decks. Based on this VC review, provide actionable, specific improvement pointers grounded in real-world failure patterns.
+
+VC Review:
+{json.dumps(review, indent=2)}
+
+Focus on fixing the TOP 10 COMMON FAILURES:
+1. Add commercial backbone: GTM plan, financials, market sizing, clear ask
+2. Fix market credibility: replace giant TAM claims with sharp, addressable market
+3. Add commercial mechanics: show how purpose becomes profit
+4. Create GTM strategy: Channels → Cost → Conversion → Timeline (one slide is enough)
+5. Replace traction theatre: show real metrics (% growth WOW, paid users, conversion rates, pilot outcomes)
+6. Reposition team: move team slide early (after problem/product), anchor with "lived the problem"
+7. Define moat: one clear line explaining defensibility
+8. Make ask specific: "Raising £X to achieve Y milestone, Z revenue" (not vague "seeking partners")
+9. Optimize slide count: 12-14 slides, 1 key message per slide
+10. Add financial logic: 3-year revenue/burn/milestone outline
+
+Generate 5-10 prioritized improvement pointers addressing the specific failures identified. Focus on:
+- Highest impact changes that will move the needle on score and commercial clarity
+- Specific, actionable recommendations (not vague advice)
+- What to fix first, second, third
+- Slide-by-slide improvements where critical issues were identified
+- How to address deal breakers and common failure patterns
+- Quick wins vs. strategic changes
+
+Return ONLY valid JSON:
+{{
+  "improvement_pointers": [
+    {{
+      "priority": 1,
+      "category": "category name (e.g., GTM, Market Credibility, Traction, etc.)",
+      "failure_pattern": "which of the top 10 failures this addresses",
+      "issue": "specific problem from deck",
+      "recommendation": "actionable fix with example",
+      "expected_impact": "how this moves the needle"
+    }}
+  ],
+  "quick_wins": ["quick fix 1", "quick fix 2"],
+  "strategic_changes": ["strategic change 1", "strategic change 2"],
+  "critical_fixes": ["must-fix issue 1", "must-fix issue 2"]
+}}
+"""
+
+    try:
+        inputs = tokenizer(improvement_prompt, return_tensors="pt", truncation=True, max_length=8192).to(model.device)
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=1500,
+            temperature=0.4,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+        raw_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        start = raw_output.find('{')
+        end = raw_output.rfind('}') + 1
+        
+        if start == -1 or end == 0:
+            return {
+                "needs_improvement": True,
+                "improvement_pointers": [{"priority": 1, "category": "General", "recommendation": "Focus on improving storyline clarity and addressing identified deal breakers"}]
+            }
+        
+        improvement_json = json.loads(raw_output[start:end])
+        improvement_json["needs_improvement"] = True
+        return improvement_json
+        
+    except Exception as e:
+        logger.warning(f"Improvement pointers generation failed: {e}")
+        return {
+            "needs_improvement": True,
+            "improvement_pointers": [{"priority": 1, "category": "General", "recommendation": "Review and address all deal breakers and low-scoring areas identified in the review"}]
+        }
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "message": "Deckgpt API",
+        "model": MODEL_ID,
+        "supported_formats": ["PDF", "DOCX", "PPT", "PPTX"]
+    }
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None and tokenizer is not None
+    }
+
+@app.post("/review")
+async def review_deck(file: UploadFile = File(...)):
+    """
+    Upload a pitch deck file and get an investor-style review.
+    
+    Supported formats: PDF, DOCX, PPT, PPTX
+    """
+    if model is None or tokenizer is None:
+        raise HTTPException(status_code=503, detail="Model not loaded yet. Please wait for startup to complete.")
+    
+    file_extension = Path(file.filename).suffix.lower()
+    supported_extensions = [".pdf", ".docx", ".doc", ".ppt", ".pptx"]
+    
+    if file_extension not in supported_extensions:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported file type: {file_extension}. Supported: {', '.join(supported_extensions)}"
+        )
+    
+    temp_file = None
+    try:
+        suffix = file_extension
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            temp_path = temp_file.name
+            
+            content = await file.read()
+            if not content:
+                raise HTTPException(status_code=400, detail="Uploaded file is empty")
+            
+            temp_file.write(content)
+            temp_file.flush()
+        
+        try:
+            logger.info(f"Extracting text from {file.filename} ({file_extension})")
+            deck_text = extract_text_from_file(temp_path, file_extension)
+            logger.info(f"Extracted {len(deck_text)} characters from file")
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            logger.error(f"File extraction error: {e}")
+            raise HTTPException(status_code=500, detail=f"Error processing file: {str(e)}")
+        
+        try:
+            logger.info("Generating VC-level review...")
+            review_result = review_pitchdeck(deck_text)
+            logger.info("Review generated successfully")
+            
+            logger.info("Checking if improvement pointers are needed...")
+            improvement_pointers = generate_improvement_pointers(review_result)
+            review_result["improvement_analysis"] = improvement_pointers
+            
+            return JSONResponse(content=review_result)
+        except ValueError as e:
+            raise HTTPException(status_code=500, detail=str(e))
+        except Exception as e:
+            logger.error(f"Review generation error: {e}")
+            raise HTTPException(status_code=500, detail=f"Error generating review: {str(e)}")
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+    
+    finally:
+        if temp_file and os.path.exists(temp_path):
+            try:
+                os.unlink(temp_path)
+            except Exception as e:
+                logger.warning(f"Failed to delete temp file {temp_path}: {e}")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,13 @@
+torch
+transformers
+fastapi
+uvicorn[standard]
+python-multipart
+pdfminer.six
+python-docx
+python-pptx
+pillow
+pytesseract
+pdf2image
+easyocr
+