Module query

Expand description

§Querying pipelines

Swiftide allows you to define sophisticated query pipelines.

Consider the following code that uses Swiftide to load some markdown text, chunk it, embed it, and store it in a Qdrant index:

use swiftide::{
    indexing::{
        self,
        loaders::FileLoader,
        transformers::{ChunkMarkdown, Embed, MetadataQAText},
    },
    integrations::{self, qdrant::Qdrant},
    integrations::openai::OpenAI,
    query::{self, answers, query_transformers, response_transformers},
};

async fn index() -> Result<(), Box<dyn std::error::Error>> {
  let openai_client = OpenAI::builder()
      .default_embed_model("text-embedding-3-large")
      .default_prompt_model("gpt-4o")
      .build()?;

  let qdrant = Qdrant::builder()
      .batch_size(50)
      .vector_size(3072)
      .collection_name("swiftide-examples")
      .build()?;

  indexing::Pipeline::from_loader(FileLoader::new("README.md"))
      .then_chunk(ChunkMarkdown::from_chunk_range(10..2048))
      .then(MetadataQAText::new(openai_client.clone()))
      .then_in_batch(Embed::new(openai_client.clone()).with_batch_size(10))
      .then_store_with(qdrant.clone())
      .run()
      .await?;

  Ok(())
}

We could then define a query pipeline that uses the Qdrant index to answer questions:

// By default the search strategy is SimilaritySingleEmbedding
// which takes the latest query, embeds it, and does a similarity search
let pipeline = query::Pipeline::default()
    .then_transform_query(query_transformers::GenerateSubquestions::from_client(
        openai_client.clone(),
    ))
    .then_transform_query(query_transformers::Embed::from_client(
        openai_client.clone(),
    ))
    .then_retrieve(qdrant.clone())
    .then_transform_response(response_transformers::Summary::from_client(
        openai_client.clone(),
    ))
    .then_answer(answers::Simple::from_client(openai_client.clone()));

let result = pipeline
    .query("What is swiftide? Please provide an elaborate explanation")
    .await?;

println!("{:?}", result.answer());

By using a query pipeline to transform queries, we can improve the quality of the answers we get from our index. In this example, we used an LLM to generate subquestions, embedding those and then using them to search the index. Finally, we summarize the results and combine them together into a single answer.

Modules§

__mock_MockAnswer
__mock_MockAnswer_Answer
__mock_MockAnswer_Clone
__mock_MockEvaluateQuery
__mock_MockEvaluateQuery_Clone
__mock_MockEvaluateQuery_EvaluateQuery
__mock_MockTransformQuery
__mock_MockTransformQuery_Clone
__mock_MockTransformQuery_TransformQuery
__mock_MockTransformResponse
__mock_MockTransformResponse_Clone
__mock_MockTransformResponse_TransformResponse
answers: Given a query, generate an answer
evaluators: This module contains evaluators for evaluating the quality of a pipeline.
query_transformers: Transform queries that are yet to be made
response_transformers: Transform retrieved queries
search_strategies
states: States of a query

Structs§

Document: A document represents a single unit of retrieved text
DocumentBuilder: Builder for Document.
MockAnswer
MockEvaluateQuery
MockTransformQuery
MockTransformResponse
Pipeline: The starting point of a query pipeline
Query: A query is the main object going through a query pipeline
QueryBuilder: Builder for Query.
QueryStream: Internally used by a query pipeline

Enums§

DocumentBuilderError: Error type for DocumentBuilder
QueryBuilderError: Error type for QueryBuilder
QueryEvaluation: Wraps a query for evaluation. Used by the crate::query_traits::EvaluateQuery trait.
TransformationEvent: Records changes to a query

Traits§