Struct ModelClient 

pub struct ModelClient { /* private fields */ }

A client for interacting with the Ollama API.

Implementations

impl ModelClient

pub async fn chat(&self, request: ChatRequest) -> Result<ChatResponse>

Generate a chat completion.

pub async fn chat_stream( &self, request: ChatRequest, ) -> Result<impl Stream<Item = Result<ChatResponse>> + '_>

Generate a streaming chat completion.

impl ModelClient

pub fn builder() -> ModelClientBuilder

Create a new builder for a ModelClient.

pub fn base_url(&self) -> &Url

Get the configured base URL.

pub fn is_authenticated(&self) -> bool

Check if authentication is configured.

pub async fn handle_response<T>( &self, response: Response, model: Option<&str>, ) -> Result<T>

where for<'a> T: Deserialize<'a>,

Helper method to handle responses consistently.

pub async fn handle_void_response(&self, response: Response) -> Result<()>

Helper method to handle responses that return nothing (Result<()>).

pub async fn get_version(&self) -> Result<VersionResponse>

Get the version of the Ollama API.

impl ModelClient

pub async fn embed(&self, request: EmbedRequest) -> Result<EmbedResponse>

Generate embeddings from text.

pub async fn embeddings( &self, request: EmbeddingsRequest, ) -> Result<EmbeddingsResponse>

Generate legacy embeddings from text.

impl ModelClient

pub async fn generate( &self, request: GenerateRequest, ) -> Result<GenerateResponse>

Generate text from a prompt.

pub async fn generate_stream( &self, request: GenerateRequest, ) -> Result<impl Stream<Item = Result<GenerateResponse>> + '_>

Generate text from a prompt with streaming.

impl ModelClient

pub async fn list_models(&self) -> Result<Vec<ModelInfo>>

List local models.

pub async fn show_model( &self, request: ShowModelRequest, ) -> Result<ShowModelResponse>

Show information about a model.

pub async fn copy_model(&self, request: CopyModelRequest) -> Result<()>

Copy a model.

pub async fn delete_model(&self, request: DeleteModelRequest) -> Result<()>

Delete a model.

pub async fn pull_model( &self, request: PullModelRequest, ) -> Result<impl Stream<Item = Result<StatusResponse>> + '_>

Pull a model.

pub async fn push_model( &self, request: PushModelRequest, ) -> Result<impl Stream<Item = Result<StatusResponse>> + '_>

Push a model.

pub async fn create_model( &self, request: CreateModelRequest, ) -> Result<impl Stream<Item = Result<StatusResponse>> + '_>

Create a model.

impl ModelClient

pub async fn chat_completions( &self, request: ChatCompletionsRequest, ) -> Result<ChatCompletionsResponse>

Create chat completions using OpenAI-compatible API

This endpoint is compatible with OpenAI client libraries. Use base URL http://localhost:11434/v1/ with any API key.

Example

use oai_sdk::{ModelClient, ChatCompletionsRequest, ChatMessage};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ModelClient::builder()
        .base_url("http://localhost:11434")
        .build()?;

    let request = ChatCompletionsRequest {
        model: "llama3.1:8b".to_string(),
        messages: vec![ChatMessage::user("Why is the sky blue?")],
        stream: Some(false),
        ..Default::default()
    };

    let response = client.chat_completions(request).await?;
    println!("{}", response.choices[0].message.content);

    Ok(())
}

pub async fn openai_embeddings( &self, request: OpenAIEmbeddingsRequest, ) -> Result<OpenAIEmbeddingsResponse>

Generate embeddings using OpenAI-compatible API

This endpoint is compatible with OpenAI client libraries. Use base URL http://localhost:11434/v1/ with any API key.

Example

use oai_sdk::{ModelClient, OpenAIEmbeddingsRequest, OpenAIEmbeddingsInput};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ModelClient::builder()
        .base_url("http://localhost:11434")
        .build()?;

    let request = OpenAIEmbeddingsRequest {
        model: "llama3.1:8b".to_string(),
        input: OpenAIEmbeddingsInput::Single("Why is the sky blue?".to_string()),
        encoding_format: Some("float".to_string()),
        ..Default::default()
    };

    let response = client.openai_embeddings(request).await?;
    println!("Embeddings: {:?}", response.data[0].embedding);

    Ok(())
}

pub async fn responses( &self, request: ResponsesRequest, ) -> Result<ResponsesResponse>

Generate responses using OpenAI-compatible API

This endpoint is compatible with OpenAI client libraries. Use base URL http://localhost:11434/v1/ with any API key.

Example

use oai_sdk::{ModelClient, ResponsesRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ModelClient::builder()
        .base_url("http://localhost:11434")
        .build()?;

    let request = ResponsesRequest {
        model: "llama3.1:8b".to_string(),
        input: Some("Why is the sky blue?".to_string()),
        stream: Some(false),
        ..Default::default()
    };

    let response = client.responses(request).await?;
    println!("{}", response.output);

    Ok(())
}

Trait Implementations

impl Clone for ModelClient

fn clone(&self) -> ModelClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelClient

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

Formats the value using the given formatter.