LCORE-298: Conversation cache factory

docs/config.puml

@@ -29,6 +29,7 @@ class "CORSConfiguration" as src.models.config.CORSConfiguration {
 class "Configuration" as src.models.config.Configuration {
   authentication : Optional[AuthenticationConfiguration]
   authorization : Optional[AuthorizationConfiguration]
+  conversation_cache : Optional[ConversationCache]
   customization : Optional[Customization]
   database : Optional[DatabaseConfiguration]
   inference : Optional[InferenceConfiguration]
@@ -42,8 +43,22 @@ class "Configuration" as src.models.config.Configuration {
 class "ConfigurationBase" as src.models.config.ConfigurationBase {
   model_config
 }
+class "ConversationCache" as src.models.config.ConversationCache {
+  memory : Optional[InMemoryCacheConfig]
+  postgres : Optional[PostgreSQLDatabaseConfiguration]
+  sqlite : Optional[SQLiteDatabaseConfiguration]
+  type : Literal['memory', 'sqlite', 'postgres'] | None
+  check_cache_configuration() -> Self
+}
+class "CustomProfile" as src.models.config.CustomProfile {
+  path : str
+  prompts : Optional[dict[str, str]]
+  get_prompts() -> dict[str, str]
+}
 class "Customization" as src.models.config.Customization {
+  custom_profile : Optional[CustomProfile]
   disable_query_system_prompt : bool
+  profile_path : Optional[str]
   system_prompt : Optional[str]
   system_prompt_path : Optional[FilePath]
   check_customization_model() -> Self
@@ -55,6 +70,9 @@ class "DatabaseConfiguration" as src.models.config.DatabaseConfiguration {
   sqlite : Optional[SQLiteDatabaseConfiguration]
   check_database_configuration() -> Self
 }
+class "InMemoryCacheConfig" as src.models.config.InMemoryCacheConfig {
+  max_entries : Annotated
+}
 class "InferenceConfiguration" as src.models.config.InferenceConfiguration {
   default_model : Optional[str]
   default_provider : Optional[str]
@@ -139,8 +157,10 @@ src.models.config.AuthenticationConfiguration --|> src.models.config.Configurati
 src.models.config.AuthorizationConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.CORSConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.Configuration --|> src.models.config.ConfigurationBase
+src.models.config.ConversationCache --|> src.models.config.ConfigurationBase
 src.models.config.Customization --|> src.models.config.ConfigurationBase
 src.models.config.DatabaseConfiguration --|> src.models.config.ConfigurationBase
+src.models.config.InMemoryCacheConfig --|> src.models.config.ConfigurationBase
 src.models.config.InferenceConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.JwkConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.JwtConfiguration --|> src.models.config.ConfigurationBase
@@ -152,6 +172,7 @@ src.models.config.SQLiteDatabaseConfiguration --|> src.models.config.Configurati
 src.models.config.ServiceConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.TLSConfiguration --|> src.models.config.ConfigurationBase
 src.models.config.UserDataCollection --|> src.models.config.ConfigurationBase
+src.models.config.CustomProfile --* src.models.config.Customization : custom_profile
 src.models.config.JsonPathOperator --* src.models.config.JwtRoleRule : operator
 src.models.config.LlamaStackConfiguration --* src.models.config.Configuration : llama_stack
 src.models.config.SQLiteDatabaseConfiguration --* src.models.config.DatabaseConfiguration : sqlite

src/configuration.py

@@ -19,7 +19,7 @@
     AuthenticationConfiguration,
     InferenceConfiguration,
     DatabaseConfiguration,
-    ConversationCache,
+    ConversationCacheConfiguration,
 )
 
 
@@ -126,7 +126,7 @@ def inference(self) -> InferenceConfiguration:
         return self._configuration.inference
 
     @property
-    def conversation_cache(self) -> ConversationCache:
+    def conversation_cache_configuration(self) -> ConversationCacheConfiguration:
         """Return conversation cache configuration."""
         if self._configuration is None:
             raise LogicError("logic error: configuration is not loaded")

src/models/config.py

@@ -486,7 +486,7 @@ def check_default_model_and_provider(self) -> Self:
         return self
 
 
-class ConversationCache(ConfigurationBase):
+class ConversationCacheConfiguration(ConfigurationBase):
     """Conversation cache configuration."""
 
     type: Literal["memory", "sqlite", "postgres"] | None = None
@@ -542,7 +542,9 @@ class Configuration(ConfigurationBase):
     authorization: Optional[AuthorizationConfiguration] = None
     customization: Optional[Customization] = None
     inference: InferenceConfiguration = Field(default_factory=InferenceConfiguration)
-    conversation_cache: ConversationCache = Field(default_factory=ConversationCache)
+    conversation_cache: ConversationCacheConfiguration = Field(
+        default_factory=ConversationCacheConfiguration
+    )
 
     def dump(self, filename: str = "configuration.json") -> None:
         """Dump actual configuration into JSON file."""

tests/unit/models/config/test_conversation_cache.py

@@ -1,4 +1,4 @@
-"""Unit tests for ConversationCache model."""
+"""Unit tests for ConversationCacheConfiguration model."""
 
 from pathlib import Path
 
@@ -8,7 +8,7 @@
 
 import constants
 from models.config import (
-    ConversationCache,
+    ConversationCacheConfiguration,
     InMemoryCacheConfig,
     SQLiteDatabaseConfiguration,
     PostgreSQLDatabaseConfiguration,
@@ -17,7 +17,7 @@
 
 def test_conversation_cache_no_type_specified() -> None:
     """Check the test for type as optional attribute."""
-    c = ConversationCache()
+    c = ConversationCacheConfiguration()
     assert c.type is None
 
 
@@ -26,7 +26,7 @@ def test_conversation_cache_unknown_type() -> None:
     with pytest.raises(
         ValidationError, match="Input should be 'memory', 'sqlite' or 'postgres'"
     ):
-        _ = ConversationCache(type="foo")
+        _ = ConversationCacheConfiguration(type="foo")
 
 
 def test_conversation_cache_correct_type_but_not_configured(subtests) -> None:
@@ -35,19 +35,19 @@ def test_conversation_cache_correct_type_but_not_configured(subtests) -> None:
         with pytest.raises(
             ValidationError, match="Memory cache is selected, but not configured"
         ):
-            _ = ConversationCache(type=constants.CACHE_TYPE_MEMORY)
+            _ = ConversationCacheConfiguration(type=constants.CACHE_TYPE_MEMORY)
 
     with subtests.test(msg="SQLite cache"):
         with pytest.raises(
             ValidationError, match="SQLite cache is selected, but not configured"
         ):
-            _ = ConversationCache(type=constants.CACHE_TYPE_SQLITE)
+            _ = ConversationCacheConfiguration(type=constants.CACHE_TYPE_SQLITE)
 
     with subtests.test(msg="SQLite cache"):
         with pytest.raises(
             ValidationError, match="PostgreSQL cache is selected, but not configured"
         ):
-            _ = ConversationCache(type=constants.CACHE_TYPE_POSTGRES)
+            _ = ConversationCacheConfiguration(type=constants.CACHE_TYPE_POSTGRES)
 
 
 def test_conversation_cache_no_type_but_configured(subtests) -> None:
@@ -56,11 +56,15 @@ def test_conversation_cache_no_type_but_configured(subtests) -> None:
 
     with subtests.test(msg="Memory cache"):
         with pytest.raises(ValidationError, match=m):
-            _ = ConversationCache(memory=InMemoryCacheConfig(max_entries=100))
+            _ = ConversationCacheConfiguration(
+                memory=InMemoryCacheConfig(max_entries=100)
+            )
 
     with subtests.test(msg="SQLite cache"):
         with pytest.raises(ValidationError, match=m):
-            _ = ConversationCache(sqlite=SQLiteDatabaseConfiguration(db_path="path"))
+            _ = ConversationCacheConfiguration(
+                sqlite=SQLiteDatabaseConfiguration(db_path="path")
+            )
 
     with subtests.test(msg="PostgreSQL cache"):
         d = PostgreSQLDatabaseConfiguration(
@@ -71,7 +75,7 @@ def test_conversation_cache_no_type_but_configured(subtests) -> None:
             ca_cert_path=Path("tests/configuration/server.crt"),
         )
         with pytest.raises(ValidationError, match=m):
-            _ = ConversationCache(postgres=d)
+            _ = ConversationCacheConfiguration(postgres=d)
 
 
 def test_conversation_cache_multiple_configurations(subtests) -> None:
@@ -88,7 +92,7 @@ def test_conversation_cache_multiple_configurations(subtests) -> None:
         with pytest.raises(
             ValidationError, match="Only memory cache config must be provided"
         ):
-            _ = ConversationCache(
+            _ = ConversationCacheConfiguration(
                 type=constants.CACHE_TYPE_MEMORY,
                 memory=InMemoryCacheConfig(max_entries=100),
                 sqlite=SQLiteDatabaseConfiguration(db_path="path"),
@@ -99,7 +103,7 @@ def test_conversation_cache_multiple_configurations(subtests) -> None:
         with pytest.raises(
             ValidationError, match="Only SQLite cache config must be provided"
         ):
-            _ = ConversationCache(
+            _ = ConversationCacheConfiguration(
                 type=constants.CACHE_TYPE_SQLITE,
                 memory=InMemoryCacheConfig(max_entries=100),
                 sqlite=SQLiteDatabaseConfiguration(db_path="path"),
@@ -110,7 +114,7 @@ def test_conversation_cache_multiple_configurations(subtests) -> None:
         with pytest.raises(
             ValidationError, match="Only PostgreSQL cache config must be provided"
         ):
-            _ = ConversationCache(
+            _ = ConversationCacheConfiguration(
                 type=constants.CACHE_TYPE_POSTGRES,
                 memory=InMemoryCacheConfig(max_entries=100),
                 sqlite=SQLiteDatabaseConfiguration(db_path="path"),
@@ -120,7 +124,7 @@ def test_conversation_cache_multiple_configurations(subtests) -> None:
 
 def test_conversation_type_memory() -> None:
     """Test the memory conversation cache configuration."""
-    c = ConversationCache(
+    c = ConversationCacheConfiguration(
         type=constants.CACHE_TYPE_MEMORY, memory=InMemoryCacheConfig(max_entries=100)
     )
     assert c.type == constants.CACHE_TYPE_MEMORY
@@ -133,21 +137,21 @@ def test_conversation_type_memory() -> None:
 def test_conversation_type_memory_wrong_config() -> None:
     """Test the memory conversation cache configuration."""
     with pytest.raises(ValidationError, match="Field required"):
-        _ = ConversationCache(
+        _ = ConversationCacheConfiguration(
             type=constants.CACHE_TYPE_MEMORY,
             memory=InMemoryCacheConfig(),
         )
 
     with pytest.raises(ValidationError, match="Input should be greater than 0"):
-        _ = ConversationCache(
+        _ = ConversationCacheConfiguration(
             type=constants.CACHE_TYPE_MEMORY,
             memory=InMemoryCacheConfig(max_entries=-100),
         )
 
 
 def test_conversation_type_sqlite() -> None:
     """Test the SQLite conversation cache configuration."""
-    c = ConversationCache(
+    c = ConversationCacheConfiguration(
         type=constants.CACHE_TYPE_SQLITE,
         sqlite=SQLiteDatabaseConfiguration(db_path="path"),
     )
@@ -161,7 +165,7 @@ def test_conversation_type_sqlite() -> None:
 def test_conversation_type_sqlite_wrong_config() -> None:
     """Test the SQLite conversation cache configuration."""
     with pytest.raises(ValidationError, match="Field required"):
-        _ = ConversationCache(
+        _ = ConversationCacheConfiguration(
             type=constants.CACHE_TYPE_SQLITE,
             memory=SQLiteDatabaseConfiguration(),
         )
@@ -177,7 +181,7 @@ def test_conversation_type_postgres() -> None:
         ca_cert_path=Path("tests/configuration/server.crt"),
     )
 
-    c = ConversationCache(
+    c = ConversationCacheConfiguration(
         type=constants.CACHE_TYPE_POSTGRES,
         postgres=d,
     )
@@ -194,7 +198,7 @@ def test_conversation_type_postgres() -> None:
 def test_conversation_type_postgres_wrong_config() -> None:
     """Test the SQLite conversation cache configuration."""
     with pytest.raises(ValidationError, match="Field required"):
-        _ = ConversationCache(
+        _ = ConversationCacheConfiguration(
             type=constants.CACHE_TYPE_POSTGRES,
             postgres=PostgreSQLDatabaseConfiguration(),
         )

tests/unit/test_configuration.py

@@ -71,7 +71,7 @@ def test_default_configuration() -> None:
 
     with pytest.raises(Exception, match="logic error: configuration is not loaded"):
         # try to read property
-        _ = cfg.conversation_cache  # pylint: disable=pointless-statement
+        _ = cfg.conversation_cache_configuration  # pylint: disable=pointless-statement
 
 
 def test_configuration_is_singleton() -> None:
@@ -149,7 +149,7 @@ def test_init_from_dict() -> None:
     assert cfg.inference is not None
 
     # check conversation cache
-    assert cfg.conversation_cache is not None
+    assert cfg.conversation_cache_configuration is not None
 
 
 def test_init_from_dict_with_mcp_servers() -> None: