0
# Query Suggestions
1

2
Intelligent query completion and suggestion services that help users discover relevant search terms and improve search experience. Build autocomplete functionality and query enhancement features.
3

4
## Capabilities
5

6
### Query Suggestions Client
7

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

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

22
### Configuration Management
23

24
Manage query suggestion configurations and settings.
25

26
```python { .api }
27
async def list_configs(
28
    self,
29
    request_options: Optional[Union[dict, RequestOptions]] = None
30
) -> ListConfigsResponse:
31
    """
32
    List all query suggestion configurations.
33
    
34
    Returns:
35
    ListConfigsResponse with all configurations
36
    """
37

38
async def create_config(
39
    self,
40
    configuration_with_index: Union[ConfigurationWithIndex, dict],
41
    request_options: Optional[Union[dict, RequestOptions]] = None
42
) -> BaseResponse:
43
    """
44
    Create a new query suggestion configuration.
45
    
46
    Parameters:
47
    - configuration_with_index: Configuration settings with target index
48
    - request_options: Additional request options
49
    
50
    Returns:
51
    BaseResponse with creation confirmation
52
    """
53

54
async def get_config(
55
    self,
56
    index_name: str,
57
    request_options: Optional[Union[dict, RequestOptions]] = None
58
) -> Configuration:
59
    """
60
    Get query suggestion configuration for an index.
61
    
62
    Parameters:
63
    - index_name: Target index name
64
    - request_options: Additional request options
65
    
66
    Returns:
67
    Configuration object with current settings
68
    """
69

70
async def update_config(
71
    self,
72
    index_name: str,
73
    configuration: Union[Configuration, dict],
74
    request_options: Optional[Union[dict, RequestOptions]] = None
75
) -> BaseResponse:
76
    """
77
    Update query suggestion configuration.
78
    
79
    Parameters:
80
    - index_name: Target index name
81
    - configuration: Updated configuration settings
82
    - request_options: Additional request options
83
    
84
    Returns:
85
    BaseResponse with update confirmation
86
    """
87

88
async def delete_config(
89
    self,
90
    index_name: str,
91
    request_options: Optional[Union[dict, RequestOptions]] = None
92
) -> BaseResponse:
93
    """
94
    Delete query suggestion configuration.
95
    
96
    Parameters:
97
    - index_name: Target index name
98
    - request_options: Additional request options
99
    
100
    Returns:
101
    BaseResponse with deletion confirmation
102
    """
103
```
104

105
### Status and Logs
106

107
Monitor query suggestion operations and troubleshoot issues.
108

109
```python { .api }
110
async def get_config_status(
111
    self,
112
    index_name: str,
113
    request_options: Optional[Union[dict, RequestOptions]] = None
114
) -> GetConfigStatusResponse:
115
    """
116
    Get status of query suggestion configuration.
117
    
118
    Parameters:
119
    - index_name: Target index name
120
    - request_options: Additional request options
121
    
122
    Returns:
123
    GetConfigStatusResponse with current status
124
    """
125

126
async def get_log_file(
127
    self,
128
    index_name: str,
129
    request_options: Optional[Union[dict, RequestOptions]] = None
130
) -> LogFile:
131
    """
132
    Get log file for query suggestion operations.
133
    
134
    Parameters:
135
    - index_name: Target index name
136
    - request_options: Additional request options
137
    
138
    Returns:
139
    LogFile with operation logs
140
    """
141
```
142

143
## Usage Example
144

145
```python
146
from algoliasearch.query_suggestions.client import QuerySuggestionsClient
147

148
# Initialize client
149
client = QuerySuggestionsClient("YOUR_APP_ID", "YOUR_API_KEY")
150

151
# Create query suggestions configuration
152
config_response = await client.create_config({
153
    "indexName": "query_suggestions_index",
154
    "sourceIndices": [
155
        {
156
            "indexName": "products", 
157
            "facets": [
158
                {"attribute": "category", "amount": 5},
159
                {"attribute": "brand", "amount": 3}
160
            ],
161
            "minHits": 5,
162
            "minLetters": 2
163
        }
164
    ],
165
    "languages": ["en", "fr"],
166
    "exclude": ["admin", "test"]
167
})
168

169
# Check configuration status
170
status = await client.get_config_status("query_suggestions_index")
171
print(f"Configuration status: {status.index_status}")
172

173
# Get current configuration
174
config = await client.get_config("query_suggestions_index")
175
print(f"Languages: {config.languages}")
176
print(f"Source indices: {len(config.source_indices)}")
177
```
178

179
## Types
180

181
```python { .api }
182
# Configuration types
183
class ConfigurationWithIndex(BaseModel):
184
    index_name: str
185
    source_indices: List[SourceIndex]
186
    languages: List[str]
187
    exclude: Optional[List[str]] = None
188

189
class Configuration(BaseModel):
190
    source_indices: List[SourceIndex]
191
    languages: List[str]
192
    exclude: Optional[List[str]] = None
193

194
class SourceIndex(BaseModel):
195
    index_name: str
196
    facets: Optional[List[Facet]] = None
197
    min_hits: Optional[int] = None
198
    min_letters: Optional[int] = None
199
    generate: Optional[List[List[str]]] = None
200

201
class Facet(BaseModel):
202
    attribute: str
203
    amount: Optional[int] = None
204

205
# Response types
206
class ListConfigsResponse(BaseModel):
207
    configs: List[dict]
208

209
class GetConfigStatusResponse(BaseModel):
210
    index_name: str
211
    index_status: str
212
    last_build_time_s: Optional[int] = None
213
    last_successful_build_started_at: Optional[str] = None
214

215
class BaseResponse(BaseModel):
216
    status: int
217
    message: str
218

219
class LogFile(BaseModel):
220
    content: str
221
    timestamp: str
222
```
223

224
## Query Suggestion Features
225

226
Query suggestions help improve search experience through:
227

228
- **Autocomplete**: Real-time query completion as users type
229
- **Popular Suggestions**: Based on frequently searched terms
230
- **Facet-based Suggestions**: Suggest queries including popular facet values
231
- **Multi-language Support**: Suggestions in multiple languages
232
- **Custom Exclusions**: Filter out unwanted suggestion terms
233
- **Analytics Integration**: Track suggestion performance and usage