fix: make OCR work always and consistently

backend/api/server.py

@@ -116,15 +116,17 @@ async def _auto_summarize_minutes(minutes: Minutes) -> Optional[SummaryResponse]
     try:
         print(f"[AUTO] Summarizing minutes {minutes.id}...")
 
-        # If the document has page image URLs, provide an image fetcher
+        # If the document has page image URLs (strings), provide an image fetcher
         # for OCR-based summarization (even if raw_text is a stub like
         # "[This document is a scanned image...]")
         image_fetcher = None
-        if (
+        has_urls = (
             minutes.page_image_urls
+            and isinstance(minutes.page_image_urls[0], str)
             and connector
             and minutes.document_url
-        ):
+        )
+        if has_urls:
             # Capture page_urls in a closure so the fallback in
             # fetch_page_images() can use them if PDF generation fails
             _page_urls = list(minutes.page_image_urls)
@@ -224,16 +226,23 @@ app.add_middleware(
 async def health():
     """Health check endpoint."""
     ocr_available = False
+    ocr_engines = []
     if summarizer:
-        ocr_available = (
-            summarizer._pytesseract_available
-            and summarizer._pillow_available
-        )
+        if summarizer._easyocr_available:
+            ocr_engines.append("easyocr")
+        if summarizer._pytesseract_available:
+            ocr_engines.append("tesseract")
+        if summarizer._pillow_available:
+            ocr_engines.append("pillow")
+        if summarizer._numpy_available:
+            ocr_engines.append("numpy")
+        ocr_available = bool(ocr_engines)
     return {
         "status": "ok",
         "city": f"{PARIS_TX_CONFIG.name}, {PARIS_TX_CONFIG.state}",
         "llm_available": summarizer is not None,
         "ocr_available": ocr_available,
+        "ocr_engines": ocr_engines,
         "storage": "postgresql" if USE_POSTGRES else "sqlite",
     }
 
@@ -425,11 +434,13 @@ async def summarize_minutes_endpoint(request: SummaryRequest):
         # Provide image fetcher for OCR-based summarization
         # (even if raw_text is a stub like "[This document is a scanned image...]")
         image_fetcher = None
-        if (
+        has_urls = (
             minutes.page_image_urls
+            and isinstance(minutes.page_image_urls[0], str)
             and connector
             and minutes.document_url
-        ):
+        )
+        if has_urls:
             # Capture page_urls in a closure so the fallback in
             # fetch_page_images() can use them if PDF generation fails
             _page_urls = list(minutes.page_image_urls)

backend/connectors/laserfiche.py

@@ -64,9 +64,12 @@ class LaserficheConnector:
             cookies={},
             headers={
                 "User-Agent": (
-                    "CivicCityHub/1.0 (civic research project; "
-                    "contact@civiccityhub.org)"
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/120.0.0.0 Safari/537.36"
                 ),
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.5",
             },
         )
 
@@ -366,8 +369,9 @@ class LaserficheConnector:
 
         Primary strategy (PDF generation):
         1. Visit docview.aspx to establish session cookies
-        2. POST to GeneratePDF.aspx to generate a PDF of the document
-        3. Use PyMuPDF (fitz) to render each PDF page to a PIL Image
+        2. Extract ASP.NET __VIEWSTATE and __EVENTVALIDATION tokens from the HTML
+        3. POST to GeneratePDF.aspx with ViewState tokens to generate a PDF
+        4. Use PyMuPDF (fitz) to render each PDF page to a PIL Image
 
         Fallback strategy (direct page download):
         If PDF generation fails (e.g. on HF Spaces where the Laserfiche
@@ -390,8 +394,41 @@ class LaserficheConnector:
             return []
 
         # Step 1: Visit docview.aspx to establish session cookies
+        # and extract ASP.NET ViewState tokens needed for GeneratePDF POST
+        viewstate = None
+        eventvalidation = None
+        docview_html = None
         try:
-            await self.client.get(document_url)
+            docview_response = await self.client.get(
+                document_url,
+                headers={
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                    "Accept-Language": "en-US,en;q=0.5",
+                },
+                timeout=30.0,
+            )
+            docview_response.raise_for_status()
+            docview_html = docview_response.text
+
+            # Extract __VIEWSTATE from the docview.aspx HTML
+            vs_match = re.search(
+                r'<input[^>]*name="__VIEWSTATE"[^>]*value="([^"]*)"',
+                docview_html,
+            )
+            if vs_match:
+                viewstate = vs_match.group(1)
+                print(f"[PDF] Extracted __VIEWSTATE ({len(viewstate)} chars)")
+
+            # Extract __EVENTVALIDATION from the docview.aspx HTML
+            ev_match = re.search(
+                r'<input[^>]*name="__EVENTVALIDATION"[^>]*value="([^"]*)"',
+                docview_html,
+            )
+            if ev_match:
+                eventvalidation = ev_match.group(1)
+                print(f"[PDF] Extracted __EVENTVALIDATION ({len(eventvalidation)} chars)")
+
         except Exception as e:
             print(f"[WARN] Error accessing document viewer: {e}")
             # Continue anyway — cookies might not be needed for GeneratePDF
@@ -400,16 +437,27 @@ class LaserficheConnector:
         gen_url = f"{self.base_url}/GeneratePDF.aspx"
         pdf_bytes = None
         try:
+            # Build POST data with ViewState tokens if available
+            post_data: dict[str, str] = {
+                "id": doc_id,
+                "dbid": DBID,
+                "pageFrom": "1",
+                "pageTo": "999",  # Request all pages
+            }
+            if viewstate:
+                post_data["__VIEWSTATE"] = viewstate
+            if eventvalidation:
+                post_data["__EVENTVALIDATION"] = eventvalidation
+
             pdf_response = await self.client.post(
                 gen_url,
-                data={
-                    "id": doc_id,
-                    "dbid": DBID,
-                    "pageFrom": "1",
-                    "pageTo": "999",  # Request all pages
-                },
+                data=post_data,
                 headers={
                     "Content-Type": "application/x-www-form-urlencoded",
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                    "Accept-Language": "en-US,en;q=0.5",
+                    "Referer": document_url,
                 },
                 timeout=60.0,  # PDF generation can be slow
             )
@@ -421,8 +469,8 @@ class LaserficheConnector:
             if not pdf_bytes or len(pdf_bytes) < 100:
                 print(f"[WARN] GeneratePDF returned empty or too small response ({len(pdf_bytes)} bytes)")
                 pdf_bytes = None
-            elif b"<html" in pdf_bytes[:100].lower() or b"<!DOCTYPE" in pdf_bytes[:100]:
-                print(f"[WARN] GeneratePDF returned HTML instead of PDF (likely an error page)")
+            elif self._is_error_response(pdf_bytes):
+                print(f"[WARN] GeneratePDF returned error page instead of PDF ({len(pdf_bytes)} bytes, Content-Type: {content_type})")
                 pdf_bytes = None
             else:
                 print(f"[PDF] Generated PDF: {len(pdf_bytes)} bytes, Content-Type: {content_type}")
@@ -441,7 +489,57 @@ class LaserficheConnector:
         # Step 4: Fallback — download individual page images directly
         # This handles cases where GeneratePDF.aspx is blocked (e.g. HF Spaces)
         print("[FALLBACK] Trying direct page image download...")
-        return await self._fetch_page_images_fallback(doc_id, page_urls)
+        return await self._fetch_page_images_fallback(doc_id, page_urls, docview_html)
+
+    def _is_error_response(self, content: bytes) -> bool:
+        """Check if the response content is an error page rather than a valid PDF.
+
+        Detects:
+        - HTML pages (<html, <!DOCTYPE)
+        - ASP.NET error pages (JavaScript alerts, "Object reference" errors)
+        - XML error responses
+        """
+        if not content:
+            return True
+
+        head = content[:500].lower()
+
+        # Check for HTML tags
+        if b"<html" in head or b"<!DOCTYPE" in head:
+            return True
+
+        # Check for ASP.NET error patterns
+        error_patterns = [
+            b"object reference not set",
+            b"nullreferenceexception",
+            b"exception of type",
+            b"error has occurred",
+            b"could not complete your request",
+            b"the system has encountered an error",
+            b"alert(",
+            b"stack trace:",
+        ]
+        for pattern in error_patterns:
+            if pattern in head:
+                return True
+
+        # Check for XML with error indicators
+        if b"<?xml" in head:
+            # XML responses from GeneratePDF are usually errors
+            # A valid PDF starts with %PDF
+            if b"<html" in content[:2000].lower() or b"error" in content[:2000].lower():
+                return True
+
+        # Check if it starts with PDF magic bytes
+        if content[:4] == b"%PDF":
+            return False
+
+        # If it doesn't start with PDF magic bytes and isn't clearly an error,
+        # it's likely not a valid PDF
+        if len(content) < 1000:
+            return True
+
+        return False
 
     def _render_pdf_to_images(self, pdf_bytes: bytes) -> list[bytes]:
         """Render PDF pages to PNG images using PyMuPDF."""
@@ -476,25 +574,34 @@ class LaserficheConnector:
         return images
 
     async def _fetch_page_images_fallback(
-        self, doc_id: str, page_urls: Optional[list[str]] = None
+        self, doc_id: str, page_urls: Optional[list[str]] = None, docview_html: Optional[str] = None
     ) -> list[bytes]:
         """Fallback: download individual page images directly from Laserfiche.
 
         Tries multiple strategies:
         1. Download each page URL directly (Page1.aspx, Page2.aspx, etc.)
-           and extract the embedded image reference from the HTML.
+           and extract docInfo JSON with PageIds from the HTML.
         2. Try the GetImage.aspx endpoint with PageIds from docInfo JSON.
+        3. Try GetImage.aspx with sequential page ID enumeration.
 
         Returns a list of PNG image bytes.
         """
         images: list[bytes] = []
 
-        # If we have explicit page URLs, try downloading them
+        # Strategy 1: Try downloading each page URL and extracting docInfo
         if page_urls:
             for i, page_url in enumerate(page_urls):
                 try:
                     print(f"[FALLBACK] Downloading page {i + 1}: {page_url}")
-                    response = await self.client.get(page_url, timeout=30.0)
+                    response = await self.client.get(
+                        page_url,
+                        headers={
+                            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                            "Accept-Language": "en-US,en;q=0.5",
+                        },
+                        timeout=30.0,
+                    )
                     response.raise_for_status()
 
                     content = response.content
@@ -502,7 +609,6 @@ class LaserficheConnector:
 
                     # Check if we got an image directly
                     if content_type.startswith("image/"):
-                        # Convert to PNG if needed
                         img_bytes = self._convert_to_png_bytes(content)
                         if img_bytes:
                             images.append(img_bytes)
@@ -526,9 +632,10 @@ class LaserficheConnector:
         if images:
             return images
 
-        # Last resort: try GetImage.aspx with page IDs from docInfo
+        # Strategy 2: Try GetImage.aspx with page IDs from docInfo
+        # Pass the already-fetched docview_html to avoid a redundant HTTP request
         print("[FALLBACK] Trying GetImage.aspx endpoint...")
-        return await self._fetch_via_getimage(doc_id)
+        return await self._fetch_via_getimage(doc_id, docview_html)
 
     async def _extract_image_from_page_html(
         self, html: str, doc_id: str, page_num: int
@@ -536,10 +643,28 @@ class LaserficheConnector:
         """Extract a page image from the Laserfiche page HTML.
 
         The page HTML contains a docInfo JSON with PageIds that can be
-        used to construct GetImage.aspx URLs.
+        used to construct GetImage.aspx URLs. Also tries to extract
+        ViewState tokens for authenticated requests.
         """
+        # Extract __VIEWSTATE from the page HTML for authenticated requests
+        viewstate = None
+        vs_match = re.search(
+            r'<input[^>]*name="__VIEWSTATE"[^>]*value="([^"]*)"',
+            html,
+        )
+        if vs_match:
+            viewstate = vs_match.group(1)
+
+        # Extract __EVENTVALIDATION
+        eventvalidation = None
+        ev_match = re.search(
+            r'<input[^>]*name="__EVENTVALIDATION"[^>]*value="([^"]*)"',
+            html,
+        )
+        if ev_match:
+            eventvalidation = ev_match.group(1)
+
         # Try to extract docInfo JSON from the HTML
-        # Pattern: var docInfo = {"NumPages":...,"PageIds":[...],...};
         doc_info_match = re.search(
             r'var\s+docInfo\s*=\s*(\{.*?"PageIds"\s*:\s*\[.*?\]\s*.*?\});',
             html,
@@ -563,12 +688,24 @@ class LaserficheConnector:
                         )
                         print(f"[FALLBACK] Trying GetImage.aspx: {img_url}")
                         try:
-                            img_response = await self.client.get(img_url, timeout=30.0)
+                            img_response = await self.client.get(
+                                img_url,
+                                headers={
+                                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                                    "Accept": "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+                                    "Accept-Language": "en-US,en;q=0.5",
+                                    "Referer": f"{self.base_url}/docview.aspx?id={doc_id_from_info}&dbid={dbid}",
+                                },
+                                timeout=30.0,
+                            )
                             img_response.raise_for_status()
                             img_content = img_response.content
                             content_type = img_response.headers.get("content-type", "")
                             if content_type.startswith("image/") and len(img_content) > 1000:
                                 return self._convert_to_png_bytes(img_content)
+                            elif len(img_content) > 1000 and not self._is_error_response(img_content):
+                                # Might be an image with wrong content-type
+                                return self._convert_to_png_bytes(img_content)
                         except Exception as e:
                             print(f"[FALLBACK] GetImage.aspx failed: {e}")
 
@@ -580,10 +717,18 @@ class LaserficheConnector:
                                     f"?pageid={page_id}&dbid={dbid}&docid={doc_id_from_info}"
                                     f"&format={fmt}"
                                 )
-                                img_response = await self.client.get(img_url_fmt, timeout=30.0)
+                                img_response = await self.client.get(
+                                    img_url_fmt,
+                                    headers={
+                                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                                        "Accept": "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+                                        "Referer": f"{self.base_url}/docview.aspx?id={doc_id_from_info}&dbid={dbid}",
+                                    },
+                                    timeout=30.0,
+                                )
                                 img_response.raise_for_status()
                                 img_content = img_response.content
-                                if len(img_content) > 1000:
+                                if len(img_content) > 1000 and not self._is_error_response(img_content):
                                     return self._convert_to_png_bytes(img_content)
                             except Exception:
                                 continue
@@ -592,19 +737,103 @@ class LaserficheConnector:
 
         return None
 
-    async def _fetch_via_getimage(self, doc_id: str) -> list[bytes]:
-        """Last resort: try to enumerate page IDs via GetImage.aspx.
+    async def _fetch_via_getimage(self, doc_id: str, existing_html: Optional[str] = None) -> list[bytes]:
+        """Last resort: try to get page images via GetImage.aspx.
+
+        Uses the docInfo JSON from the docview.aspx page to get PageIds,
+        then tries GetImage.aspx with each page ID.
 
-        Laserfiche assigns sequential page IDs. We try a range of
-        possible page IDs and see which ones return valid images.
+        Args:
+            doc_id: The Laserfiche document ID.
+            existing_html: Previously fetched docview.aspx HTML to avoid redundant requests.
         """
         images: list[bytes] = []
-        # Try page IDs in a reasonable range (typically sequential starting from a base)
-        # We don't know the exact page IDs, so we try a heuristic approach
-        # Page IDs are usually large numbers (e.g. 5580932, 5580933, 5580934)
-        # We can't enumerate them, so this is a best-effort attempt.
-        # Instead, try the page URLs with image-specific headers.
-        print("[FALLBACK] GetImage.aspx enumeration not feasible without page IDs")
+
+        # Use existing HTML if provided (avoids redundant HTTP request)
+        html = existing_html
+        docview_url = f"{self.base_url}/docview.aspx?id={doc_id}&dbid={DBID}"
+
+        # Fetch docview.aspx if we don't already have the HTML
+        if not html:
+            try:
+                response = await self.client.get(
+                    docview_url,
+                    headers={
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                    },
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+                html = response.text
+            except Exception as e:
+                print(f"[FALLBACK] Failed to get docInfo from docview.aspx: {e}")
+                return images
+
+        # Extract docInfo JSON
+        try:
+            doc_info_match = re.search(
+                r'var\s+docInfo\s*=\s*(\{.*?"PageIds"\s*:\s*\[.*?\]\s*.*?\});',
+                html,
+                re.DOTALL,
+            )
+            if doc_info_match:
+                doc_info = json.loads(doc_info_match.group(1))
+                page_ids = doc_info.get("PageIds", [])
+                dbid = doc_info.get("DBID", DBID)
+                doc_id_from_info = str(doc_info.get("Id", doc_id))
+
+                print(f"[FALLBACK] Got docInfo: {len(page_ids) - 1} pages, PageIds={page_ids}")
+
+                # Try each page ID with GetImage.aspx
+                for page_num in range(1, len(page_ids)):
+                    page_id = page_ids[page_num]
+                    if page_id and page_id > 0:
+                        img_url = (
+                            f"{self.base_url}/GetImage.aspx"
+                            f"?pageid={page_id}&dbid={dbid}&docid={doc_id_from_info}"
+                        )
+                        try:
+                            img_response = await self.client.get(
+                                img_url,
+                                headers={
+                                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                                    "Accept": "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
+                                    "Referer": docview_url,
+                                },
+                                timeout=30.0,
+                            )
+                            img_response.raise_for_status()
+                            img_content = img_response.content
+                            content_type = img_response.headers.get("content-type", "")
+
+                            if content_type.startswith("image/") and len(img_content) > 1000:
+                                img_bytes = self._convert_to_png_bytes(img_content)
+                                if img_bytes:
+                                    images.append(img_bytes)
+                                    print(f"[FALLBACK] GetImage.aspx page {page_num}: Got image ({len(img_bytes)} bytes)")
+                                    continue
+
+                            # Check if it's an error page
+                            if self._is_error_response(img_content):
+                                print(f"[FALLBACK] GetImage.aspx page {page_num}: Got error page ({len(img_content)} bytes, {content_type})")
+                            else:
+                                # Try to convert anyway
+                                img_bytes = self._convert_to_png_bytes(img_content)
+                                if img_bytes:
+                                    images.append(img_bytes)
+                                    print(f"[FALLBACK] GetImage.aspx page {page_num}: Got image ({len(img_bytes)} bytes)")
+
+                        except Exception as e:
+                            print(f"[FALLBACK] GetImage.aspx page {page_num}: Failed: {e}")
+
+        except (json.JSONDecodeError, KeyError, IndexError) as e:
+            print(f"[FALLBACK] Failed to parse docInfo JSON: {e}")
+
+        if images:
+            return images
+
+        print("[FALLBACK] All GetImage.aspx attempts failed")
         return images
 
     def _convert_to_png_bytes(self, image_data: bytes) -> Optional[bytes]:

backend/parsers/llm_summarizer.py

@@ -134,6 +134,10 @@ class LLMSummarizer:
     # This prevents LLM hallucination on completely unreadable text
     UNREADABLE_THRESHOLD = 0.2
 
+    # Minimum character threshold for considering OCR successful.
+    # If an engine produces fewer chars than this, other engines will still be tried.
+    MIN_OCR_CHARS = 50
+
     def __init__(
         self,
         deepseek_key: Optional[str] = None,
@@ -229,7 +233,7 @@ class LLMSummarizer:
         """Cleanup resources (no-op for now, kept for API compatibility)."""
         pass
 
-    def _preprocess_image_for_ocr(self, image) -> object:
+    def _preprocess_image_for_ocr(self, image, for_easyocr: bool = False):
         """Preprocess a PIL image to improve OCR accuracy.
 
         Applies:
@@ -239,9 +243,17 @@ class LLMSummarizer:
         4. Denoise with median filter
         5. Deskew (straighten) the image
 
-        Returns the preprocessed PIL Image.
+        For EasyOCR, returns the preprocessed image in RGB mode (EasyOCR needs 3-channel).
+        For Tesseract, returns the preprocessed image in grayscale (L) mode.
+
+        Args:
+            image: PIL Image to preprocess.
+            for_easyocr: If True, returns RGB image; if False, returns grayscale.
+
+        Returns:
+            Preprocessed PIL Image.
         """
-        # Convert to grayscale
+        # Convert to grayscale for processing
         if image.mode != "L":
             image = image.convert("L")
 
@@ -271,6 +283,10 @@ class LLMSummarizer:
             # Simple threshold without numpy
             image = image.point(lambda x: 255 if x > 128 else 0)
 
+        # EasyOCR expects 3-channel RGB
+        if for_easyocr:
+            image = image.convert("RGB")
+
         return image
 
     def _get_easyocr_reader(self):
@@ -294,11 +310,14 @@ class LLMSummarizer:
         return self._easyocr_reader
 
     def _ocr_with_easyocr(self, image_bytes: bytes) -> str:
-        """Run EasyOCR on a single page image.
+        """Run EasyOCR on a single page image with preprocessing.
 
         EasyOCR is a deep-learning based OCR engine (MIT license) that
         significantly outperforms Tesseract on scanned documents.
 
+        Applies image preprocessing (contrast enhancement, binarization)
+        before passing to EasyOCR for better results on scanned documents.
+
         Args:
             image_bytes: PNG/JPEG bytes of the page image.
 
@@ -310,12 +329,15 @@ class LLMSummarizer:
             return ""
 
         try:
-            # EasyOCR expects a numpy array (H, W, 3) in RGB format
+            # Open the image
             image = self._PIL_Image.open(io.BytesIO(image_bytes))
-            # Convert to RGB if necessary (EasyOCR expects 3-channel)
-            if image.mode != "RGB":
-                image = image.convert("RGB")
-            img_array = self._np.array(image)
+
+            # Preprocess the image for better OCR accuracy
+            # EasyOCR gets the same preprocessing as Tesseract now
+            processed = self._preprocess_image_for_ocr(image, for_easyocr=True)
+
+            # EasyOCR expects a numpy array (H, W, 3) in RGB format
+            img_array = self._np.array(processed)
 
             # Run EasyOCR
             results = reader.readtext(img_array, paragraph=True)
@@ -327,7 +349,26 @@ class LLMSummarizer:
                 if confidence > 0.3:  # Filter low-confidence detections
                     lines.append(text.strip())
 
-            return "\n".join(lines)
+            easyocr_text = "\n".join(lines)
+
+            # If EasyOCR produced very little text, try without preprocessing too
+            # (some documents OCR better with original image)
+            if len(easyocr_text.strip()) < self.MIN_OCR_CHARS:
+                raw_image = self._PIL_Image.open(io.BytesIO(image_bytes))
+                if raw_image.mode != "RGB":
+                    raw_image = raw_image.convert("RGB")
+                raw_array = self._np.array(raw_image)
+                raw_results = reader.readtext(raw_array, paragraph=True)
+                raw_lines = []
+                for bbox, text, confidence in raw_results:
+                    if confidence > 0.3:
+                        raw_lines.append(text.strip())
+                raw_text = "\n".join(raw_lines)
+                if len(raw_text.strip()) > len(easyocr_text.strip()):
+                    print(f"[EASYOCR] Raw image produced more text ({len(raw_text.strip())} chars) than preprocessed ({len(easyocr_text.strip())} chars)")
+                    easyocr_text = raw_text
+
+            return easyocr_text
         except Exception as e:
             print(f"[EASYOCR] Error during OCR: {e}")
             return ""
@@ -447,10 +488,12 @@ class LLMSummarizer:
         """Summarize meeting minutes using the best available method.
 
         Priority:
-        1. EasyOCR mode (primary) — deep-learning OCR, MIT license.
-           Significantly better accuracy than Tesseract on scanned documents.
-        2. Tesseract OCR mode (fallback) — traditional OCR, free, open-source.
-        3. Text mode (DeepSeek) — if raw_text is available.
+        1. OCR mode (EasyOCR -> Tesseract) — for scanned document images.
+        2. Text mode (DeepSeek) — if raw_text is available.
+
+        OCR mode is entered when:
+        - page_image_urls is non-empty, AND
+        - At least one OCR engine is available (EasyOCR, Tesseract, or Pillow for preprocessing)
 
         Args:
             minutes: The minutes document to summarize.
@@ -458,8 +501,15 @@ class LLMSummarizer:
                 for OCR. Used when page_image_urls contains URLs (strings)
                 instead of actual image data.
         """
+        # Check if any OCR capability is available
+        ocr_capable = (
+            self._easyocr_available
+            or self._pytesseract_available
+            or self._pillow_available
+        )
+
         # Prefer OCR mode for scanned document images
-        if minutes.page_image_urls and self._pillow_available:
+        if minutes.page_image_urls and ocr_capable:
             return await self._summarize_with_ocr(minutes, image_fetcher)
 
         # Fall back to text mode
@@ -521,51 +571,65 @@ class LLMSummarizer:
             )
 
         # Run OCR on each page image
-        # Priority: EasyOCR (primary) -> Tesseract (fallback)
+        # Strategy: Try ALL available engines and take the BEST result per page
         extracted_pages = []
         total_raw_chars = 0
-        easyocr_available = self._easyocr_available
-        tesseract_available = self._pytesseract_available
 
         for i, img_bytes in enumerate(image_bytes_list):
             page_text = ""
             ocr_engine = "none"
 
             try:
+                best_text = ""
+                best_engine = "none"
+
                 # --- Try EasyOCR first (deep-learning, better accuracy) ---
-                if easyocr_available:
-                    page_text = self._ocr_with_easyocr(img_bytes)
-                    if page_text and page_text.strip():
-                        ocr_engine = "EasyOCR"
-                        print(f"[OCR] Page {i + 1}: EasyOCR extracted {len(page_text.strip())} chars")
-
-                # --- Fall back to Tesseract if EasyOCR failed or produced nothing ---
-                if (not page_text or len(page_text.strip()) < 20) and tesseract_available:
-                    image = self._PIL_Image.open(io.BytesIO(img_bytes))
-
-                    # Try with preprocessing first
-                    processed = self._preprocess_image_for_ocr(image)
-                    text_tess = self._pytesseract.image_to_string(
-                        processed,
-                        lang=self.TESSERACT_LANGUAGES,
-                        config="--psm 6 --oem 3",
-                    )
+                if self._easyocr_available:
+                    try:
+                        text_easy = self._ocr_with_easyocr(img_bytes)
+                        if text_easy and len(text_easy.strip()) > len(best_text.strip()):
+                            best_text = text_easy.strip()
+                            best_engine = "EasyOCR"
+                            print(f"[OCR] Page {i + 1}: EasyOCR extracted {len(best_text)} chars")
+                    except Exception as e:
+                        print(f"[WARN] EasyOCR failed for page {i + 1}: {e}")
+
+                # --- Always try Tesseract too (it may extract different content) ---
+                if self._pytesseract_available:
+                    try:
+                        image = self._PIL_Image.open(io.BytesIO(img_bytes))
+
+                        # Try with preprocessing first
+                        processed = self._preprocess_image_for_ocr(image, for_easyocr=False)
+                        text_tess_processed = self._pytesseract.image_to_string(
+                            processed,
+                            lang=self.TESSERACT_LANGUAGES,
+                            config="--psm 6 --oem 3",
+                        ).strip()
 
-                    # Try without preprocessing as fallback
-                    if not text_tess or len(text_tess.strip()) < 20:
-                        text_raw = self._pytesseract.image_to_string(
+                        # Try without preprocessing as fallback
+                        text_tess_raw = self._pytesseract.image_to_string(
                             image,
                             lang=self.TESSERACT_LANGUAGES,
                             config="--psm 6 --oem 3",
-                        )
-                        if len(text_raw.strip()) > len(text_tess.strip()):
-                            text_tess = text_raw
-                            print(f"[OCR] Page {i + 1}: Tesseract using raw image")
-
-                    if text_tess and len(text_tess.strip()) > len(page_text.strip()):
-                        page_text = text_tess
-                        ocr_engine = "Tesseract"
-                        print(f"[OCR] Page {i + 1}: Tesseract extracted {len(text_tess.strip())} chars")
+                        ).strip()
+
+                        # Take the longer result from Tesseract
+                        text_tess = text_tess_processed if len(text_tess_processed) >= len(text_tess_raw) else text_tess_raw
+
+                        if text_tess and len(text_tess) > len(best_text):
+                            best_text = text_tess
+                            best_engine = "Tesseract"
+                            print(f"[OCR] Page {i + 1}: Tesseract extracted {len(best_text)} chars")
+                            if text_tess == text_tess_raw and text_tess != text_tess_processed:
+                                print(f"[OCR] Page {i + 1}: Tesseract using raw image (preprocessed gave {len(text_tess_processed)} chars)")
+                    except Exception as e:
+                        print(f"[WARN] Tesseract failed for page {i + 1}: {e}")
+
+                # --- Use the best result ---
+                if best_text:
+                    page_text = best_text
+                    ocr_engine = best_engine
 
                 # --- Log results ---
                 if page_text and page_text.strip():

backend/run.py

@@ -22,13 +22,29 @@ if __name__ == "__main__":
         providers.append("DeepSeek (text + OCR)")
     llm_status = ", ".join(providers) if providers else "Not configured"
 
-    ocr_available = False
+    ocr_engines = []
+    try:
+        import easyocr
+        ocr_engines.append("EasyOCR")
+    except ImportError:
+        pass
     try:
         import pytesseract
+        ocr_engines.append("Tesseract")
+    except ImportError:
+        pass
+    try:
         import PIL
-        ocr_available = True
+        ocr_engines.append("Pillow")
     except ImportError:
         pass
+    try:
+        import numpy
+        ocr_engines.append("NumPy")
+    except ImportError:
+        pass
+
+    ocr_status = ", ".join(ocr_engines) if ocr_engines else "Not installed"
 
     print("=" * 60)
     print("  Civic City Hub API Server")
@@ -37,7 +53,7 @@ if __name__ == "__main__":
     print(f"  City:     Paris, TX")
     print(f"  Website:  https://www.paristexas.gov")
     print(f"  LLM:      {llm_status}")
-    print(f"  OCR:      {'Tesseract (free)' if ocr_available else 'Not installed (pip install pytesseract Pillow)'}")
+    print(f"  OCR:      {ocr_status}")
     print()
     print("  Endpoints:")
     print(f"    Health:     http://localhost:{port}/health")

frontend/.gitignore

@@ -39,3 +39,5 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+
+.vercel