0
# Monitoring and Management
1

2
Service health monitoring, infrastructure metrics, operational management tools, and personalization services for maintaining optimal search performance and user experience.
3

4
## Capabilities
5

6
### Monitoring Client
7

8
Monitor service health and infrastructure performance.
9

10
```python { .api }
11
class MonitoringClient:
12
    def __init__(
13
        self,
14
        app_id: Optional[str] = None, 
15
        api_key: Optional[str] = None,
16
        transporter: Optional[Transporter] = None,
17
        config: Optional[MonitoringConfig] = None
18
    ) -> None: ...
19

20
    async def close(self) -> None: ...
21
    async def set_client_api_key(self, api_key: str) -> None: ...
22
```
23

24
### Infrastructure Monitoring
25

26
Monitor cluster status, server health, and performance metrics.
27

28
```python { .api }
29
async def get_cluster_status(
30
    self,
31
    request_options: Optional[Union[dict, RequestOptions]] = None
32
) -> ClusterStatus:
33
    """
34
    Get current cluster health and status.
35
    
36
    Returns:
37
    ClusterStatus with health information
38
    """
39

40
async def get_infrastructure_metrics(
41
    self,
42
    metric: str,
43
    start_date: str,
44
    end_date: str,
45
    request_options: Optional[Union[dict, RequestOptions]] = None  
46
) -> InfrastructureMetrics:
47
    """
48
    Get infrastructure performance metrics.
49
    
50
    Parameters:
51
    - metric: Metric type to retrieve
52
    - start_date: Start date (YYYY-MM-DD format)
53
    - end_date: End date (YYYY-MM-DD format)
54
    - request_options: Additional request options
55
    
56
    Returns:
57
    InfrastructureMetrics with performance data
58
    """
59

60
async def get_servers(
61
    self,
62
    request_options: Optional[Union[dict, RequestOptions]] = None
63
) -> ServersResponse:
64
    """
65
    Get list of available servers and their status.
66
    
67
    Returns:
68
    ServersResponse with server information
69
    """
70
```
71

72
### Personalization Client
73

74
Manage search personalization and user experience optimization.
75

76
```python { .api }
77
class PersonalizationClient:
78
    def __init__(
79
        self,
80
        app_id: Optional[str] = None,
81
        api_key: Optional[str] = None,
82
        transporter: Optional[Transporter] = None,
83
        config: Optional[PersonalizationConfig] = None
84
    ) -> None: ...
85

86
    async def close(self) -> None: ...
87
    async def set_client_api_key(self, api_key: str) -> None: ...
88
```
89

90
### Personalization Strategy
91

92
Configure and manage personalization strategies for enhanced user experience.
93

94
```python { .api }
95
async def get_personalization_strategy(
96
    self,
97
    request_options: Optional[Union[dict, RequestOptions]] = None
98
) -> PersonalizationStrategy:
99
    """
100
    Get current personalization strategy configuration.
101
    
102
    Returns:
103
    PersonalizationStrategy with current settings
104
    """
105

106
async def set_personalization_strategy(
107
    self,
108
    personalization_strategy_params: Union[PersonalizationStrategyParams, dict],
109
    request_options: Optional[Union[dict, RequestOptions]] = None
110
) -> SetPersonalizationStrategyResponse:
111
    """
112
    Configure personalization strategy settings.
113
    
114
    Parameters:
115
    - personalization_strategy_params: Strategy configuration
116
    - request_options: Additional request options
117
    
118
    Returns:
119
    SetPersonalizationStrategyResponse with update confirmation
120
    """
121

122
async def delete_user_profile(
123
    self,
124
    user_token: str,
125
    request_options: Optional[Union[dict, RequestOptions]] = None
126
) -> dict:
127
    """
128
    Delete a user's personalization profile.
129
    
130
    Parameters:
131
    - user_token: Unique user identifier
132
    - request_options: Additional request options
133
    
134
    Returns:
135
    Deletion confirmation response
136
    """
137

138
async def get_user_token_profile(
139
    self,
140
    user_token: str,
141
    request_options: Optional[Union[dict, RequestOptions]] = None
142
) -> GetUserTokenProfileResponse:
143
    """
144
    Get personalization profile for a specific user.
145
    
146
    Parameters:
147
    - user_token: Unique user identifier
148
    - request_options: Additional request options
149
    
150
    Returns:
151
    GetUserTokenProfileResponse with user profile data
152
    """
153
```
154

155
### Composition Client
156

157
Manage search compositions for advanced query orchestration.
158

159
```python { .api }
160
class CompositionClient:
161
    def __init__(
162
        self,
163
        app_id: Optional[str] = None,
164
        api_key: Optional[str] = None,
165
        transporter: Optional[Transporter] = None,
166
        config: Optional[CompositionConfig] = None
167
    ) -> None: ...
168

169
    async def close(self) -> None: ...
170
    async def set_client_api_key(self, api_key: str) -> None: ...
171
```
172

173
### Composition Operations
174

175
Execute complex search operations across multiple indices and sources.
176

177
```python { .api }
178
async def search(
179
    self,
180
    composition_id: str,
181
    request_body: Union[RequestBody, dict],
182
    request_options: Optional[Union[dict, RequestOptions]] = None
183
) -> SearchResponse:
184
    """
185
    Execute search on a composition.
186
    
187
    Parameters:
188
    - composition_id: Unique composition identifier
189
    - request_body: Search request body
190
    - request_options: Additional request options
191
    
192
    Returns:
193
    SearchResponse with composition search results
194
    """
195

196
async def search_for_facet_values(
197
    self,
198
    composition_id: str,
199
    facet_name: str,
200
    search_for_facet_values_request: Optional[Union[SearchForFacetValuesRequest, dict]] = None,
201
    request_options: Optional[Union[dict, RequestOptions]] = None
202
) -> SearchForFacetValuesResponse:
203
    """
204
    Search for facet values within a composition.
205
    
206
    Parameters:
207
    - composition_id: Unique composition identifier
208
    - facet_name: Facet attribute name
209
    - search_for_facet_values_request: Facet search parameters
210
    - request_options: Additional request options
211
    
212
    Returns:
213
    SearchForFacetValuesResponse with facet values
214
    """
215
```
216

217
## Usage Examples
218

219
### Monitor Infrastructure
220

221
```python
222
from algoliasearch.monitoring.client import MonitoringClient
223

224
# Initialize client
225
client = MonitoringClient("YOUR_APP_ID", "YOUR_API_KEY")
226

227
# Check cluster status
228
status = await client.get_cluster_status()
229
print(f"Cluster status: {status.status}")
230
print(f"Last update: {status.last_update_timestamp}")
231

232
# Get infrastructure metrics
233
metrics = await client.get_infrastructure_metrics(
234
    metric="cpu_usage",
235
    start_date="2024-01-01",
236
    end_date="2024-01-31"
237
)
238
```
239

240
### Configure Personalization
241

242
```python
243
from algoliasearch.personalization.client import PersonalizationClient
244

245
# Initialize client
246
client = PersonalizationClient("YOUR_APP_ID", "YOUR_API_KEY")
247

248
# Set personalization strategy
249
strategy_response = await client.set_personalization_strategy({
250
    "eventsScoring": [
251
        {
252
            "eventName": "Add to cart",
253
            "eventType": "conversion", 
254
            "score": 50
255
        },
256
        {
257
            "eventName": "Purchase",
258
            "eventType": "conversion",
259
            "score": 100
260
        }
261
    ],
262
    "facetsScoring": [
263
        {
264
            "facetName": "brand",
265
            "score": 100
266
        },
267
        {
268
            "facetName": "category", 
269
            "score": 10
270
        }
271
    ],
272
    "personalizationImpact": 95
273
})
274

275
print(f"Strategy updated at: {strategy_response.updated_at}")
276
```
277

278
## Types
279

280
```python { .api }
281
# Monitoring types
282
class ClusterStatus(BaseModel):
283
    status: str
284
    last_update_timestamp: str
285
    degraded: bool
286

287
class InfrastructureMetrics(BaseModel):
288
    metric_name: str
289
    data_points: List[dict]
290
    start_date: str
291
    end_date: str
292

293
class ServersResponse(BaseModel):
294
    servers: List[dict]
295

296
# Personalization types  
297
class PersonalizationStrategy(BaseModel):
298
    events_scoring: List[EventScoring]
299
    facets_scoring: List[FacetScoring]
300
    personalization_impact: int
301

302
class EventScoring(BaseModel):
303
    event_name: str
304
    event_type: str
305
    score: int
306

307
class FacetScoring(BaseModel):
308
    facet_name: str
309
    score: int
310

311
class PersonalizationStrategyParams(BaseModel):
312
    events_scoring: Optional[List[EventScoring]] = None
313
    facets_scoring: Optional[List[FacetScoring]] = None
314
    personalization_impact: Optional[int] = None
315

316
class SetPersonalizationStrategyResponse(BaseModel):
317
    status: int
318
    updated_at: str
319

320
class GetUserTokenProfileResponse(BaseModel):
321
    user_token: str
322
    last_event_at: str
323
    scores: Optional[dict] = None
324

325
# Composition types
326
class RequestBody(BaseModel):
327
    query: Optional[str] = None
328
    params: Optional[dict] = None
329

330
class SearchResponse(BaseModel):
331
    hits: List[dict]
332
    nb_hits: int
333
    processing_time_ms: int
334
    query: str
335
```