Struct OllamaClient 

pub struct OllamaClient { /* private fields */ }

Ollama client for LLM inference

Implementations

impl OllamaClient

pub fn new(config: OllamaConfig) -> Self

Create a new Ollama client

pub fn get_stats(&self) -> &OllamaUsageStats

Get usage statistics

pub fn config(&self) -> &OllamaConfig

Access the underlying Ollama configuration

pub async fn generate(&self, prompt: &str) -> Result<String>

Generate text completion using Ollama API

pub async fn generate_with_params( &self, prompt: &str, params: OllamaGenerationParams, ) -> Result<String>

Generate text completion with custom parameters

pub async fn generate_with_full_response( &self, prompt: &str, params: OllamaGenerationParams, ) -> Result<OllamaGenerateResponse>

Generate text and return the full response including KV cache context and token stats.

Use this for the two-step contextual enrichment pattern:

let client = OllamaClient::new(OllamaConfig::default());

// Step 1: Prime — load the document into Ollama's KV cache
let prime_params = OllamaGenerationParams {
    num_predict: Some(1), // generate minimal output; we just want the context
    keep_alive: Some("1h".to_string()),
    num_ctx: Some(32768),
    ..Default::default()
};
let prime = client.generate_with_full_response("<document>..full doc..</document>", prime_params).await?;
println!("Prompt tokens evaluated: {}", prime.prompt_eval_count); // ~doc_tokens

// Step 2: Per chunk — only the chunk tokens are evaluated
for chunk in chunks {
    let params = OllamaGenerationParams {
        num_predict: Some(80),
        context: Some(prime.context.clone()),  // ← KV cache reuse!
        keep_alive: Some("1h".to_string()),
        ..Default::default()
    };
    let resp = client.generate_with_full_response(&chunk, params).await?;
    println!("Chunk tokens evaluated: {}", resp.prompt_eval_count); // ~chunk_tokens, not doc_tokens!
}

pub async fn generate_streaming(&self, prompt: &str) -> Result<Receiver<String>>

Generate streaming completion

Returns a channel receiver that yields tokens as they are generated. This enables real-time display of generation progress.

Example

use graphrag_core::ollama::{OllamaClient, OllamaConfig};

let client = OllamaClient::new(OllamaConfig::default());
let mut rx = client.generate_streaming("Write a story").await?;

while let Some(token) = rx.recv().await {
    print!("{}", token);
}

Trait Implementations

impl Clone for OllamaClient

fn clone(&self) -> OllamaClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OllamaClient

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

Formats the value using the given formatter.