Struct InferenceEngine 

pub struct InferenceEngine { /* private fields */ }

Main inference engine

Implementations

impl InferenceEngine

pub fn new(model: DeepSeekR1Model) -> Result<Self>

Create a new inference engine

pub fn with_configs( model: DeepSeekR1Model, tokenizer_config: TokenizerConfig, sampling_config: SamplingConfig, generation_config: GenerationConfig, ) -> Result<Self>

Create a new inference engine with custom configurations

pub fn generate_text(&mut self, prompt: &str) -> Result<String>

Generate text from a prompt using default configuration

pub fn generate_text_with_config( &mut self, prompt: &str, config: &GenerationConfig, ) -> Result<GenerationOutput>

Generate text from a prompt with custom configuration

pub fn generate_text_streaming<F>( &mut self, prompt: &str, config: &GenerationConfig, callback: F, ) -> Result<GenerationOutput>

where F: FnMut(&str) -> Result<bool>,

Generate text with streaming (returns tokens as they are generated)

pub fn set_generation_config(&mut self, config: GenerationConfig)

Set generation configuration

pub fn generation_config(&self) -> &GenerationConfig

Get current generation configuration

pub fn clear_cache(&mut self)

Clear generation cache

pub fn tokenizer(&self) -> &Tokenizer

Get tokenizer reference

pub fn generate_with_reasoning( &mut self, prompt: &str, ) -> Result<ReasoningOutput>

Generate text with reasoning awareness

pub fn generate_with_reasoning_config( &mut self, prompt: &str, config: &GenerationConfig, ) -> Result<ReasoningOutput>

Generate text with reasoning awareness and custom config

pub fn generate_with_reasoning_detection( &mut self, prompt: &str, ) -> Result<(GenerationOutput, Option<ReasoningOutput>)>

Generate text with automatic reasoning detection

pub fn generate_structured_reasoning( &mut self, prompt: &str, ) -> Result<ReasoningOutput>

Generate structured reasoning for a given prompt

pub fn solve_math_problem(&mut self, problem: &str) -> Result<ReasoningOutput>

Solve a mathematical problem with reasoning

pub fn solve_math_problem_detailed( &mut self, problem: &str, ) -> Result<MathSolutionOutput>

Solve a mathematical problem with detailed step-by-step reasoning

pub fn explain_code(&mut self, code: &str) -> Result<ReasoningOutput>

Explain code with reasoning

pub fn explain_code_detailed( &mut self, code: &str, language: Option<&str>, ) -> Result<CodeExplanationOutput>

Explain code with detailed analysis

pub fn solve_logical_problem( &mut self, problem: &str, ) -> Result<ReasoningOutput>

Solve logical reasoning problems

pub fn solve_logical_problem_detailed( &mut self, problem: &str, ) -> Result<LogicalSolutionOutput>

Solve logical reasoning problems with detailed analysis

pub fn solve_problem( &mut self, problem: &str, problem_type: ProblemType, ) -> Result<ReasoningOutput>

General problem solving with adaptive prompting