adk-rag 0.6.0

Retrieval-Augmented Generation for Rust Agent Development Kit (ADK-Rust) agents
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

//! Error types for the `adk-rag` crate.

use thiserror::Error;

/// Errors that can occur in RAG operations.
#[derive(Debug, Error)]
pub enum RagError {
    /// An error occurred during embedding generation.
    #[error("Embedding error ({provider}): {message}")]
    EmbeddingError {
        /// The embedding provider that produced the error.
        provider: String,
        /// A description of the failure.
        message: String,
    },

    /// An error occurred in the vector store backend.
    #[error("Vector store error ({backend}): {message}")]
    VectorStoreError {
        /// The vector store backend that produced the error.
        backend: String,
        /// A description of the failure.
        message: String,
    },

    /// An error occurred during document chunking.
    #[error("Chunking error: {0}")]
    ChunkingError(String),

    /// An error occurred during result reranking.
    #[error("Reranker error ({reranker}): {message}")]
    RerankerError {
        /// The reranker that produced the error.
        reranker: String,
        /// A description of the failure.
        message: String,
    },

    /// A configuration validation error.
    #[error("Configuration error: {0}")]
    ConfigError(String),

    /// An error in the RAG pipeline orchestration.
    #[error("Pipeline error: {0}")]
    PipelineError(String),

    /// An error propagated from `adk-core`.
    #[error(transparent)]
    AdkError(#[from] adk_core::AdkError),
}

/// A convenience result type for RAG operations.
pub type Result<T> = std::result::Result<T, RagError>;

impl From<RagError> for adk_core::AdkError {
    fn from(err: RagError) -> Self {
        use adk_core::{ErrorCategory, ErrorComponent};
        // If it's already wrapping an AdkError, unwrap it
        if let RagError::AdkError(inner) = err {
            return inner;
        }
        let (category, code) = match &err {
            RagError::EmbeddingError { .. } => (ErrorCategory::Internal, "memory.embedding"),
            RagError::VectorStoreError { .. } => (ErrorCategory::Internal, "memory.vector_store"),
            RagError::ChunkingError(_) => (ErrorCategory::Internal, "memory.chunking"),
            RagError::RerankerError { .. } => (ErrorCategory::Internal, "memory.reranker"),
            RagError::ConfigError(_) => (ErrorCategory::InvalidInput, "memory.rag_config"),
            RagError::PipelineError(_) => (ErrorCategory::Internal, "memory.rag_pipeline"),
            RagError::AdkError(_) => unreachable!(),
        };
        adk_core::AdkError::new(ErrorComponent::Memory, category, code, err.to_string())
            .with_source(err)
    }
}