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 project_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 project_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 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 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 project_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 project_rag::{RagClient, QueryRequest};

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

let request = QueryRequest {
    query: "authentication logic".to_string(),
    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

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

Search git commit history using semantic search

Example

use project_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);
}

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

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.