Fix URL normalization and improve error handling in Ollama service

- Add _normalize_base function to handle URL protocol and formatting
- Replace 0.0.0.0 with localhost for client requests
- Improve error handling with specific exception types
- Add better logging with URL information
- Use urljoin for safer URL construction

app/services/summarizer.py

@@ -2,120 +2,138 @@
 Ollama service integration for text summarization.
 """
 import time
-from typing import Dict, Any, Optional
+from typing import Dict, Any
+from urllib.parse import urljoin
+
 import httpx
+
 from app.core.config import settings
 from app.core.logging import get_logger
 
 logger = get_logger(__name__)
 
 
+def _normalize_base(url: str) -> str:
+    """
+    Ensure a usable base URL:
+      - add http:// if scheme missing
+      - replace 0.0.0.0 (bind addr) with localhost for client requests
+      - ensure trailing slash for safe urljoin
+    """
+    v = (url or "").strip()
+    if not v:
+        v = "http://localhost:11434"
+    if not (v.startswith("http://") or v.startswith("https://")):
+        v = "http://" + v
+    if "://0.0.0.0:" in v:
+        v = v.replace("://0.0.0.0:", "://localhost:")
+    if not v.endswith("/"):
+        v += "/"
+    return v
+
+
 class OllamaService:
     """Service for interacting with Ollama API."""
-    
+
     def __init__(self):
-        self.base_url = settings.ollama_host
+        self.base_url = _normalize_base(settings.ollama_host)
         self.model = settings.ollama_model
         self.timeout = settings.ollama_timeout
-    
+
+        logger.info(f"Ollama base URL (normalized): {self.base_url}")
+        logger.info(f"Ollama model: {self.model}")
+
     async def summarize_text(
-        self, 
-        text: str, 
-        max_tokens: int = 256, 
-        prompt: str = "Summarize the following text concisely:"
+        self,
+        text: str,
+        max_tokens: int = 256,
+        prompt: str = "Summarize the following text concisely:",
     ) -> Dict[str, Any]:
         """
         Summarize text using Ollama.
-        
-        Args:
-            text: Text to summarize
-            max_tokens: Maximum tokens for summary
-            prompt: Custom prompt for summarization
-            
-        Returns:
-            Dictionary containing summary and metadata
-            
-        Raises:
-            httpx.HTTPError: If Ollama API call fails
+        Raises httpx.HTTPError (and subclasses) on failure.
         """
         start_time = time.time()
-        
-        # Calculate dynamic timeout based on text length
-        # Base timeout + additional time for longer texts
+
+        # Dynamic timeout: base + 5s per extra 1000 chars (cap 120s)
         text_length = len(text)
-        dynamic_timeout = self.timeout + max(0, (text_length - 1000) // 1000 * 5)  # +5s per 1000 chars over 1000
-        
-        # Cap the timeout at 2 minutes to prevent extremely long waits
-        dynamic_timeout = min(dynamic_timeout, 120)
-        
-        logger.info(f"Processing text of {text_length} characters with timeout of {dynamic_timeout}s")
-        
-        # Prepare the full prompt
+        dynamic_timeout = min(self.timeout + max(0, (text_length - 1000) // 1000 * 5), 120)
+
+        logger.info(f"Processing text of {text_length} chars with timeout {dynamic_timeout}s")
+
         full_prompt = f"{prompt}\n\n{text}"
-        
-        # Prepare request payload
+
         payload = {
             "model": self.model,
             "prompt": full_prompt,
             "stream": False,
             "options": {
                 "num_predict": max_tokens,
-                "temperature": 0.3,  # Lower temperature for more consistent summaries
-            }
+                "temperature": 0.3,
+            },
         }
-        
+
+        generate_url = urljoin(self.base_url, "api/generate")
+        logger.info(f"POST {generate_url}")
+
         try:
-            # Debug logging
-            full_url = f"{self.base_url}/api/generate"
-            logger.info(f"Making request to: {full_url}")
-            logger.info(f"Base URL: {self.base_url}")
-            
             async with httpx.AsyncClient(timeout=dynamic_timeout) as client:
-                response = await client.post(
-                    full_url,
-                    json=payload
-                )
-                response.raise_for_status()
-                
-                result = response.json()
-                
-                # Calculate processing time
-                latency_ms = (time.time() - start_time) * 1000
-                
-                return {
-                    "summary": result.get("response", "").strip(),
-                    "model": self.model,
-                    "tokens_used": result.get("eval_count", 0),
-                    "latency_ms": round(latency_ms, 2)
-                }
-                
+                resp = await client.post(generate_url, json=payload)
+                resp.raise_for_status()
+                data = resp.json()
+
+            latency_ms = (time.time() - start_time) * 1000.0
+            return {
+                "summary": (data.get("response") or "").strip(),
+                "model": self.model,
+                "tokens_used": data.get("eval_count", 0),
+                "latency_ms": round(latency_ms, 2),
+            }
+
         except httpx.TimeoutException:
-            logger.error(f"Timeout calling Ollama API after {dynamic_timeout}s for text of {text_length} characters")
-            # Re-raise the TimeoutException so the API layer can handle it properly
+            logger.error(
+                f"Timeout calling Ollama after {dynamic_timeout}s "
+                f"(chars={text_length}, url={generate_url})"
+            )
+            raise
+        except httpx.RequestError as e:
+            # Network / connection errors (DNS, refused, TLS, etc.)
+            logger.error(f"Request error calling Ollama at {generate_url}: {e}")
             raise
-        except httpx.HTTPError as e:
-            logger.error(f"HTTP error calling Ollama API: {e}")
+        except httpx.HTTPStatusError as e:
+            # Non-2xx responses
+            body = e.response.text if e.response is not None else ""
+            logger.error(
+                f"HTTP {e.response.status_code if e.response else '??'} from Ollama at {generate_url}: {body[:400]}"
+            )
             raise
         except Exception as e:
-            logger.error(f"Unexpected error calling Ollama API: {e}")
-            raise httpx.HTTPError(f"Ollama API error: {str(e)}")
-    
+            logger.error(f"Unexpected error calling Ollama at {generate_url}: {e}")
+            # Present a consistent error type to callers
+            raise httpx.HTTPError(f"Ollama API error: {e}") from e
+
     async def check_health(self) -> bool:
         """
-        Check if Ollama service is available.
-        
-        Returns:
-            True if Ollama is reachable, False otherwise
+        Verify Ollama is reachable and (optionally) that the model exists.
         """
+        tags_url = urljoin(self.base_url, "api/tags")
+        logger.info(f"GET {tags_url} (health)")
+
         try:
-            # Debug logging for health check
-            health_url = f"{self.base_url}/api/tags"
-            logger.info(f"Health check URL: {health_url}")
-            logger.info(f"Base URL for health check: {self.base_url}")
-            
-            async with httpx.AsyncClient(timeout=5) as client:
-                response = await client.get(health_url)
-                return response.status_code == 200
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                resp = await client.get(tags_url)
+                resp.raise_for_status()
+                tags = resp.json()
+
+            # If you want to *require* the model to exist, uncomment below:
+            # available = {m.get("name") for m in tags.get("models", []) if isinstance(m, dict)}
+            # if self.model and self.model not in available:
+            #     logger.warning(f"Model '{self.model}' not found in Ollama tags: {available}")
+            #     # Still return True for connectivity; or return False to fail hard
+            #     return True
+
+            return True
+
         except Exception as e:
             logger.warning(f"Ollama health check failed: {e}")
             return False