azure_search_rs 0.3.3

Azure AI Search client library for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::{
    client::AzureSearchClient,
    error::Result,
    models::{
        search::{SearchRequest, SearchResponse, VectorKind},
        QueryType,
    },
};

pub trait SearchTrait {
    /// Execute a search query against an index
    fn search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        request: &SearchRequest,
    ) -> impl std::future::Future<Output = Result<SearchResponse<T>>> + Send;

    /// Execute a vector search query
    fn vector_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        vector_queries: Vec<VectorKind>,
    ) -> impl std::future::Future<Output = Result<SearchResponse<T>>> + Send;

    /// Execute a semantic search query (optionally with vector search)
    fn semantic_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        query: &str,
        semantic_configuration: &str,
        vector_queries: Option<Vec<VectorKind>>,
    ) -> impl std::future::Future<Output = Result<SearchResponse<T>>> + Send;

    /// Execute a hybrid search combining semantic and vector search
    fn hybrid_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        query: &str,
        semantic_configuration: &str,
        vector_queries: Vec<VectorKind>,
    ) -> impl std::future::Future<Output = Result<SearchResponse<T>>> + Send;
}

impl SearchTrait for AzureSearchClient {
    /// Execute a search query against an index
    async fn search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        request: &SearchRequest,
    ) -> Result<SearchResponse<T>> {
        let path = format!("indexes/{}/docs/search", index_name);
        self.send_request::<SearchResponse<T>, SearchRequest>(
            reqwest::Method::POST,
            &path,
            Some(request),
        )
        .await
    }

    /// Execute a vector search query
    async fn vector_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        vector_queries: Vec<VectorKind>,
    ) -> Result<SearchResponse<T>> {
        let request = SearchRequest {
            vector_queries: Some(vector_queries),
            ..Default::default()
        };
        self.search(index_name, &request).await
    }

    /// Execute a semantic search query (optionally with vector search)
    async fn semantic_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        query: &str,
        semantic_configuration: &str,
        vector_queries: Option<Vec<VectorKind>>,
    ) -> Result<SearchResponse<T>> {
        let request = SearchRequest {
            search: Some(query.to_string()),
            semantic_configuration: Some(semantic_configuration.to_string()),
            vector_queries,
            query_type: Some(QueryType::Semantic),
            ..Default::default()
        };
        self.search(index_name, &request).await
    }

    /// Execute a hybrid search combining semantic and vector search
    async fn hybrid_search<T: serde::de::DeserializeOwned>(
        &self,
        index_name: &str,
        query: &str,
        semantic_configuration: &str,
        vector_queries: Vec<VectorKind>,
    ) -> Result<SearchResponse<T>> {
        self.semantic_search(
            index_name,
            query,
            semantic_configuration,
            Some(vector_queries),
        )
        .await
    }
}