0
# Advanced Features
1
2
Enhanced capabilities including business rules, serving configurations, and generative AI features. These advanced services provide sophisticated control over search and recommendation behavior, business logic implementation, and cutting-edge AI-powered features.
3
4
## Capabilities
5
6
### Business Rules and Controls
7
8
Management of business rules and control mechanisms that influence search and recommendation behavior.
9
10
```python { .api }
11
class ControlServiceClient:
12
def create_control(self, request: CreateControlRequest) -> Control:
13
"""
14
Creates a new control for applying business rules.
15
16
Args:
17
request: Contains parent catalog and control configuration
18
19
Returns:
20
Control: The created control with generated metadata
21
"""
22
23
def get_control(self, request: GetControlRequest) -> Control:
24
"""
25
Retrieves a control by its resource name.
26
27
Args:
28
request: Contains control resource name
29
30
Returns:
31
Control: The requested control configuration
32
"""
33
34
def list_controls(self, request: ListControlsRequest) -> ListControlsResponse:
35
"""
36
Lists all controls in a catalog with pagination support.
37
38
Args:
39
request: Contains parent catalog and pagination parameters
40
41
Returns:
42
ListControlsResponse: List of controls with pagination
43
"""
44
45
def update_control(self, request: UpdateControlRequest) -> Control:
46
"""
47
Updates an existing control configuration.
48
49
Args:
50
request: Contains control updates and field mask
51
52
Returns:
53
Control: Updated control configuration
54
"""
55
56
def delete_control(self, request: DeleteControlRequest) -> None:
57
"""
58
Deletes a control and removes it from all serving configurations.
59
60
Args:
61
request: Contains control resource name
62
"""
63
```
64
65
```python { .api }
66
class ControlServiceAsyncClient:
67
async def create_control(self, request: CreateControlRequest) -> Control:
68
"""
69
Creates a new control for applying business rules.
70
71
Args:
72
request: Contains parent catalog and control configuration
73
74
Returns:
75
Control: The created control with generated metadata
76
"""
77
78
async def get_control(self, request: GetControlRequest) -> Control:
79
"""
80
Retrieves a control by its resource name.
81
82
Args:
83
request: Contains control resource name
84
85
Returns:
86
Control: The requested control configuration
87
"""
88
89
async def list_controls(self, request: ListControlsRequest) -> ListControlsResponse:
90
"""
91
Lists all controls in a catalog with pagination support.
92
93
Args:
94
request: Contains parent catalog and pagination parameters
95
96
Returns:
97
ListControlsResponse: List of controls with pagination
98
"""
99
100
async def update_control(self, request: UpdateControlRequest) -> Control:
101
"""
102
Updates an existing control configuration.
103
104
Args:
105
request: Contains control updates and field mask
106
107
Returns:
108
Control: Updated control configuration
109
"""
110
111
async def delete_control(self, request: DeleteControlRequest) -> None:
112
"""
113
Deletes a control and removes it from all serving configurations.
114
115
Args:
116
request: Contains control resource name
117
"""
118
```
119
120
### Serving Configuration Management
121
122
Management of serving configurations that control how search and recommendations are delivered.
123
124
```python { .api }
125
class ServingConfigServiceClient:
126
def create_serving_config(self, request: CreateServingConfigRequest) -> ServingConfig:
127
"""
128
Creates a new serving configuration for search or recommendations.
129
130
Args:
131
request: Contains parent catalog and serving config settings
132
133
Returns:
134
ServingConfig: The created serving configuration
135
"""
136
137
def get_serving_config(self, request: GetServingConfigRequest) -> ServingConfig:
138
"""
139
Retrieves a serving configuration by its resource name.
140
141
Args:
142
request: Contains serving config resource name
143
144
Returns:
145
ServingConfig: The requested serving configuration
146
"""
147
148
def list_serving_configs(self, request: ListServingConfigsRequest) -> ListServingConfigsResponse:
149
"""
150
Lists all serving configurations in a catalog.
151
152
Args:
153
request: Contains parent catalog and pagination parameters
154
155
Returns:
156
ListServingConfigsResponse: List of serving configurations
157
"""
158
159
def update_serving_config(self, request: UpdateServingConfigRequest) -> ServingConfig:
160
"""
161
Updates an existing serving configuration.
162
163
Args:
164
request: Contains serving config updates and field mask
165
166
Returns:
167
ServingConfig: Updated serving configuration
168
"""
169
170
def delete_serving_config(self, request: DeleteServingConfigRequest) -> None:
171
"""
172
Deletes a serving configuration.
173
174
Args:
175
request: Contains serving config resource name
176
"""
177
178
def add_control(self, request: AddControlRequest) -> ServingConfig:
179
"""
180
Associates a control with a serving configuration.
181
182
Args:
183
request: Contains serving config and control resource names
184
185
Returns:
186
ServingConfig: Updated serving configuration with new control
187
"""
188
189
def remove_control(self, request: RemoveControlRequest) -> ServingConfig:
190
"""
191
Removes a control from a serving configuration.
192
193
Args:
194
request: Contains serving config and control resource names
195
196
Returns:
197
ServingConfig: Updated serving configuration without the control
198
"""
199
```
200
201
```python { .api }
202
class ServingConfigServiceAsyncClient:
203
async def create_serving_config(self, request: CreateServingConfigRequest) -> ServingConfig:
204
"""
205
Creates a new serving configuration for search or recommendations.
206
207
Args:
208
request: Contains parent catalog and serving config settings
209
210
Returns:
211
ServingConfig: The created serving configuration
212
"""
213
214
async def get_serving_config(self, request: GetServingConfigRequest) -> ServingConfig:
215
"""
216
Retrieves a serving configuration by its resource name.
217
218
Args:
219
request: Contains serving config resource name
220
221
Returns:
222
ServingConfig: The requested serving configuration
223
"""
224
225
async def list_serving_configs(self, request: ListServingConfigsRequest) -> ListServingConfigsResponse:
226
"""
227
Lists all serving configurations in a catalog.
228
229
Args:
230
request: Contains parent catalog and pagination parameters
231
232
Returns:
233
ListServingConfigsResponse: List of serving configurations
234
"""
235
236
async def update_serving_config(self, request: UpdateServingConfigRequest) -> ServingConfig:
237
"""
238
Updates an existing serving configuration.
239
240
Args:
241
request: Contains serving config updates and field mask
242
243
Returns:
244
ServingConfig: Updated serving configuration
245
"""
246
247
async def delete_serving_config(self, request: DeleteServingConfigRequest) -> None:
248
"""
249
Deletes a serving configuration.
250
251
Args:
252
request: Contains serving config resource name
253
"""
254
255
async def add_control(self, request: AddControlRequest) -> ServingConfig:
256
"""
257
Associates a control with a serving configuration.
258
259
Args:
260
request: Contains serving config and control resource names
261
262
Returns:
263
ServingConfig: Updated serving configuration with new control
264
"""
265
266
async def remove_control(self, request: RemoveControlRequest) -> ServingConfig:
267
"""
268
Removes a control from a serving configuration.
269
270
Args:
271
request: Contains serving config and control resource names
272
273
Returns:
274
ServingConfig: Updated serving configuration without the control
275
"""
276
```
277
278
### Generative AI Features
279
280
Advanced AI-powered features including generative questions and conversational search capabilities.
281
282
```python { .api }
283
class GenerativeQuestionServiceClient:
284
def get_generative_questions_feature_config(self, request: GetGenerativeQuestionsFeatureConfigRequest) -> GenerativeQuestionsFeatureConfig:
285
"""
286
Gets the configuration for generative questions feature.
287
288
Args:
289
request: Contains catalog resource name
290
291
Returns:
292
GenerativeQuestionsFeatureConfig: Current feature configuration
293
"""
294
295
def update_generative_questions_feature_config(self, request: UpdateGenerativeQuestionsFeatureConfigRequest) -> GenerativeQuestionsFeatureConfig:
296
"""
297
Updates the generative questions feature configuration.
298
299
Args:
300
request: Contains config updates and field mask
301
302
Returns:
303
GenerativeQuestionsFeatureConfig: Updated feature configuration
304
"""
305
306
def list_generative_question_configs(self, request: ListGenerativeQuestionConfigsRequest) -> ListGenerativeQuestionConfigsResponse:
307
"""
308
Lists generative question configurations for a catalog.
309
310
Args:
311
request: Contains parent catalog and pagination parameters
312
313
Returns:
314
ListGenerativeQuestionConfigsResponse: List of question configurations
315
"""
316
317
def update_generative_question_config(self, request: UpdateGenerativeQuestionConfigRequest) -> GenerativeQuestionConfig:
318
"""
319
Updates a specific generative question configuration.
320
321
Args:
322
request: Contains question config updates and field mask
323
324
Returns:
325
GenerativeQuestionConfig: Updated question configuration
326
"""
327
328
def batch_update_generative_question_configs(self, request: BatchUpdateGenerativeQuestionConfigsRequest) -> BatchUpdateGenerativeQuestionConfigsResponse:
329
"""
330
Updates multiple generative question configurations in batch.
331
332
Args:
333
request: Contains multiple question config updates
334
335
Returns:
336
BatchUpdateGenerativeQuestionConfigsResponse: Results of batch update
337
"""
338
```
339
340
```python { .api }
341
class GenerativeQuestionServiceAsyncClient:
342
async def get_generative_questions_feature_config(self, request: GetGenerativeQuestionsFeatureConfigRequest) -> GenerativeQuestionsFeatureConfig:
343
"""
344
Gets the configuration for generative questions feature.
345
346
Args:
347
request: Contains catalog resource name
348
349
Returns:
350
GenerativeQuestionsFeatureConfig: Current feature configuration
351
"""
352
353
async def update_generative_questions_feature_config(self, request: UpdateGenerativeQuestionsFeatureConfigRequest) -> GenerativeQuestionsFeatureConfig:
354
"""
355
Updates the generative questions feature configuration.
356
357
Args:
358
request: Contains config updates and field mask
359
360
Returns:
361
GenerativeQuestionsFeatureConfig: Updated feature configuration
362
"""
363
364
async def list_generative_question_configs(self, request: ListGenerativeQuestionConfigsRequest) -> ListGenerativeQuestionConfigsResponse:
365
"""
366
Lists generative question configurations for a catalog.
367
368
Args:
369
request: Contains parent catalog and pagination parameters
370
371
Returns:
372
ListGenerativeQuestionConfigsResponse: List of question configurations
373
"""
374
375
async def update_generative_question_config(self, request: UpdateGenerativeQuestionConfigRequest) -> GenerativeQuestionConfig:
376
"""
377
Updates a specific generative question configuration.
378
379
Args:
380
request: Contains question config updates and field mask
381
382
Returns:
383
GenerativeQuestionConfig: Updated question configuration
384
"""
385
386
async def batch_update_generative_question_configs(self, request: BatchUpdateGenerativeQuestionConfigsRequest) -> BatchUpdateGenerativeQuestionConfigsResponse:
387
"""
388
Updates multiple generative question configurations in batch.
389
390
Args:
391
request: Contains multiple question config updates
392
393
Returns:
394
BatchUpdateGenerativeQuestionConfigsResponse: Results of batch update
395
"""
396
```
397
398
## Data Types
399
400
### Control Configuration
401
402
Business rules and control mechanisms for search and recommendation behavior.
403
404
```python { .api }
405
class Control:
406
name: str # Control resource name (read-only)
407
display_name: str # Human-readable control name
408
associated_serving_config_ids: List[str] # Serving configs using this control (read-only)
409
solution_types: List[SolutionType] # Applicable solution types
410
search_solution_use_case: List[SearchSolutionUseCase] # Search use cases
411
412
# Control rule specifications (one of the following)
413
facet_spec: SearchRequestFacetSpec # Faceting control
414
rule: Rule # Business rule control
415
416
class Rule:
417
boost_action: RuleBoostAction # Boost certain products
418
redirect_action: RuleRedirectAction # Redirect user to specific URL
419
oneway_synonyms_action: RuleOnewaySynonymsAction # Add one-way synonyms
420
do_not_associate_action: RuleDoNotAssociateAction # Prevent associations
421
replacement_action: RuleReplacementAction # Replace query terms
422
ignore_action: RuleIgnoreAction # Ignore certain terms
423
filter_action: RuleFilterAction # Apply additional filtering
424
twoway_synonyms_action: RuleTwowaySynonymsAction # Add bidirectional synonyms
425
force_return_facet_action: RuleForceReturnFacetAction # Force facet return
426
remove_facet_action: RuleRemoveFacetAction # Remove facets
427
428
condition: Condition # When to apply this rule
429
430
class Condition:
431
query_terms: List[ConditionQueryTerm] # Query-based conditions
432
active_time_range: List[ConditionTimeRange] # Time-based conditions
433
page_categories: List[str] # Page category conditions
434
435
# Control rule actions
436
class RuleBoostAction:
437
boost: float # Boost multiplier
438
products_filter: str # Filter for products to boost
439
440
class RuleRedirectAction:
441
redirect_uri: str # URL to redirect to
442
443
class RuleFilterAction:
444
filter: str # Additional filter to apply
445
446
class RuleOnewaySynonymsAction:
447
query_terms: List[str] # Query terms
448
synonyms: List[str] # One-way synonyms for the terms
449
450
class RuleTwowaySynonymsAction:
451
synonyms: List[str] # Bidirectional synonyms
452
```
453
454
### Serving Configuration
455
456
Configuration for how search and recommendations are served to users.
457
458
```python { .api }
459
class ServingConfig:
460
name: str # Serving config resource name (read-only)
461
display_name: str # Human-readable name
462
model_id: str # Associated model ID for recommendations
463
price_reranking_level: str # Price reranking level (NO_PRICE_RERANKING, LOW, MEDIUM, HIGH)
464
facet_control_ids: List[str] # Applied facet control IDs
465
dynamic_facet_spec: SearchRequestDynamicFacetSpec # Dynamic faceting configuration
466
boost_control_ids: List[str] # Applied boost control IDs
467
filter_control_ids: List[str] # Applied filter control IDs
468
redirect_control_ids: List[str] # Applied redirect control IDs
469
twoway_synonyms_control_ids: List[str] # Applied synonym control IDs
470
oneway_synonyms_control_ids: List[str] # Applied one-way synonym control IDs
471
do_not_associate_control_ids: List[str] # Applied dissociation control IDs
472
replacement_control_ids: List[str] # Applied replacement control IDs
473
ignore_control_ids: List[str] # Applied ignore control IDs
474
diversity_level: str # Result diversity level
475
diversity_type: str # Type of diversity to apply
476
enable_category_filter_level: str # Category filtering level
477
personalization_spec: SearchRequestPersonalizationSpec # Personalization settings
478
solution_types: List[SolutionType] # Applicable solution types
479
```
480
481
### Generative AI Configuration
482
483
Settings for AI-powered generative features and question generation.
484
485
```python { .api }
486
class GenerativeQuestionsFeatureConfig:
487
catalog: str # Catalog resource name (read-only)
488
feature_enabled: bool # Whether generative questions are enabled
489
minimum_products: int # Minimum products required for question generation
490
491
class GenerativeQuestionConfig:
492
catalog: str # Catalog resource name (read-only)
493
facet: str # Facet for which questions are generated
494
generated_question: str # AI-generated question text
495
final_question: str # Final question after human review
496
example_values: List[str] # Example values for the question
497
frequency: float # Question frequency/importance score
498
allowed_in_conversation: bool # Whether question can be used in conversation
499
```
500
501
### Request Types
502
503
Request configurations for advanced feature management operations.
504
505
```python { .api }
506
class CreateControlRequest:
507
parent: str # Catalog resource name (required)
508
control: Control # Control configuration (required)
509
control_id: str # Control ID (required)
510
511
class GetControlRequest:
512
name: str # Control resource name (required)
513
514
class ListControlsRequest:
515
parent: str # Catalog resource name (required)
516
page_size: int # Maximum controls to return
517
page_token: str # Token for pagination
518
filter: str # Filter expression
519
520
class UpdateControlRequest:
521
control: Control # Control with updates (required)
522
update_mask: FieldMask # Fields to update
523
524
class DeleteControlRequest:
525
name: str # Control resource name (required)
526
527
class CreateServingConfigRequest:
528
parent: str # Catalog resource name (required)
529
serving_config: ServingConfig # Serving config (required)
530
serving_config_id: str # Serving config ID (required)
531
532
class AddControlRequest:
533
serving_config: str # Serving config resource name (required)
534
control_id: str # Control ID to add (required)
535
536
class RemoveControlRequest:
537
serving_config: str # Serving config resource name (required)
538
control_id: str # Control ID to remove (required)
539
540
class UpdateGenerativeQuestionConfigRequest:
541
generative_question_config: GenerativeQuestionConfig # Config with updates (required)
542
update_mask: FieldMask # Fields to update
543
544
class BatchUpdateGenerativeQuestionConfigsRequest:
545
parent: str # Catalog resource name (required)
546
requests: List[UpdateGenerativeQuestionConfigRequest] # Batch of updates
547
```
548
549
## Usage Examples
550
551
### Creating Business Rules with Controls
552
553
```python
554
from google.cloud import retail
555
556
control_client = retail.ControlServiceClient()
557
558
# Create a boost control to promote featured products
559
boost_rule = retail.Rule(
560
boost_action=retail.Rule.BoostAction(
561
boost=2.0, # Double the relevance score
562
products_filter='(tags: ANY("featured"))'
563
),
564
condition=retail.Condition(
565
query_terms=[
566
retail.Condition.QueryTerm(
567
value="laptop",
568
full_match=False
569
)
570
]
571
)
572
)
573
574
boost_control = retail.Control(
575
display_name="Featured Laptop Boost",
576
rule=boost_rule,
577
solution_types=[retail.SolutionType.SOLUTION_TYPE_SEARCH]
578
)
579
580
request = retail.CreateControlRequest(
581
parent="projects/my-project/locations/global/catalogs/default_catalog",
582
control=boost_control,
583
control_id="featured-laptop-boost"
584
)
585
586
created_control = control_client.create_control(request=request)
587
print(f"Created boost control: {created_control.name}")
588
589
# Create a filter control to exclude out-of-stock items
590
filter_rule = retail.Rule(
591
filter_action=retail.Rule.FilterAction(
592
filter='(availability: "IN_STOCK")'
593
),
594
condition=retail.Condition() # Apply to all queries
595
)
596
597
filter_control = retail.Control(
598
display_name="Hide Out of Stock",
599
rule=filter_rule,
600
solution_types=[
601
retail.SolutionType.SOLUTION_TYPE_SEARCH,
602
retail.SolutionType.SOLUTION_TYPE_RECOMMENDATION
603
]
604
)
605
606
request = retail.CreateControlRequest(
607
parent="projects/my-project/locations/global/catalogs/default_catalog",
608
control=filter_control,
609
control_id="hide-out-of-stock"
610
)
611
612
filter_control = control_client.create_control(request=request)
613
print(f"Created filter control: {filter_control.name}")
614
```
615
616
### Creating Serving Configurations
617
618
```python
619
serving_client = retail.ServingConfigServiceClient()
620
621
# Create a serving configuration for product search
622
search_serving_config = retail.ServingConfig(
623
display_name="Product Search Configuration",
624
price_reranking_level="MEDIUM",
625
diversity_level="MEDIUM",
626
diversity_type="RULE_BASED_DIVERSITY",
627
enable_category_filter_level="DISABLED",
628
personalization_spec=retail.SearchRequest.PersonalizationSpec(
629
mode=retail.SearchRequest.PersonalizationSpec.Mode.AUTO
630
),
631
solution_types=[retail.SolutionType.SOLUTION_TYPE_SEARCH]
632
)
633
634
request = retail.CreateServingConfigRequest(
635
parent="projects/my-project/locations/global/catalogs/default_catalog",
636
serving_config=search_serving_config,
637
serving_config_id="product-search-config"
638
)
639
640
created_config = serving_client.create_serving_config(request=request)
641
print(f"Created serving config: {created_config.name}")
642
643
# Add controls to the serving configuration
644
add_boost_request = retail.AddControlRequest(
645
serving_config=created_config.name,
646
control_id="featured-laptop-boost"
647
)
648
649
updated_config = serving_client.add_control(request=add_boost_request)
650
651
add_filter_request = retail.AddControlRequest(
652
serving_config=updated_config.name,
653
control_id="hide-out-of-stock"
654
)
655
656
final_config = serving_client.add_control(request=add_filter_request)
657
print(f"Added controls to serving config")
658
print(f"Boost controls: {final_config.boost_control_ids}")
659
print(f"Filter controls: {final_config.filter_control_ids}")
660
```
661
662
### Advanced Control Rules
663
664
```python
665
# Create a synonym control for better search matching
666
synonym_rule = retail.Rule(
667
twoway_synonyms_action=retail.Rule.TwowaySynonymsAction(
668
synonyms=["laptop", "notebook", "portable computer"]
669
),
670
condition=retail.Condition() # Apply to all queries
671
)
672
673
synonym_control = retail.Control(
674
display_name="Laptop Synonyms",
675
rule=synonym_rule,
676
solution_types=[retail.SolutionType.SOLUTION_TYPE_SEARCH]
677
)
678
679
request = retail.CreateControlRequest(
680
parent="projects/my-project/locations/global/catalogs/default_catalog",
681
control=synonym_control,
682
control_id="laptop-synonyms"
683
)
684
685
synonym_control = control_client.create_control(request=request)
686
687
# Create a redirect control for brand searches
688
redirect_rule = retail.Rule(
689
redirect_action=retail.Rule.RedirectAction(
690
redirect_uri="https://example.com/brands/apple"
691
),
692
condition=retail.Condition(
693
query_terms=[
694
retail.Condition.QueryTerm(
695
value="apple",
696
full_match=True
697
)
698
]
699
)
700
)
701
702
redirect_control = retail.Control(
703
display_name="Apple Brand Redirect",
704
rule=redirect_rule,
705
solution_types=[retail.SolutionType.SOLUTION_TYPE_SEARCH]
706
)
707
708
request = retail.CreateControlRequest(
709
parent="projects/my-project/locations/global/catalogs/default_catalog",
710
control=redirect_control,
711
control_id="apple-redirect"
712
)
713
714
redirect_control = control_client.create_control(request=request)
715
print("Created synonym and redirect controls")
716
```
717
718
### Time-Based Control Rules
719
720
```python
721
# Create a seasonal promotion control
722
from google.protobuf.timestamp_pb2 import Timestamp
723
import datetime
724
725
# Define holiday promotion period
726
start_time = Timestamp()
727
start_time.FromDatetime(datetime.datetime(2024, 11, 20)) # Black Friday season
728
end_time = Timestamp()
729
end_time.FromDatetime(datetime.datetime(2024, 12, 31)) # End of year
730
731
holiday_boost_rule = retail.Rule(
732
boost_action=retail.Rule.BoostAction(
733
boost=1.5,
734
products_filter='(tags: ANY("holiday_sale"))'
735
),
736
condition=retail.Condition(
737
active_time_range=[
738
retail.Condition.TimeRange(
739
start_time=start_time,
740
end_time=end_time
741
)
742
]
743
)
744
)
745
746
holiday_control = retail.Control(
747
display_name="Holiday Sale Boost",
748
rule=holiday_boost_rule,
749
solution_types=[retail.SolutionType.SOLUTION_TYPE_SEARCH]
750
)
751
752
request = retail.CreateControlRequest(
753
parent="projects/my-project/locations/global/catalogs/default_catalog",
754
control=holiday_control,
755
control_id="holiday-boost"
756
)
757
758
holiday_control = control_client.create_control(request=request)
759
print("Created time-based holiday promotion control")
760
```
761
762
### Generative AI Question Configuration
763
764
```python
765
question_client = retail.GenerativeQuestionServiceClient()
766
767
# Get current generative questions feature configuration
768
request = retail.GetGenerativeQuestionsFeatureConfigRequest(
769
catalog="projects/my-project/locations/global/catalogs/default_catalog"
770
)
771
772
feature_config = question_client.get_generative_questions_feature_config(request=request)
773
print(f"Generative questions enabled: {feature_config.feature_enabled}")
774
print(f"Minimum products required: {feature_config.minimum_products}")
775
776
# Enable generative questions feature
777
if not feature_config.feature_enabled:
778
updated_config = retail.GenerativeQuestionsFeatureConfig(
779
catalog=feature_config.catalog,
780
feature_enabled=True,
781
minimum_products=10 # Require at least 10 products for question generation
782
)
783
784
request = retail.UpdateGenerativeQuestionsFeatureConfigRequest(
785
generative_questions_feature_config=updated_config,
786
update_mask=field_mask_pb2.FieldMask(paths=["feature_enabled", "minimum_products"])
787
)
788
789
updated = question_client.update_generative_questions_feature_config(request=request)
790
print("Enabled generative questions feature")
791
792
# List existing generative question configurations
793
request = retail.ListGenerativeQuestionConfigsRequest(
794
parent="projects/my-project/locations/global/catalogs/default_catalog"
795
)
796
797
response = question_client.list_generative_question_configs(request=request)
798
799
print("Existing generative question configurations:")
800
for config in response.generative_question_configs:
801
print(f"- Facet: {config.facet}")
802
print(f" Generated question: {config.generated_question}")
803
print(f" Final question: {config.final_question}")
804
print(f" Frequency: {config.frequency}")
805
print(f" Allowed in conversation: {config.allowed_in_conversation}")
806
```
807
808
### Managing Control Lifecycle
809
810
```python
811
# List all controls to see what's available
812
request = retail.ListControlsRequest(
813
parent="projects/my-project/locations/global/catalogs/default_catalog",
814
page_size=50
815
)
816
817
response = control_client.list_controls(request=request)
818
819
print("Available controls:")
820
for control in response.controls:
821
print(f"- {control.display_name} ({control.name})")
822
print(f" Solution types: {control.solution_types}")
823
print(f" Associated serving configs: {len(control.associated_serving_config_ids)}")
824
825
# Update an existing control
826
existing_control = response.controls[0] # Get first control
827
existing_control.display_name = f"{existing_control.display_name} (Updated)"
828
829
request = retail.UpdateControlRequest(
830
control=existing_control,
831
update_mask=field_mask_pb2.FieldMask(paths=["display_name"])
832
)
833
834
updated_control = control_client.update_control(request=request)
835
print(f"Updated control display name: {updated_control.display_name}")
836
837
# Remove a control from serving configuration (if needed)
838
serving_configs = serving_client.list_serving_configs(
839
request=retail.ListServingConfigsRequest(
840
parent="projects/my-project/locations/global/catalogs/default_catalog"
841
)
842
)
843
844
if serving_configs.serving_configs:
845
serving_config = serving_configs.serving_configs[0]
846
if serving_config.boost_control_ids:
847
remove_request = retail.RemoveControlRequest(
848
serving_config=serving_config.name,
849
control_id=serving_config.boost_control_ids[0]
850
)
851
852
updated_serving = serving_client.remove_control(request=remove_request)
853
print(f"Removed control from serving config")
854
```