Release v3.5.0 into Main

Author: estohlmann

CHANGELOG.md

@@ -1,3 +1,40 @@
+# v3.5.0
+## Key Features
+### User Interface Modernization
+- New year new me? We are rolling out an updated user interface (UI) in Q1. This release is the first stage of this effort.
+- **Document Summarization**
+  - Building on existing non-RAG in context capabilities, we added a more comprehensive Document Summarization feature. This includes a dedicated modal interface where users:
+    - Upload text-based documents
+    - Select from approved summarization models
+    - Select and customize summarization prompts
+    - Choose between integrating summaries into existing chat sessions or initiating new ones
+  - System administrators retain full control through configuration settings in the Admin Configuration page
+
+## Other UI Enhancements
+- Refactored chatbot UI in advance of upcoming UI improvements and this launch
+- Consolidated existing chatbot features to streamline the UI
+- Added several components to improve user experience: copy button, response generation animation
+- Markdown formatting updated in LLM responses
+
+## Other System Enhancements
+- Enhanced user data integration with RAG metadata infrastructure, enabling improved file management within vector stores
+- Optimized RAG metadata schema to accommodate expanded documentation requirements
+- Started updating sdk to be compliant with current APIs
+- Implementation of updated corporate brand guidelines
+
+## Coming soon
+Our development roadmap includes several significant UI/UX enhancements:
+- Streamlined vector store file administration and access control
+- Integrated ingestion pipeline management
+- Enhanced Model Management user interface
+
+## Acknowledgements
+* @bedanley
+* @estohlmann
+* @dustins
+
+**Full Changelog**: https://github.com/awslabs/LISA/compare/v3.4.0...v3.5.0
+
 # v3.4.0
 ## Key Features
 ### Vector Store Support

Makefile

@@ -154,6 +154,7 @@ createPythonEnvironment:
 installPythonRequirements:
 	pip3 install pip --upgrade
 	pip3 install -r requirements-dev.txt
+	pip3 install -e lisa-sdk
 
 
 ## Set up TypeScript interpreter environment

VERSION

@@ -1 +1 @@
-3.4.0
+3.5.0

lambda/authorizer/lambda_functions.py

@@ -54,26 +54,29 @@ def lambda_handler(event: Dict[str, Any], context) -> Dict[str, Any]:  # type: i
     jwt_groups_property = os.environ.get("JWT_GROUPS_PROP", "")
 
     deny_policy = generate_policy(effect="Deny", resource=event["methodArn"])
-
+    groups: str
     if id_token in get_management_tokens():
-        allow_policy = generate_policy(effect="Allow", resource=event["methodArn"], username="lisa-management-token")
+        username = "lisa-management-token"
+        # Add management token to Admin groups
+        groups = json.dumps([admin_group])
+        allow_policy = generate_policy(effect="Allow", resource=event["methodArn"], username=username)
+        allow_policy["context"] = {"username": username, "groups": groups}
         logger.debug(f"Generated policy: {allow_policy}")
         return allow_policy
 
     if jwt_data := id_token_is_valid(id_token=id_token, client_id=client_id, authority=authority):
         is_admin_user = is_admin(jwt_data, admin_group, jwt_groups_property)
-        groups = get_property_path(jwt_data, jwt_groups_property)
-        allow_policy = generate_policy(effect="Allow", resource=event["methodArn"], username=jwt_data["sub"])
-        allow_policy["context"] = {"username": jwt_data["sub"], "groups": json.dumps(groups or [])}
+        groups = json.dumps(get_property_path(jwt_data, jwt_groups_property) or [])
+        username = find_jwt_username(jwt_data)
+        allow_policy = generate_policy(effect="Allow", resource=event["methodArn"], username=username)
+        allow_policy["context"] = {"username": username, "groups": groups}
 
         if requested_resource.startswith("/models") and not is_admin_user:
             # non-admin users can still list models
             if event["path"].rstrip("/") != "/models":
-                username = jwt_data.get("sub", "user")
                 logger.info(f"Deny access to {username} due to non-admin accessing /models api.")
                 return deny_policy
         if requested_resource.startswith("/configuration") and request_method == "PUT" and not is_admin_user:
-            username = jwt_data.get("sub", "user")
             logger.info(f"Deny access to {username} due to non-admin trying to update configuration.")
             return deny_policy
         logger.debug(f"Generated policy: {allow_policy}")
@@ -160,6 +163,22 @@ def get_property_path(data: dict[str, Any], property_path: str) -> Optional[Any]
     return current_node
 
 
+def find_jwt_username(jwt_data: dict[str, str]) -> str:
+    """Find the username in the JWT. If the key 'username' doesn't exist, return 'sub', which will be a UUID"""
+    username = None
+    if "username" in jwt_data:
+        username = jwt_data.get("username")
+    if "cognito:username" in jwt_data:
+        username = jwt_data.get("cognito:username")
+    else:
+        username = jwt_data.get("sub")
+
+    if not username:
+        raise ValueError("No username found in JWT")
+
+    return username
+
+
 @cache
 def get_management_tokens() -> list[str]:
     """Return secret management tokens if they exist."""
@@ -170,10 +189,13 @@ def get_management_tokens() -> list[str]:
         secret_tokens.append(
             secrets_manager.get_secret_value(SecretId=secret_id, VersionStage="AWSCURRENT")["SecretString"]
         )
-        secret_tokens.append(
-            secrets_manager.get_secret_value(SecretId=secret_id, VersionStage="AWSPREVIOUS")["SecretString"]
-        )
+        try:
+            secret_tokens.append(
+                secrets_manager.get_secret_value(SecretId=secret_id, VersionStage="AWSPREVIOUS")["SecretString"]
+            )
+        except Exception:
+            logger.info("No previous management token version found")
     except ClientError as e:
-        logger.warn(f"Unable to fetch {secret_id}. {e.response['Error']['Code']}: {e.response['Error']['Message']}")
+        logger.warning(f"Unable to fetch {secret_id}. {e.response['Error']['Code']}: {e.response['Error']['Message']}")
 
     return secret_tokens

lambda/models/domain_objects.py

@@ -14,16 +14,19 @@
 
 """Domain objects for interacting with the model endpoints."""
 
+import logging
 import time
 import uuid
 from enum import Enum
-from typing import Annotated, Any, Dict, List, Optional, Union
+from typing import Annotated, Any, Dict, Generator, List, Optional, TypeAlias, Union
 
 from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt
 from pydantic.functional_validators import AfterValidator, field_validator, model_validator
 from typing_extensions import Self
 from utilities.validators import validate_all_fields_defined, validate_any_fields_defined, validate_instance_type
 
+logger = logging.getLogger(__name__)
+
 
 class InferenceContainer(str, Enum):
     """Enum representing the interface container type."""
@@ -167,6 +170,15 @@ def validate_environment(cls, environment: Dict[str, str]) -> Dict[str, str]:
         return environment
 
 
+class ModelFeature(BaseModel):
+    __exceptions: List[Any] = []
+    name: str
+    overview: str
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+
 class LISAModel(BaseModel):
     """Core model definition fields."""
 
@@ -181,6 +193,7 @@ class LISAModel(BaseModel):
     modelUrl: Optional[str] = None
     status: ModelStatus
     streaming: bool
+    features: Optional[List[ModelFeature]] = None
 
 
 class ApiResponseBase(BaseModel):
@@ -202,6 +215,7 @@ class CreateModelRequest(BaseModel):
     modelType: ModelType
     modelUrl: Optional[str] = None
     streaming: Optional[bool] = False
+    features: Optional[List[ModelFeature]] = None
 
     @model_validator(mode="after")
     def validate_create_model_request(self) -> Self:
@@ -301,6 +315,28 @@ class IngestionType(Enum):
     MANUAL = "manual"
 
 
+RagDocumentDict: TypeAlias = Dict[str, Any]
+
+
+class ChunkStrategyType(Enum):
+    """Enum for different types of chunking strategies."""
+
+    FIXED = "fixed"
+
+
+class RagSubDocument(BaseModel):
+    """Rag Sub-Document Entity for storing in DynamoDB."""
+
+    document_id: str
+    subdocs: list[str] = Field(default_factory=lambda: [])
+    index: int = Field(exclude=True)
+    sk: Optional[str] = None
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        self.sk = f"subdoc#{self.document_id}#{self.index}"
+
+
 class RagDocument(BaseModel):
     """Rag Document Entity for storing in DynamoDB."""
 
@@ -310,16 +346,48 @@ class RagDocument(BaseModel):
     collection_id: str
     document_name: str
     source: str
-    sub_docs: List[str] = Field(default_factory=lambda: [])
+    username: str
+    subdocs: List[str] = Field(default_factory=lambda: [], exclude=True)
+    chunk_strategy: dict[str, str] = {}
     ingestion_type: IngestionType = Field(default_factory=lambda: IngestionType.MANUAL)
     upload_date: int = Field(default_factory=lambda: int(time.time()))
-
+    chunks: Optional[int] = 0
     model_config = ConfigDict(use_enum_values=True, validate_default=True)
 
     def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         self.pk = self.createPartitionKey(self.repository_id, self.collection_id)
+        self.chunks = len(self.subdocs)
 
     @staticmethod
     def createPartitionKey(repository_id: str, collection_id: str) -> str:
         return f"{repository_id}#{collection_id}"
+
+    def chunk_doc(self, chunk_size: int = 1000) -> Generator[RagSubDocument, None, None]:
+        """Chunk the document into smaller sub-documents."""
+        total_subdocs = len(self.subdocs)
+        for start_index in range(0, total_subdocs, chunk_size):
+            end_index = min(start_index + chunk_size, total_subdocs)
+            yield RagSubDocument(
+                document_id=self.document_id, subdocs=self.subdocs[start_index:end_index], index=start_index
+            )
+
+    @staticmethod
+    def join_docs(documents: List[RagDocumentDict]) -> List[RagDocumentDict]:
+        """Join the multiple sub-documents into a single document."""
+        # Group documents by document_id
+        grouped_docs: dict[str, List[RagDocumentDict]] = {}
+        for doc in documents:
+            doc_id = doc.get("document_id", "")
+            if doc_id not in grouped_docs:
+                grouped_docs[doc_id] = []
+            grouped_docs[doc_id].append(doc)
+
+        # Join same document_id into single RagDocument
+        joined_docs: List[RagDocumentDict] = []
+        for docs in grouped_docs.values():
+            joined_doc = docs[0]
+            joined_doc["subdocs"] = [sub_doc for doc in docs for sub_doc in (doc.get("subdocs", []) or [])]
+            joined_docs.append(joined_doc)
+
+        return joined_docs