Struct Query

pub struct Query<STATE>
where
    STATE: QueryState,
{
    pub embedding: Option<Vec<f32>>,
    pub sparse_embedding: Option<SparseEmbedding>,
    pub documents: Vec<Document>,
    /* private fields */
}

A query is the main object going through a query pipeline

It acts as a statemachine, with the following transitions:

states::Pending: No documents have been retrieved states::Retrieved: Documents have been retrieved states::Answered: The query has been answered

Fields

embedding: Option<Vec<f32>>

sparse_embedding: Option<SparseEmbedding>

documents: Vec<Document>

Documents the query will operate on

A query can retrieve multiple times, accumulating documents

Implementations

impl<STATE> Query<STATE>

where STATE: Clone + QueryState,

pub fn builder() -> QueryBuilder<STATE>

pub fn original(&self) -> &str

Return the query it started with

pub fn current(&self) -> &str

Return the current query (or after retrieval!)

pub fn history(&self) -> &Vec<TransformationEvent>

pub fn documents(&self) -> &[Document]

Returns the current documents that will be used as context for answer generation

pub fn documents_mut(&mut self) -> &mut Vec<Document>

Returns the current documents as mutable

impl<STATE> Query<STATE>

where STATE: Clone + CanRetrieve,

pub fn retrieved_documents(self, documents: Vec<Document>) -> Query<Retrieved>

Add retrieved documents and transition to states::Retrieved

impl Query<Pending>

pub fn new(query: impl Into<String>) -> Query<Pending>

pub fn transformed_query(&mut self, new_query: impl Into<String>)

Transforms the current query

impl Query<Retrieved>

pub fn new() -> Query<Retrieved>

pub fn transformed_response(&mut self, new_response: impl Into<String>)

Transforms the current response

pub fn answered(self, answer: impl Into<String>) -> Query<Answered>

Transition the query to states::Answered

impl Query<Answered>

pub fn new() -> Query<Answered>

pub fn answer(&self) -> &str

Returns the answer of the query

Trait Implementations

impl<STATE> Clone for Query<STATE>

where STATE: Clone + QueryState,

fn clone(&self) -> Query<STATE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<STATE> Debug for Query<STATE>

where STATE: Debug + QueryState,

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

Formats the value using the given formatter.

impl<STATE> Default for Query<STATE>

where STATE: Default + QueryState,

fn default() -> Query<STATE>

Returns the “default value” for a type.

impl From<Query<Answered>> for QueryEvaluation

fn from(val: Query<Answered>) -> QueryEvaluation

Converts to this type from the input type.

impl From<Query<Retrieved>> for QueryEvaluation

fn from(val: Query<Retrieved>) -> QueryEvaluation

Converts to this type from the input type.

impl<T> From<T> for Query<Pending>

where T: AsRef<str>,

fn from(original: T) -> Query<Pending>

Converts to this type from the input type.

impl<STATE> PartialEq for Query<STATE>

where STATE: PartialEq + QueryState,

fn eq(&self, other: &Query<STATE>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<STATE> StructuralPartialEq for Query<STATE>

where STATE: QueryState,