Struct RagClient 

pub struct RagClient { /* private fields */ }

Main client for interacting with the RAG system

This client provides a high-level API for indexing codebases and performing semantic searches. It contains all the core functionality and can be used directly as a library or wrapped by the MCP server.

Example

use crate::rag::{RagClient, IndexRequest, QueryRequest};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create client with default configuration
    let client = RagClient::new().await?;

    // Index a codebase
    let index_req = IndexRequest {
        path: "/path/to/code".to_string(),
        project: Some("my-project".to_string()),
        include_patterns: vec!["**/*.rs".to_string()],
        exclude_patterns: vec!["**/target/**".to_string()],
        max_file_size: 1_048_576,
    };
    let response = client.index_codebase(index_req).await?;
    println!("Indexed {} files", response.files_indexed);

    Ok(())
}

Implementations

impl RagClient

pub async fn new() -> Result<Self>

Create a new RAG client with default configuration

This will initialize the embedding model, vector database, and load any existing caches from disk.

Errors

Returns an error if:

• Configuration cannot be loaded
• Embedding model cannot be initialized
• Vector database cannot be initialized

pub async fn with_config(config: Config) -> Result<Self>

Create a new RAG client with custom configuration

Example

use crate::rag::{RagClient, Config};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut config = Config::default();
    config.embedding.model_name = "BAAI/bge-small-en-v1.5".to_string();

    let client = RagClient::with_config(config).await?;
    Ok(())
}

pub async fn with_vector_db( vector_db: Arc<dyn VectorDatabase>, config: Config, ) -> Result<Self>

Create a RAG client with an externally-provided vector database.

This enables callers to share a database connection across subsystems instead of creating a new one internally.

pub fn normalize_path(path: &str) -> Result<String>

Normalize a path to a canonical absolute form for consistent cache lookups

pub async fn is_index_dirty(&self, path: &str) -> bool

Check if a specific path’s index is dirty (incomplete/corrupted)

Returns true if the path is marked as dirty, meaning a previous indexing operation was interrupted and the data may be inconsistent.

pub async fn get_dirty_paths(&self) -> Vec<String>

Check if any indexed paths are dirty

Returns a list of paths that have dirty indexes.

pub fn config(&self) -> &Config

Get the configuration used by this client

pub fn embedding_dimension(&self) -> usize

Get the embedding dimension used by this client

impl RagClient

pub async fn index_codebase( &self, request: IndexRequest, ) -> Result<IndexResponse>

Index a codebase directory

This automatically performs full indexing for new codebases or incremental updates for previously indexed codebases.

Example

use crate::rag::{RagClient, IndexRequest};

let client = RagClient::new().await?;

let request = IndexRequest {
    path: "/path/to/code".to_string(),
    project: Some("my-project".to_string()),
    include_patterns: vec!["**/*.rs".to_string()],
    exclude_patterns: vec!["**/target/**".to_string()],
    max_file_size: 1_048_576,
};

let response = client.index_codebase(request).await?;
println!("Indexed {} files in {} ms",
         response.files_indexed,
         response.duration_ms);

pub async fn query_codebase( &self, request: QueryRequest, ) -> Result<QueryResponse>

Query the indexed codebase using semantic search

Example

use crate::rag::{RagClient, QueryRequest};

let client = RagClient::new().await?;

let request = QueryRequest {
    query: "authentication logic".to_string(),
    path: None,
    project: Some("my-project".to_string()),
    limit: 10,
    min_score: 0.7,
    hybrid: true,
};

let response = client.query_codebase(request).await?;
for result in response.results {
    println!("Found in {}: {:.2}", result.file_path, result.score);
    println!("{}", result.content);
}

pub async fn search_with_filters( &self, request: AdvancedSearchRequest, ) -> Result<QueryResponse>

Advanced search with filters for file type, language, and path patterns

pub async fn get_statistics(&self) -> Result<StatisticsResponse>

Get statistics about the indexed codebase

pub async fn clear_index(&self) -> Result<ClearResponse>

Clear all indexed data from the vector database and hash cache

pub async fn search_git_history( &self, request: SearchGitHistoryRequest, ) -> Result<SearchGitHistoryResponse>

Search git commit history using semantic search

Example

use crate::rag::{RagClient, SearchGitHistoryRequest};

let client = RagClient::new().await?;

let request = SearchGitHistoryRequest {
    query: "bug fix authentication".to_string(),
    path: "/path/to/repo".to_string(),
    project: None,
    branch: None,
    max_commits: 100,
    limit: 10,
    min_score: 0.7,
    author: None,
    since: None,
    until: None,
    file_pattern: None,
};

let response = client.search_git_history(request).await?;
for result in response.results {
    println!("Commit {}: {}", result.commit_hash, result.commit_message);
}

impl RagClient

pub async fn query_ensemble( &self, request: EnsembleRequest, ) -> Result<EnsembleResponse>

Multi-strategy ensemble query: fan out across all requested strategies concurrently, fuse results via Reciprocal Rank Fusion (RRF), and optionally apply spectral diversity reranking as a final pass.

Strategies

• Semantic — vector similarity search
• Keyword — BM25 keyword / hybrid search
• GitHistory — semantic search over commit history
• CodeNavigation — AST-based relations search (requires code-analysis)

Fusion

Results from each strategy are deduplicated by file_path:start_line and fused using RRF so that items appearing near the top of multiple strategy lists rank highest overall.

impl RagClient

pub async fn query_diverse( &self, request: QueryRequest, reranker: Option<RerankerKind>, ) -> Result<QueryResponse>

Query the indexed codebase with pluggable diversity/relevance reranking.

This oversamples candidates (3× the limit), then applies the chosen reranker to select the final result set. Pass None to use the default spectral reranker with its default configuration.

Reranker options

• RerankerKind::Spectral — greedy log-det maximization (diversity-focused)
• RerankerKind::CrossEncoder — query-document cosine blend (relevance-focused)
• RerankerKind::Both — spectral first, then cross-encoder on the selected subset

Requires the spectral feature.

impl RagClient

pub async fn find_definition( &self, request: FindDefinitionRequest, ) -> Result<FindDefinitionResponse>

Find the definition of a symbol at a given file location

This method looks up the symbol at the specified location and returns its definition information if found.

Arguments

• request - The find definition request containing file path, line, and column

Returns

A response containing the definition if found, along with precision info

pub async fn find_references( &self, request: FindReferencesRequest, ) -> Result<FindReferencesResponse>

Find all references to a symbol at a given file location

This method finds all locations where the symbol at the given position is referenced throughout the indexed codebase.

Arguments

• request - The find references request containing file path, line, column, and limit

Returns

A response containing the list of references found

pub async fn get_call_graph( &self, request: GetCallGraphRequest, ) -> Result<GetCallGraphResponse>

Get the call graph for a function at a given file location

This method returns the callers (incoming calls) and callees (outgoing calls) for the function at the specified location.

Arguments

• request - The call graph request containing file path, line, column, and depth

Returns

A response containing the root symbol and its call graph

Trait Implementations

impl Clone for RagClient

fn clone(&self) -> RagClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.