manavgup
diff --git a/‎backend/rag_solution/data_ingestion/chunking.py‎
Lines changed: 43 additions & 12 deletions b/‎backend/rag_solution/data_ingestion/chunking.py‎
Lines changed: 43 additions & 12 deletions
diff --git a/‎backend/rag_solution/repository/llm_model_repository.py‎
Lines changed: 16 additions & 5 deletions b/‎backend/rag_solution/repository/llm_model_repository.py‎
Lines changed: 16 additions & 5 deletions
diff --git a/‎backend/rag_solution/repository/llm_provider_repository.py‎
Lines changed: 20 additions & 8 deletions b/‎backend/rag_solution/repository/llm_provider_repository.py‎
Lines changed: 20 additions & 8 deletions
diff --git a/‎backend/rag_solution/router/llm_provider_router.py‎
Lines changed: 17 additions & 18 deletions b/‎backend/rag_solution/router/llm_provider_router.py‎
Lines changed: 17 additions & 18 deletions
diff --git a/‎backend/rag_solution/schemas/llm_model_schema.py‎
Lines changed: 23 additions & 0 deletions b/‎backend/rag_solution/schemas/llm_model_schema.py‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎backend/rag_solution/schemas/llm_provider_schema.py‎
Lines changed: 26 additions & 4 deletions b/‎backend/rag_solution/schemas/llm_provider_schema.py‎
Lines changed: 26 additions & 4 deletions
@@ -192,9 +192,38 @@ def sentence_based_chunking(
     for sentence in sentences:
         sentence_len = len(sentence)
 
-        # Check if adding this sentence would exceed target
-        if current_char_count + sentence_len > target_chars and current_chunk:
-            # Save current chunk
+        # Handle oversized sentences by splitting them
+        if sentence_len > target_chars:
+            # Save current chunk first if not empty
+            if current_chunk:
+                chunk_text = " ".join(current_chunk)
+                chunks.append(chunk_text)
+                current_chunk = []
+                current_char_count = 0
+
+            # Split oversized sentence into target-sized pieces
+            start = 0
+            while start < sentence_len:
+                end = min(start + target_chars, sentence_len)
+                # Try to break at word boundary
+                if end < sentence_len:
+                    last_space = sentence[start:end].rfind(" ")
+                    if last_space > target_chars * 0.5:  # At least 50% full
+                        end = start + last_space
+
+                chunk_piece = sentence[start:end].strip()
+                if chunk_piece:  # Only append non-empty chunks
+                    chunks.append(chunk_piece)
+                start = end
+
+            continue
+
+        # Account for space between sentences when joining
+        space_len = 1 if current_chunk else 0
+
+        # STRICT: Don't add sentence if it would exceed target
+        if current_char_count + space_len + sentence_len > target_chars and current_chunk:
+            # Save current chunk (don't add the sentence that would exceed)
             chunk_text = " ".join(current_chunk)
             chunks.append(chunk_text)
 
@@ -204,17 +233,18 @@ def sentence_based_chunking(
 
             for i in range(len(current_chunk) - 1, -1, -1):
                 sent_len = len(current_chunk[i])
-                if overlap_count + sent_len <= overlap_chars:
+                space = 1 if overlap_chunk else 0
+                if overlap_count + space + sent_len <= overlap_chars:
                     overlap_chunk.insert(0, current_chunk[i])
-                    overlap_count += sent_len
+                    overlap_count += sent_len + space
                 else:
                     break
 
             current_chunk = overlap_chunk
             current_char_count = overlap_count
 
         current_chunk.append(sentence)
-        current_char_count += sentence_len
+        current_char_count += sentence_len + space_len
 
     # Add final chunk if it meets minimum size
     if current_chunk:
@@ -368,19 +398,20 @@ def hierarchical_chunker_wrapper(text: str, settings: Settings = get_settings())
 def sentence_chunker(text: str, settings: Settings = get_settings()) -> list[str]:
     """Sentence-based chunking using settings configuration.
 
-    Uses conservative character-to-token ratio (2.5:1) for IBM Slate safety.
+    All config values (min_chunk_size, max_chunk_size, chunk_overlap) are in CHARACTERS.
+    Conservative char-to-token ratio (2.5:1) provides safety margin for IBM Slate 512-token limit.
 
     Args:
         text: Input text to chunk
-        settings: Configuration settings
+        settings: Configuration settings (all values in characters)
 
     Returns:
         List of sentence-based chunks
     """
-    # Convert config values assuming they're in tokens, multiply by 2.5 for chars
-    target_chars = int(settings.max_chunk_size * 2.5) if settings.max_chunk_size < 1000 else 750
-    overlap_chars = int(settings.chunk_overlap * 2.5) if settings.chunk_overlap < 200 else 100
-    min_chars = int(settings.min_chunk_size * 2.5) if settings.min_chunk_size < 500 else 500
+    # Use config values directly as characters (no conversion needed)
+    target_chars = settings.max_chunk_size
+    overlap_chars = settings.chunk_overlap
+    min_chars = settings.min_chunk_size
 
     return sentence_based_chunking(text, target_chars=target_chars, overlap_chars=overlap_chars, min_chars=min_chars)
 
 
@@ -6,7 +6,7 @@
 
 from rag_solution.core.exceptions import AlreadyExistsError, NotFoundError, ValidationError
 from rag_solution.models.llm_model import LLMModel
-from rag_solution.schemas.llm_model_schema import LLMModelInput, LLMModelOutput, ModelType
+from rag_solution.schemas.llm_model_schema import LLMModelInput, LLMModelOutput, LLMModelUpdate, ModelType
 
 
 class LLMModelRepository:
@@ -66,20 +66,29 @@ def get_models_by_type(self, model_type: ModelType) -> list[LLMModelOutput]:
         except Exception:
             raise
 
-    def update_model(self, model_id: UUID4, updates: dict) -> LLMModelOutput:
-        """Updates model details.
+    def update_model(self, model_id: UUID4, updates: LLMModelUpdate) -> LLMModelOutput:
+        """Updates model details with partial updates.
+
+        Args:
+            model_id: ID of the model to update
+            updates: LLMModelUpdate with optional fields for partial updates
 
         Raises:
             NotFoundError: If model not found
+
+        Note:
+            Only updates fields that are explicitly set in the updates object.
+            Uses Pydantic's exclude_unset=True to handle partial updates.
         """
         try:
             # Find the model first
             model = self.session.query(LLMModel).filter_by(id=model_id).first()
             if not model:
                 raise NotFoundError(resource_type="LLMModel", resource_id=str(model_id))
 
-            # Apply updates
-            for key, value in updates.items():
+            # Update only fields that were explicitly set (partial update support)
+            update_data = updates.model_dump(exclude_unset=True)
+            for key, value in update_data.items():
                 setattr(model, key, value)
 
             self.session.commit()
@@ -89,6 +98,8 @@ def update_model(self, model_id: UUID4, updates: dict) -> LLMModelOutput:
             self.session.rollback()
             raise AlreadyExistsError(resource_type="LLMModel", field="id", value=str(model_id)) from e
         except (NotFoundError, AlreadyExistsError, ValidationError):
+            # Rollback for safety even though these are typically raised before DB changes
+            self.session.rollback()
             raise
         except Exception:
             self.session.rollback()
 
@@ -6,7 +6,7 @@
 
 from rag_solution.core.exceptions import AlreadyExistsError, NotFoundError, ValidationError
 from rag_solution.models.llm_provider import LLMProvider
-from rag_solution.schemas.llm_provider_schema import LLMProviderInput
+from rag_solution.schemas.llm_provider_schema import LLMProviderInput, LLMProviderUpdate
 
 
 class LLMProviderRepository:
@@ -102,22 +102,33 @@ def get_provider_by_name_with_credentials(self, name: str) -> LLMProvider:
         except Exception:
             raise
 
-    def update_provider(self, provider_id: UUID4, updates: dict) -> LLMProvider:
-        """Updates provider details.
+    def update_provider(self, provider_id: UUID4, updates: LLMProviderUpdate) -> LLMProvider:
+        """Updates provider details with partial updates.
+
+        Args:
+            provider_id: ID of the provider to update
+            updates: LLMProviderUpdate with optional fields for partial updates
 
         Raises:
             NotFoundError: If provider not found
+
+        Note:
+            Only updates fields that are explicitly set in the updates object.
+            Uses Pydantic's exclude_unset=True to handle partial updates.
         """
         try:
-            # Handle SecretStr in updates
-            if "api_key" in updates and hasattr(updates["api_key"], "get_secret_value"):
-                updates["api_key"] = updates["api_key"].get_secret_value()
-
             # Find the provider first - this will raise NotFoundError if not found
             provider = self.get_provider_by_id(provider_id)
 
+            # Convert Pydantic model to dict, only including explicitly set fields
+            update_data = updates.model_dump(exclude_unset=True)
+
+            # Handle SecretStr in updates
+            if "api_key" in update_data and hasattr(update_data["api_key"], "get_secret_value"):
+                update_data["api_key"] = update_data["api_key"].get_secret_value()
+
             # Apply updates
-            for key, value in updates.items():
+            for key, value in update_data.items():
                 setattr(provider, key, value)
 
             self.session.commit()
@@ -128,6 +139,7 @@ def update_provider(self, provider_id: UUID4, updates: dict) -> LLMProvider:
             self.session.rollback()
             raise AlreadyExistsError(resource_type="LLMProvider", field="name", value=str(provider_id)) from e
         except (NotFoundError, AlreadyExistsError, ValidationError):
+            self.session.rollback()
             raise
         except Exception:
             self.session.rollback()
 
@@ -5,8 +5,8 @@
 from sqlalchemy.orm import Session
 
 from rag_solution.file_management.database import get_db
-from rag_solution.schemas.llm_model_schema import LLMModelInput, LLMModelOutput, ModelType
-from rag_solution.schemas.llm_provider_schema import LLMProviderInput, LLMProviderOutput
+from rag_solution.schemas.llm_model_schema import LLMModelInput, LLMModelOutput, LLMModelUpdate, ModelType
+from rag_solution.schemas.llm_provider_schema import LLMProviderInput, LLMProviderOutput, LLMProviderUpdate
 from rag_solution.services.llm_provider_service import LLMProviderService
 
 router = APIRouter(
@@ -58,15 +58,15 @@ def get_provider(provider_id: UUID4, service: Annotated[LLMProviderService, Depe
 
 @router.put("/{provider_id}", response_model=LLMProviderOutput)
 def update_provider(
-    provider_id: UUID4, updates: dict, service: Annotated[LLMProviderService, Depends(get_service)]
+    provider_id: UUID4, updates: LLMProviderUpdate, service: Annotated[LLMProviderService, Depends(get_service)]
 ) -> LLMProviderOutput:
     """
-    Update a specific LLM Provider.
+    Update a specific LLM Provider with partial updates.
+
+    Accepts LLMProviderUpdate with optional fields for partial updates.
+    Raises 404 if provider not found.
     """
-    provider = service.update_provider(provider_id, updates)
-    if not provider:
-        raise HTTPException(status_code=404, detail="Provider not found")
-    return provider
+    return service.update_provider(provider_id, updates)
 
 
 @router.delete("/{provider_id}")
@@ -122,24 +122,23 @@ def get_models_by_type(
 def get_model_by_id(model_id: UUID4, service: Annotated[LLMProviderService, Depends(get_service)]) -> LLMModelOutput:
     """
     Get a specific Model by ID.
+
+    Raises 404 if model not found.
     """
-    model = service.get_model_by_id(model_id)
-    if not model:
-        raise HTTPException(status_code=404, detail="Model not found")
-    return model
+    return service.get_model_by_id(model_id)
 
 
 @router.put("/models/{model_id}", response_model=LLMModelOutput)
 def update_model(
-    model_id: UUID4, updates: dict, service: Annotated[LLMProviderService, Depends(get_service)]
+    model_id: UUID4, updates: LLMModelUpdate, service: Annotated[LLMProviderService, Depends(get_service)]
 ) -> LLMModelOutput:
     """
-    Update a specific Model.
+    Update a specific Model with partial updates.
+
+    Accepts LLMModelUpdate with optional fields for partial updates.
+    Raises 404 if model not found.
     """
-    model = service.update_model(model_id, updates)
-    if not model:
-        raise HTTPException(status_code=404, detail="Model not found")
-    return model
+    return service.update_model(model_id, updates)
 
 
 @router.delete("/models/{model_id}")
 
@@ -27,6 +27,29 @@ class LLMModelInput(BaseModel):
     model_config = ConfigDict(protected_namespaces=())
 
 
+class LLMModelUpdate(BaseModel):
+    """Schema for partial updates to LLM models.
+
+    All fields are optional to support partial updates from API.
+    Use exclude_unset=True when converting to dict to only update provided fields.
+    """
+
+    model_id: str | None = None
+    default_model_id: str | None = None
+    model_type: ModelType | None = None
+    timeout: int | None = None
+    max_retries: int | None = None
+    batch_size: int | None = None
+    retry_delay: float | None = None
+    concurrency_limit: int | None = None
+    stream: bool | None = None
+    rate_limit: int | None = None
+    is_default: bool | None = None
+    is_active: bool | None = None
+
+    model_config = ConfigDict(protected_namespaces=())
+
+
 class LLMModelOutput(BaseModel):
     id: UUID4
     provider_id: UUID4
 
@@ -16,6 +16,23 @@ class LLMProviderInput(BaseModel):
     user_id: UUID4 | None = Field(None, description="User ID who owns this provider")
 
 
+class LLMProviderUpdate(BaseModel):
+    """Schema for partial updates to LLM providers.
+
+    All fields are optional to support partial updates from API.
+    Use exclude_unset=True when converting to dict to only update provided fields.
+    """
+
+    name: str | None = None
+    base_url: str | None = None
+    api_key: SecretStr | None = None
+    org_id: str | None = None
+    project_id: str | None = None
+    is_active: bool | None = None
+    is_default: bool | None = None
+    user_id: UUID4 | None = None
+
+
 class LLMProviderOutput(BaseModel):
     """Schema for returning an LLM Provider."""
 
@@ -48,12 +65,17 @@ class LLMProviderConfig(BaseModel):
 
     @field_validator("api_key", mode="before")
     @classmethod
-    def convert_api_key_to_secret_str(cls, v):
-        """Convert string API key to SecretStr."""
+    def convert_api_key_to_secret_str(cls, v: str | SecretStr) -> SecretStr:
+        """Convert string API key to SecretStr.
+
+        Args:
+            v: API key as string or SecretStr
+
+        Returns:
+            SecretStr: Secured API key
+        """
         if isinstance(v, str):
-            print(f"DEBUG: Converting API key '{v}' to SecretStr")
             return SecretStr(v)
-        print(f"DEBUG: API key is not a string: {type(v)} = {v}")
         return v
 
     model_config = ConfigDict(from_attributes=True)