Struct CreateIndexRequest 

pub struct CreateIndexRequest {

    pub index_name: String,
    pub schema: Vec<SchemaField>,
    pub similarity: LexicalSimilarity,
    pub tokenizer: TokenizerType,
    pub stemmer: StemmerType,
    pub stop_words: StopwordType,
    pub frequent_words: FrequentwordType,
    pub ngram_indexing: u8,
    pub document_compression: DocumentCompression,
    pub synonyms: Vec<Synonym>,
    pub spelling_correction: Option<SpellingCorrection>,
    pub query_completion: Option<QueryCompletion>,
    pub clustering: Clustering,
    pub inference: Inference,
}

Create index request object

Fields

index_name: String

Index name, used for informational purposes only.

schema: Vec<SchemaField>

Schema definition for the index: field name, field type, and indexing options. The schema defines how documents are indexed and searched. It specifies the fields that are indexed, stored, and used for faceting, as well as the field types and their properties. It also defines whether lexical, hybrid, or vector search is enabled for each field.

similarity: LexicalSimilarity

Specify similarity measure for the index: (default=Bm25fProximity). The similarity function is used to calculate the relevance score of search results for a given search query. The choice of similarity function can affect search performance and relevance, depending on the characteristics of the text being indexed and the search queries being executed.

tokenizer: TokenizerType

Specify tokenizer type for the index: (default=UnicodeAlphanumeric). The tokenizer is used to split text into tokens for indexing and searching. The choice of tokenizer can affect search performance and relevance, depending on the language and characteristics of the text being indexed.

stemmer: StemmerType

Specify stemmer

stop_words: StopwordType

Specify stop words for the index. Stop words are not indexed and not searched for. This can be used to reduce index size and improve search performance by excluding high-frequency, low-information terms from the index.

frequent_words: FrequentwordType

Specify frequent words for the index. Frequent words are used to optimize search performance for high-frequency terms.

ngram_indexing: u8

Specify n-gram indexing for the index. N-gram indexing can improve search performance for certain types of queries. The n-gram set is defined as a bitwise combination of the following values:

• NgramSet::SingleTerm = 0b00000000,,
• NgramSet::NgramFF = 0b00000001, (Ngram frequent frequent)
• NgramSet::NgramFR = 0b00000010, (Ngram frequent rare)
• NgramSet::NgramRF = 0b00000011, (Ngram rare frequent)
• NgramSet::NgramFFF = 0b00000100, (Ngram frequent frequent frequent)
• NgramSet::NgramRFF = 0b00000101, (Ngram rare frequent frequent)
• NgramSet::NgramFFR = 0b00000110, (Ngram frequent frequent rare)
• NgramSet::NgramFRF = 0b00000111, (Ngram frequent rare frequent)

For example, to enable both NgramFF and NgramFFF, set ngram_indexing to 5 (1 | 4). Note: enabling n-gram indexing (ngram_indexing>0) will increase index size and indexing time, but improves search performance of phrase queries with frequent terms.

document_compression: DocumentCompression

Enable document compression for the index. This can reduce the index size on disk and in memory, but may increase indexing and search latency. Default: Snappy compression.

synonyms: Vec<Synonym>

Specify synonyms for the index. Synonyms are used to expand search queries with additional terms that have the same or similar meaning, improving recall and search relevance. The multiway option specifies whether the synonym relationship is multiway (if true, all terms in the synonym set are considered synonyms of each other) or one-way (if false, only the first term in the synonym set is considered the main term, and the other terms are considered synonyms of the main term).

spelling_correction: Option<SpellingCorrection>

Enable spelling correction for search queries using the SymSpell algorithm. When enabled, a SymSpell dictionary is incrementally created during indexing of documents and stored in the index. In addition you need to set the parameter query_rewriting in the search method to enable it per query. The creation of an individual dictionary derived from the indexed documents improves the correction quality compared to a generic dictionary. An dictionary per index improves the privacy compared to a global dictionary derived from all indices. The dictionary is deleted when delete_index or clear_index is called. Note: enabling spelling correction increases the index size, indexing time and query latency. Default: None. Enable by setting a value for max_dictionary_edit_distance (1..2 recommended). The higher the value, the higher the number of errors that can be corrected - but also the memory consumption, lookup latency, and the number of false positives.

query_completion: Option<QueryCompletion>

Enable query completion for search queries using a prefix dictionary. When enabled, a prefix dictionary is incrementally created during indexing of documents and stored in the index. The prefix dictionary is used to generate suggestions for query completion based on the indexed documents. In addition you need to set the parameter query_rewriting in the search method to enable it per query. Note: enabling query completion increases the index size, indexing time and query latency.

clustering: Clustering

Enable clustering for vector search.

inference: Inference

Enable inference for search and indexing. This can be used to create vector representations of documents and queries for semantic search, e.g. by using a model like PotionBase2M.

Trait Implementations

impl Clone for CreateIndexRequest

fn clone(&self) -> CreateIndexRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CreateIndexRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateIndexRequest

fn deserialize<__D>( __deserializer: __D, ) -> Result<CreateIndexRequest, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CreateIndexRequest

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for CreateIndexRequest

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.