Llmoxide

https://docs.rs/llmoxide
Admin
Llmoxide is a provider-agnostic Rust SDK for LLM APIs with normalized interfaces, streaming,...
Tokens:84,315
Snippets:666
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Prompt Implementation: Get Client

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Returns a reference to the underlying Client instance.

```rust
pub fn client(&self) -> &Client {
    &self.client
}
```

--------------------------------

### Create Chat Session

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Start a new chat session with a specific model.

```rust
pub fn chat(&self, model: impl Into<String>) -> crate::chat::ChatSession<'_> {
        crate::chat::ChatSession::new(self, crate::chat::Chat::new(model))
    }
```

--------------------------------

### Start an auto-detected chat session

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Starts a chat session using an automatically detected model. This is convenient when only one model is available or a default is preferred.

```rust
pub fn chat_auto(&self) -> ChatSession<'_>
```

--------------------------------

### Create Auto Chat Session

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Start a new chat session with automatic model selection.

```rust
pub fn chat_auto(&self) -> crate::chat::ChatSession<'_> {
        crate::chat::ChatSession::new(self, crate::chat::Chat::new_auto())
    }
```

--------------------------------

### Start a chat session

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Initiates a chat session for a specific model. The model can be specified by its name or ID.

```rust
pub fn chat(&self, model: impl Into<String>) -> ChatSession<'_>
```

--------------------------------

### Basic unwrap usage

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `unwrap` to get the `Ok` value. Panics if the `Result` is an `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

--------------------------------

### Handling File Metadata Operations

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Illustrates using `and_then` to chain fallible operations, specifically for retrieving file metadata and its modification time. This example shows how to handle both successful and erroneous outcomes when interacting with the file system.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Send a request and get a response

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Sends a request to the language model and returns a single response. Use this for non-streaming interactions.

```rust
pub async fn send(&self, req: ResponseRequest) -> Result<Response>
```

--------------------------------

### Handling File Metadata Operations

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Illustrates using `and_then` to chain operations like getting file metadata and then its modification time, handling potential errors like file not found.

```APIDOC
## Handling File Metadata Operations

### Description
This example demonstrates chaining operations that can fail, such as accessing file metadata and then its modification time. It uses `and_then` to handle potential errors gracefully.

### Method
`and_then`

### Parameters
- `self`: The `Result` instance from `Path::metadata()`.
- `op`: A closure that takes the `metadata` and returns the modified time `Result`.

### Request Example
```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

### Response
- Returns `Ok(Instant)` with the modification time if successful.
- Returns `Err(io::Error)` if any operation fails (e.g., file not found).
```

--------------------------------

### Client Initialization

Source: https://docs.rs/llmoxide/latest/index.html

Demonstrates how to initialize the `Client` with configuration.

```APIDOC
## Client Initialization

### Description
Initialize the `Client` with `ClientConfig` to interact with LLM providers.

### Method
`Client::new(config: ClientConfig)`

### Parameters
- **config** (`ClientConfig`) - Required - The configuration for the client.

### Request Example
```rust
use llmoxide::client::Client;
use llmoxide::client::ClientConfig;

let config = ClientConfig::default(); // Or a custom configuration
let client = Client::new(config);
```

### Response
#### Success Response
- **Client** - An initialized client instance.
```

--------------------------------

### Client Initialization

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Create a new client instance with the provided configuration.

```rust
pub fn new(cfg: ClientConfig) -> Self {
        Self {
            http: reqwest::Client::new(),
            cfg,
        }
    }
```

--------------------------------

### Client::new

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Constructs a new Client instance with the provided configuration.

```APIDOC
## Client::new

### Description
Constructs a new `Client` instance with the provided configuration.

### Signature
```rust
pub fn new(cfg: ClientConfig) -> Self
```
```

--------------------------------

### Initialize OpenAI Prompt

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Create a new Prompt instance configured for OpenAI using your API key.

```rust
pub fn openai(api_key: impl Into<String>) -> Prompt {
    Prompt::new(ClientConfig::openai(api_key))
}
```

--------------------------------

### Send Request

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Send a request to the configured language model provider and get a response.

```rust
pub async fn send(&self, req: ResponseRequest) -> Result<Response> {
        self.cfg.provider.send(&self.http, req).await
    }
```

--------------------------------

### Get Text Content from Message

Source: https://docs.rs/llmoxide/latest/llmoxide/types/struct.Message.html

Retrieves the plain text content from a Message if it exists.

```rust
pub fn text_content(&self) -> Option<String>
```

--------------------------------

### Create a new Client instance

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Instantiates a new Client with the provided configuration. Ensure ClientConfig is properly set up before calling this.

```rust
pub fn new(cfg: ClientConfig) -> Self>
```

--------------------------------

### Prompt Implementation: New

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Constructor for the Prompt struct, initializing it with a given ClientConfig.

```rust
fn new(cfg: ClientConfig) -> Self {
    Self {
        client: Client::new(cfg),
        model: None,
        max_output_tokens: None,
    }
}
```

--------------------------------

### Initialize Ollama Prompt

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Create a new Prompt instance configured for Ollama using default settings.

```rust
pub fn ollama() -> Prompt {
    Prompt::new(ClientConfig::ollama_default())
}
```

--------------------------------

### Get Provider Kind

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Retrieve the kind of the language model provider currently configured for the client.

```rust
pub fn provider(&self) -> &Provider {
        &self.cfg.provider_kind
    }
```

--------------------------------

### Initialize Gemini Prompt

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Create a new Prompt instance configured for Gemini using your API key.

```rust
pub fn gemini(api_key: impl Into<String>) -> Prompt {
    Prompt::new(ClientConfig::gemini(api_key))
}
```

--------------------------------

### OpenAiApi::new

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/openai/struct.OpenAiApi.html

Constructs a new OpenAiApi instance with the provided API key and base URL.

```APIDOC
## `OpenAiApi::new`

### Description
Constructs a new `OpenAiApi` instance.

### Signature
```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self
```

### Parameters
* `api_key`: An object that can be converted into a `String`, representing the OpenAI API key.
* `base_url`: An object that can be converted into a `String`, representing the base URL for the OpenAI API.
```

--------------------------------

### Any::type_id() Implementation

Source: https://docs.rs/llmoxide/latest/llmoxide/error/enum.Error.html

Gets the `TypeId` of the implementing type. This is part of the `Any` trait, useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### unwrap_err for Err and Ok

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `unwrap_err` to get the `Err` value. Panics with the `Ok` value if the `Result` is an `Ok`.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

--------------------------------

### Prompt Implementation: Into Client

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Consumes the Prompt and returns the underlying Client instance.

```rust
pub fn into_client(self) -> Client {
    self.client
}
```

--------------------------------

### GeminiApi::new

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/gemini/struct.GeminiApi.html

Constructs a new GeminiApi instance.

```APIDOC
## GeminiApi::new

### Description
Constructs a new GeminiApi instance.

### Signature
```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self
```

### Parameters
* `api_key`: An object that can be converted into a String, representing the API key.
* `base_url`: An object that can be converted into a String, representing the base URL for the API.
```

--------------------------------

### Get owned version of Client

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Returns an owned version of the Client, typically by cloning. This is part of the `ToOwned` trait.

```rust
type Owned = T;
fn to_owned(&self) -> T>
```

--------------------------------

### Get TypeId of Client

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Retrieves the `TypeId` of the Client. This is part of the `Any` trait implementation and is used for dynamic type checking.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### Initialize Ollama Prompt at Specific URL

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Create a new Prompt instance configured for Ollama, specifying the base URL.

```rust
pub fn ollama_at(base_url: impl Into<String>) -> Prompt {
    Prompt::new(ClientConfig::ollama(base_url))
}
```

--------------------------------

### Error::cause() (Deprecated)

Source: https://docs.rs/llmoxide/latest/llmoxide/error/enum.Error.html

Deprecated method for getting the underlying cause of an error. Use `Error::source()` which supports downcasting.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### Prompt Implementation: List Models

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Retrieves a list of available models from the configured LLM provider.

```rust
pub async fn list_models(&self) -> Result<Vec<ModelInfo>> {
    self.client.list_models().await
}
```

--------------------------------

### Listing Models

Source: https://docs.rs/llmoxide/latest/index.html

Demonstrates how to list available models.

```APIDOC
## Listing Models

### Description
Retrieve a list of available models using the `Prompt::list_models` method.

### Method
`Prompt::list_models()`

### Request Example
```rust
use llmoxide::Prompt;

let models = Prompt::list_models();
```

### Response
#### Success Response
- **Vec<Model>** - A vector of available `Model` objects.
```

--------------------------------

### Get the Provider from Client

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Retrieves a reference to the Provider associated with the Client. This can be useful for inspecting the underlying model provider details.

```rust
pub fn provider(&self) -> &Provider>
```

--------------------------------

### Chat Initialization and Configuration

Source: https://docs.rs/llmoxide/latest/src/llmoxide/chat.rs.html

Provides methods for creating and configuring a new chat instance, setting the model, and adjusting output parameters.

```APIDOC
## Chat::new

### Description
Creates a new `Chat` instance with a specified model.

### Method Signature
`pub fn new(model: impl Into<String>) -> Self`

## Chat::new_auto

### Description
Creates a new `Chat` instance without a predefined model, allowing for automatic model selection.

### Method Signature
`pub fn new_auto() -> Self`

## Chat::model

### Description
Sets or updates the model for the chat instance. This method consumes `self` and returns a new instance with the model set.

### Method Signature
`pub fn model(mut self, model: impl Into<String>) -> Self`

## Chat::max_output_tokens

### Description
Sets the maximum number of output tokens for the chat. This method consumes `self` and returns a new instance with the token limit set.

### Method Signature
`pub fn max_output_tokens(mut self, max: u32) -> Self`

## Chat::set_max_output_tokens

### Description
Sets the maximum number of output tokens for the chat instance mutably.

### Method Signature
`pub fn set_max_output_tokens(&mut self, max: u32) -> &mut Self`
```

--------------------------------

### openai

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Creates a new Prompt client configured for the OpenAI provider.

```APIDOC
## openai

### Description
Creates a new `Prompt` client configured for the OpenAI provider.

### Function Signature
```rust
pub fn openai(api_key: impl Into<String>) -> Prompt
```

### Parameters
* `api_key` (impl Into<String>): The API key for authenticating with OpenAI.
```

--------------------------------

### Default Model Constants

Source: https://docs.rs/llmoxide/latest/src/llmoxide/types.rs.html

Provides default model names for various providers. These can be used as a starting point when no specific model is required.

```rust
pub const DEFAULT_OPENAI_MODEL: &str = "gpt-4.1-mini";
pub const DEFAULT_ANTHROPIC_MODEL: &str = "claude-sonnet-4-6";
pub const DEFAULT_GEMINI_MODEL: &str = "gemini-2.5-flash";
pub const DEFAULT_OLLAMA_MODEL: &str = "llama3.1";
```

--------------------------------

### expect_err panics on Ok

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `expect_err` to get the `Err` value. Panics with a custom message and the `Ok` value if the `Result` is an `Ok`.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

--------------------------------

### OpenAI API Client Initialization

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/openai.rs.html

Initializes a new OpenAI API client with an API key and base URL. Ensure your API key is kept secure.

```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            base_url: base_url.into(),
        }
    }
```

--------------------------------

### Get Provider Type

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/ollama/struct.OllamaApi.html

Returns the Provider enum variant associated with this API client. This helps identify the type of service being used.

```rust
fn provider(&self) -> Provider>
```

--------------------------------

### Client Configuration

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Configuration options for initializing the LLMOxide client with different providers.

```APIDOC
## ClientConfig

### Description
Configuration struct for setting up the language model provider.

### Methods

#### `openai(api_key: impl Into<String>) -> Self`
Initializes the client with the OpenAI provider.

#### `anthropic(api_key: impl Into<String>) -> Self`
Initializes the client with the Anthropic provider.

#### `gemini(api_key: impl Into<String>) -> Self`
Initializes the client with the Gemini provider.

#### `ollama(base_url: impl Into<String>) -> Self`
Initializes the client with the Ollama provider, specifying a custom base URL.

#### `ollama_default() -> Self`
Initializes the client with the Ollama provider using the default local URL (`http://localhost:11434`).
```

--------------------------------

### Or Policy Method

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/anthropic/struct.AnthropicApi.html

Creates a new Policy that returns Action::Follow if either self or other policies return Action::Follow.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>,
 P: Policy<B, E>,
```

--------------------------------

### Get Client Reference

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Obtain a reference to the underlying Client for more advanced interactions, such as managing chat history or custom response requests.

```rust
pub fn client(&self) -> &Client
```

--------------------------------

### Error::description() (Deprecated)

Source: https://docs.rs/llmoxide/latest/llmoxide/error/enum.Error.html

Deprecated method for getting a string description of the error. Prefer using the Display implementation or `to_string()` instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### Initialize Anthropic Prompt

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Create a new Prompt instance configured for Anthropic using your API key.

```rust
pub fn anthropic(api_key: impl Into<String>) -> Prompt {
    Prompt::new(ClientConfig::anthropic(api_key))
}
```

--------------------------------

### And Policy Method

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/anthropic/struct.AnthropicApi.html

Creates a new Policy that returns Action::Follow only if both self and other policies return Action::Follow.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>,
 P: Policy<B, E>,
```

--------------------------------

### Extract Text from Gemini Response

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/gemini.rs.html

Extracts plain text content from a Gemini GenerateContentResponse. This is used to get the model's textual output.

```rust
    #[test]
    fn extract_text_from_generate_content_response() {
        let json = r#"{
          "candidates": [
            {
              "content": {
                "parts": [
                  { "text": "hello" },
                  { "text": " world" }
                ]
              }
            }
          ]
        }"#;
        let parsed: GenerateContentResponse = serde_json::from_str(json).unwrap();
        assert_eq!(GeminiProvider::extract_text(&parsed), "hello world");
    }
```

--------------------------------

### Unsafe `unwrap_err_unchecked` Example

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Shows the usage of `unwrap_err_unchecked`, which returns the `Err` value without checking if the Result is `Ok`. This is unsafe and should only be used when the caller guarantees the Result is `Err`.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

--------------------------------

### Client::chat_from

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Initializes a chat session from an existing chat object.

```APIDOC
## Client::chat_from

### Description
Initializes a chat session from an existing chat object.

### Signature
```rust
pub fn chat_from(&self, chat: Chat) -> ChatSession<'_>
```
```

--------------------------------

### Unsafe `unwrap_unchecked` Example

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Shows the usage of `unwrap_unchecked`, which returns the `Ok` value without checking if the Result is `Err`. This is unsafe and should only be used when the caller guarantees the Result is `Ok`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

--------------------------------

### Chat Initialization

Source: https://docs.rs/llmoxide/latest/llmoxide/chat/struct.Chat.html

Methods for creating a new Chat instance.

```APIDOC
## `Chat::new(model: impl Into<String>) -> Self`

### Description
Creates a new Chat instance with the specified model.

### Method
`new`

### Parameters
- `model` (impl Into<String>) - The model to use for the chat.
```

```APIDOC
## `Chat::new_auto() -> Self`

### Description
Creates a new Chat instance automatically selecting the model.

### Method
`new_auto`
```

--------------------------------

### Prompt Implementation: Send

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Sends a prompt to the LLM and returns the full response.

```rust
pub async fn send(&self, prompt: impl Into<String>) -> Result<Response> {
    self.client.send(self.request(prompt)).await
}
```

--------------------------------

### Gemini Model ID Normalization

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/gemini.rs.html

Ensures that a model identifier conforms to the expected 'models/' prefix for Gemini API requests. If the ID already starts with 'models/', it's returned as is.

```rust
fn normalize_model_id(id: &str) -> String {
    if id.starts_with("models/") {
        id.to_string()
    } else {
        format!("models/{id}")
    }
}
```

--------------------------------

### Gemini API Client Initialization

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/gemini.rs.html

Initializes a new Gemini API client with an API key and base URL. Ensure the base URL is correctly formatted.

```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self {
    Self {
        api_key: api_key.into(),
        base_url: base_url.into(),
    }
}
```

--------------------------------

### unwrap_or_default for Ok and Err

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `unwrap_or_default` to get the `Ok` value or the default value if it's an `Err`. This is useful for converting fallible string parses into a default numeric value.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

--------------------------------

### ClientConfig Constructors

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.ClientConfig.html

These static methods allow you to create a ClientConfig for specific AI providers by providing necessary authentication or base URL information.

```APIDOC
## ClientConfig

### `openai(api_key: impl Into<String>) -> Self`
Creates a `ClientConfig` for OpenAI.

### `anthropic(api_key: impl Into<String>) -> Self`
Creates a `ClientConfig` for Anthropic.

### `gemini(api_key: impl Into<String>) -> Self`
Creates a `ClientConfig` for Gemini.

### `ollama(base_url: impl Into<String>) -> Self`
Creates a `ClientConfig` for Ollama with a custom base URL.

### `ollama_default() -> Self`
Creates a `ClientConfig` for Ollama using the default base URL.
```

--------------------------------

### Parse Ollama Chat Response Tool Calls

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/ollama.rs.html

Parses an Ollama chat response containing tool calls. This example demonstrates how to deserialize the tool call structure and verify its properties.

```rust
let json = r#"{ 
            "message": { 
                "role": "assistant", 
                "content": "", 
                "tool_calls": [ 
                    { 
                        "type": "function", 
                        "function": { 
                            "index": 0, 
                            "name": "add", 
                            "arguments": {"a": 19, "b": 23}
                        } 
                    } 
                ] 
            } 
        }"#;
        let parsed: OllamaChatResponse = serde_json::from_str(json).unwrap();
        let calls = OllamaProvider::wire_tool_calls_to_tool_calls(&parsed.message.tool_calls);
        assert_eq!(calls.len(), 1);
        assert_eq!(calls[0].name, "add");
        assert_eq!(calls[0].id.as_deref(), Some("ollama-0"));
```

--------------------------------

### Create a combined Policy (Or)

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Creates a new `Policy` that allows `Action::Follow` if either `self` or `other` policies return `Action::Follow`. Useful for alternative conditions.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>,
```

--------------------------------

### ollama_at

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Creates a new Prompt client configured for the Ollama provider at a specified base URL.

```APIDOC
## ollama_at

### Description
Creates a new `Prompt` client configured for the Ollama provider at a specified base URL.

### Function Signature
```rust
pub fn ollama_at(base_url: impl Into<String>) -> Prompt
```

### Parameters
* `base_url` (impl Into<String>): The base URL for the Ollama instance.
```

--------------------------------

### Iterating over `Ok` values with `iter`

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `iter` to get an iterator that yields a reference to the value if the Result is `Ok`, otherwise it yields nothing. This is useful for treating a `Result` like an optional collection.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### Client Methods

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Core methods for interacting with the LLMOxide client.

```APIDOC
## Client

### Description
The main client for interacting with language model providers.

### Methods

#### `new(cfg: ClientConfig) -> Self`
Creates a new client instance with the provided configuration.

#### `provider(&self) -> &Provider`
Returns the kind of the configured provider.

#### `send(&self, req: ResponseRequest) -> Result<Response>`
Sends a request to the configured provider and returns the response.

#### `stream<F>(&self, req: ResponseRequest, on_event: F) -> Result<Response>`
Sends a request and streams the response events to a callback function.
- `F`: A closure that accepts an `Event` and is called for each event.

#### `list_models(&self) -> Result<Vec<ModelInfo>>`
Retrieves a list of available models from the configured provider.

#### `chat(&self, model: impl Into<String>) -> crate::chat::ChatSession<'_>`
Starts a new chat session with a specific model.

#### `chat_auto(&self) -> crate::chat::ChatSession<'_>`
Starts a new chat session with an automatically selected model.

#### `chat_from(&self, chat: crate::chat::Chat) -> crate::chat::ChatSession<'_>`
Starts a new chat session from an existing `Chat` object.
```

--------------------------------

### List Models

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/gemini.rs.html

Retrieves a list of available models from the Gemini provider. This method constructs the appropriate URL, sends an HTTP GET request, and parses the response to return a list of `ModelInfo` objects.

```APIDOC
## list_models

### Description
Retrieves a list of available models from the Gemini provider.

### Method
GET (Implicitly via `reqwest::Client`)

### Endpoint
Constructed dynamically using `Self::models_url(base_url, api_key)`

### Parameters
- `http`: `&reqwest::Client` - The HTTP client to use for the request.
- `api_key`: `&str` - The API key for authentication.
- `base_url`: `&str` - The base URL for the Gemini API.

### Response
- `Result<Vec<ModelInfo>>` - A future that resolves to a vector of `ModelInfo` structs on success, or an `Error` on failure.
```

--------------------------------

### Mutably Iterating over `Ok` values with `iter_mut`

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Use `iter_mut` to get a mutable iterator that yields a mutable reference to the value if the Result is `Ok`, otherwise it yields nothing. This allows in-place modification of the `Ok` value.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### into_ok

Source: https://docs.rs/llmoxide/latest/llmoxide/error/type.Result.html

Returns the contained Ok value, but never panics. This is a nightly-only experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. This method is known to never panic on the result types it is implemented for, making it a maintainability safeguard.

### Method
`into_ok()`

### Constraints
Requires that the error type `E` implements `Into<!>`.
This is a nightly-only experimental API.

### Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

--------------------------------

### ClientConfig for Ollama

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Configure the client to use the Ollama API. Requires a base URL for the Ollama server.

```rust
pub fn ollama(base_url: impl Into<String>) -> Self {
        Self {
            provider_kind: Provider::Ollama,
            provider: Arc::new(OllamaApi::new(base_url)),
        }
    }
```

--------------------------------

### ClientConfig for OpenAI

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Configure the client to use the OpenAI API. Requires an API key and specifies the API endpoint.

```rust
pub fn openai(api_key: impl Into<String>) -> Self {
        let api_key = api_key.into();
        Self {
            provider_kind: Provider::OpenAi,
            provider: Arc::new(OpenAiApi::new(
                api_key,
                "https://api.openai.com".to_string(),
            )),
        }
    }
```

--------------------------------

### List Models Method

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/trait.ProviderApi.html

Retrieves a list of available models from the language model provider.

```rust
fn list_models<'life0, 'life1, 'async_trait>(
        &'life0 self,
        http: &'life1 Client,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ModelInfo>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
```

--------------------------------

### Policy Or

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` policies return `Action::Follow`. Used for combining policies.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where
  T: Policy<B, E>,
  P: Policy<B, E>,

```

--------------------------------

### Ollama API Client Initialization

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/ollama.rs.html

Initializes a new Ollama API client with a specified base URL. This client is used to interact with the Ollama server.

```rust
pub fn new(base_url: impl Into<String>) -> Self {
        Self {
            base_url: base_url.into(),
        }
    }
```

--------------------------------

### Create a combined Policy (And)

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Creates a new `Policy` that requires both `self` and `other` policies to return `Action::Follow`. Useful for combining multiple conditions.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>,
```

--------------------------------

### CloneToUninit Method for Blanket CloneToUninit Implementation

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/openai/struct.OpenAiProvider.html

Presents the `clone_to_uninit` method, an experimental nightly-only API from the `CloneToUninit` blanket implementation.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)

```

--------------------------------

### ClientConfig for Ollama (Default)

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Configure the client to use the Ollama API with the default local URL.

```rust
pub fn ollama_default() -> Self {
        Self::ollama("http://localhost:11434".to_string())
    }
```

--------------------------------

### Policy And

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Creates a new `Policy` that returns `Action::Follow` only if both `self` and `other` policies return `Action::Follow`. Used for combining policies.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where
  T: Policy<B, E>,
  P: Policy<B, E>,

```

--------------------------------

### With Subscriber

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Attaches a `Subscriber` to the Prompt, returning a `WithDispatch` wrapper. Useful for integrating with observability systems.

```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
  S: Into<Dispatch>,

```

--------------------------------

### Sending a Prompt

Source: https://docs.rs/llmoxide/latest/index.html

Shows how to send a single user string prompt to the LLM.

```APIDOC
## Sending a Prompt

### Description
Send a single user string prompt to the LLM using the `Prompt` struct.

### Method
`Prompt::send(prompt: &str)`

### Parameters
- **prompt** (`&str`) - Required - The user's input string.

### Request Example
```rust
use llmoxide::Prompt;

let response = Prompt::send("What is the capital of France?");
```

### Response
#### Success Response
- **Response** - The LLM's response to the prompt.
```

--------------------------------

### Create New OllamaApi Instance

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/ollama/struct.OllamaApi.html

Instantiates a new OllamaApi with the provided base URL. This is the entry point for configuring the API client.

```rust
pub fn new(base_url: impl Into<String>) -> Self>
```

--------------------------------

### Chat Configuration

Source: https://docs.rs/llmoxide/latest/llmoxide/chat/struct.Chat.html

Methods for configuring the Chat instance.

```APIDOC
## `Chat::model(self, model: impl Into<String>) -> Self`

### Description
Sets the model for the Chat instance.

### Method
`model`

### Parameters
- `model` (impl Into<String>) - The model to set.
```

```APIDOC
## `Chat::max_output_tokens(self, max: u32) -> Self`

### Description
Sets the maximum number of output tokens for the Chat instance.

### Method
`max_output_tokens`

### Parameters
- `max` (u32) - The maximum number of output tokens.
```

```APIDOC
## `Chat::set_max_output_tokens(&mut self, max: u32) -> &mut Self`

### Description
Sets the maximum number of output tokens for the Chat instance.

### Method
`set_max_output_tokens`

### Parameters
- `max` (u32) - The maximum number of output tokens.
```

--------------------------------

### Prompt Clone Implementation

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Provides functionality to clone a Prompt instance.

```APIDOC
## impl Clone for Prompt

### `clone(&self) -> Prompt`
Returns a duplicate of the value.

### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.
```

--------------------------------

### Prompt Implementation: Request Generation

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Internal method to construct a ResponseRequest from a user prompt, applying configured model and max_output_tokens.

```rust
fn request(&self, user_prompt: impl Into<String>) -> ResponseRequest {
    let mut req = match &self.model {
        Some(m) => ResponseRequest::new(m.as_str()),
        None => ResponseRequest::new_auto(),
    };
    if let Some(max) = self.max_output_tokens {
        req = req.max_output_tokens(max);
    }
    req.push_message(Message::text(Role::User, user_prompt.into()))
}
```

--------------------------------

### Clone Prompt From Source

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Performs copy-assignment from a source Prompt to the current one. This is an efficient way to duplicate prompt states.

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

--------------------------------

### Clone Client from source

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Performs copy-assignment from a source Client to the current one. This is an optimization for in-place cloning.

```rust
fn clone_from(&mut self, source: &Self)>
```

--------------------------------

### GeminiApi Constructor

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/gemini/struct.GeminiApi.html

Creates a new instance of GeminiApi. Requires an API key and a base URL.

```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self
```

--------------------------------

### List Models

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Retrieve a list of available models from the configured language model provider.

```rust
pub async fn list_models(&self) -> Result<Vec<ModelInfo>> {
        self.cfg.provider.list_models(&self.http).await
    }
```

--------------------------------

### gemini

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Creates a new Prompt client configured for the Gemini provider.

```APIDOC
## gemini

### Description
Creates a new `Prompt` client configured for the Gemini provider.

### Function Signature
```rust
pub fn gemini(api_key: impl Into<String>) -> Prompt
```

### Parameters
* `api_key` (impl Into<String>): The API key for authenticating with Gemini.
```

--------------------------------

### Create a chat session from an existing chat

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Initializes a chat session from a pre-existing `Chat` object. This is useful for resuming or continuing a conversation.

```rust
pub fn chat_from(&self, chat: Chat) -> ChatSession<'_>
```

--------------------------------

### Prompt::list_models

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Retrieves a list of available models from the configured LLM provider.

```APIDOC
## Prompt::list_models

### Description
Retrieves a list of available models from the configured LLM provider.

### Method
```rust
pub async fn list_models(&self) -> Result<Vec<ModelInfo>>
```

### Returns
* `Result<Vec<ModelInfo>>`: A future that resolves to a vector of `ModelInfo` objects on success, or an `Error` on failure.
```

--------------------------------

### ResponseRequest Constructor and Builder Methods

Source: https://docs.rs/llmoxide/latest/llmoxide/types/struct.ResponseRequest.html

Provides methods for creating and configuring ResponseRequest instances.

```APIDOC
## Implementations

### impl ResponseRequest

#### pub fn new(model: impl Into<String>) -> Self
Creates a new `ResponseRequest` with the specified model.

#### pub fn new_auto() -> Self
Creates a new `ResponseRequest` with automatic model selection.

#### pub fn model(self, model: impl Into<String>) -> Self
Sets the model for the `ResponseRequest`.

#### pub fn push_message(self, message: Message) -> Self
Adds a message to the `ResponseRequest`.

#### pub fn max_output_tokens(self, max: u32) -> Self
Sets the maximum output tokens for the `ResponseRequest`.

#### pub fn tools(self, tools: Vec<ToolSpec>) -> Self
Sets the tool specifications for the `ResponseRequest`.
```

--------------------------------

### Model::new

Source: https://docs.rs/llmoxide/latest/llmoxide/types/struct.Model.html

Creates a new Model instance from any type that can be converted into a String.

```APIDOC
### impl Model

#### pub fn new(model: impl Into<String>) -> Self

Creates a new Model instance.
```

--------------------------------

### AnthropicApi::new

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/anthropic/struct.AnthropicApi.html

Constructs a new AnthropicApi instance. Requires an API key and a base URL for the Anthropic API.

```APIDOC
## AnthropicApi::new

### Description
Constructs a new `AnthropicApi` instance.

### Method
`pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self`

### Parameters
* `api_key`: An API key for authenticating with the Anthropic API. Can be any type that can be converted into a `String`.
* `base_url`: The base URL for the Anthropic API endpoint. Can be any type that can be converted into a `String`.
```

--------------------------------

### Anthropic API Client Constructor

Source: https://docs.rs/llmoxide/latest/src/llmoxide/providers/anthropic.rs.html

Creates a new AnthropicApi client with the provided API key and base URL. Ensures the base URL is properly formatted.

```rust
impl AnthropicApi {
    pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            base_url: base_url.into(),
        }
    }
}
```

--------------------------------

### Prompt::send

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Sends a single user prompt to the configured LLM and returns the response.

```APIDOC
## Prompt::send

### Description
Sends a single user string prompt to the LLM.

### Method
```rust
pub async fn send(&self, prompt: impl Into<String>) -> Result<Response>
```

### Parameters
* `prompt` (impl Into<String>): The user's input string.

### Returns
* `Result<Response>`: A future that resolves to a `Response` object on success, or an `Error` on failure.
```

--------------------------------

### Prompt Methods

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Methods available on the Prompt struct for interacting with language models.

```APIDOC
## Prompt Struct Methods

### `model(self, model: impl Into<String>) -> Self`
Sets the model to be used for the prompt.

### `max_output_tokens(self, max: u32) -> Self`
Sets the maximum number of output tokens for the response.

### `send(&self, prompt: impl Into<String>) -> Result<Response>`
Sends a single user string prompt and returns the model's response.

### `stream<F>(&self, prompt: impl Into<String>, on_event: F) -> Result<Response>`
Streams the response for a given prompt, invoking the `on_event` closure for each event.
`F` must implement `FnMut(Event)`.

### `list_models(&self) -> Result<Vec<ModelInfo>>`
Lists all available models that can be used.

### `client(&self) -> &Client`
Returns a reference to the underlying client.

### `into_client(self) -> Client`
Consumes the Prompt and returns the underlying client.
```

--------------------------------

### Response with_tool_calls() method

Source: https://docs.rs/llmoxide/latest/llmoxide/types/struct.Response.html

Creates a new Response instance by taking ownership of the current response and appending or replacing its tool calls.

```rust
pub fn with_tool_calls(self, tool_calls: Vec<ToolCall>) -> Self
```

--------------------------------

### Response metadata() method

Source: https://docs.rs/llmoxide/latest/llmoxide/types/struct.Response.html

Provides access to the provider-agnostic metadata associated with the response. This can include usage details, citations, or safety flags.

```rust
pub fn metadata(&self) -> &Value
```

--------------------------------

### ClientConfig for Gemini

Source: https://docs.rs/llmoxide/latest/src/llmoxide/client.rs.html

Configure the client to use the Gemini API. Requires an API key and specifies the API endpoint.

```rust
pub fn gemini(api_key: impl Into<String>) -> Self {
        let api_key = api_key.into();
        Self {
            provider_kind: Provider::Gemini,
            provider: Arc::new(GeminiApi::new(
                api_key,
                "https://generativelanguage.googleapis.com".to_string(),
            )),
        }
    }
```

--------------------------------

### Consume Prompt into Client

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Convert the Prompt struct into its underlying Client. This is useful when you need to take ownership of the client for further operations.

```rust
pub fn into_client(self) -> Client
```

--------------------------------

### Error::provide() (Nightly-only)

Source: https://docs.rs/llmoxide/latest/llmoxide/error/enum.Error.html

Experimental nightly-only API for providing type-based access to error context, intended for error reporting.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### Prompt Implementation: Stream

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Streams the LLM's response, invoking a callback function for each event.

```rust
pub async fn stream<F>(&self, prompt: impl Into<String>, on_event: F) -> Result<Response>
where
    F: FnMut(Event),
{
    self.client.stream(self.request(prompt), on_event).await
}
```

--------------------------------

### Clone to Uninit (Nightly)

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Nightly-only experimental API. Performs copy-assignment from the Prompt to an uninitialized memory location. Use with caution.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### anthropic

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Creates a new Prompt client configured for the Anthropic provider.

```APIDOC
## anthropic

### Description
Creates a new `Prompt` client configured for the Anthropic provider.

### Function Signature
```rust
pub fn anthropic(api_key: impl Into<String>) -> Prompt
```

### Parameters
* `api_key` (impl Into<String>): The API key for authenticating with Anthropic.
```

--------------------------------

### List Models

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/openai/struct.OpenAiProvider.html

This method allows you to list available models through the OpenAI API. It requires an HTTP client, an API key, and the base URL for the API.

```APIDOC
## list_models

### Description
Lists available models through the OpenAI API.

### Method Signature
`fn list_models(&self, http: &Client, api_key: &str, base_url: &str) -> impl Future<Output = Result<Vec<ModelInfo>>> + Send`

### Parameters
- `http` (*&Client*): An HTTP client instance.
- `api_key` (*&str*): The API key for authentication.
- `base_url` (*&str*): The base URL of the OpenAI API endpoint.

### Returns
A future that resolves to a `Result` containing a `Vec<ModelInfo>` on success, or an error on failure.
```

--------------------------------

### OpenAiApi Constructor

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/openai/struct.OpenAiApi.html

Creates a new instance of OpenAiApi with the provided API key and base URL.

```rust
pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self>
```

--------------------------------

### ollama_at Function Signature

Source: https://docs.rs/llmoxide/latest/llmoxide/fn.ollama_at.html

This function initializes an Ollama client with a specified base URL.

```APIDOC
## Function ollama_at

### Description
Initializes an Ollama client with a specified base URL.

### Signature
```rust
pub fn ollama_at(base_url: impl Into<String>) -> Prompt
```

### Parameters
* `base_url`: An object that can be converted into a String, representing the base URL of the Ollama instance.
```

--------------------------------

### Send a Single User Prompt

Source: https://docs.rs/llmoxide/latest/llmoxide/struct.Prompt.html

Use this method to send a single user string as a prompt to the language model. Ensure the Prompt struct is properly initialized.

```rust
pub async fn send(&self, prompt: impl Into<String>) -> Result<Response>
```

--------------------------------

### ollama

Source: https://docs.rs/llmoxide/latest/src/llmoxide/lib.rs.html

Creates a new Prompt client configured for the Ollama provider using the default endpoint.

```APIDOC
## ollama

### Description
Creates a new `Prompt` client configured for the Ollama provider using the default endpoint.

### Function Signature
```rust
pub fn ollama() -> Prompt
```
```

--------------------------------

### Generic Implementations for OpenAiApi

Source: https://docs.rs/llmoxide/latest/llmoxide/providers/openai/struct.OpenAiApi.html

Showcases blanket implementations for generic traits like Any, Borrow, CloneToUninit, Instrument, Into, PolicyExt, ToOwned, TryFrom, TryInto, and WithSubscriber.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
```

```rust
fn type_id(&self) -> TypeId>
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
```

```rust
fn borrow(&self) -> &T>
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
```

```rust
fn borrow_mut(&mut self) -> &mut T>
```

```rust
impl<T> CloneToUninit for T
where T: Clone,
```

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)>
```

```rust
impl<T, U> Into<U> for T
where U: From<T>,
```

```rust
fn into(self) -> U>
```

```rust
impl<T> PolicyExt for T
where T: ?Sized,
```

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>,
 P: Policy<B, E>,
```

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>,
 P: Policy<B, E>,
```

```rust
impl<T> ToOwned for T
where T: Clone,
```

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T>
```

```rust
fn clone_into(&self, target: &mut T)>
```

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
```

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error)>
```

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
```

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error)>
```

```rust
impl<T> WithSubscriber for T
```

```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,
```

--------------------------------

### Client::chat

Source: https://docs.rs/llmoxide/latest/llmoxide/client/struct.Client.html

Initializes a chat session for a specific model.

```APIDOC
## Client::chat

### Description
Initializes a chat session for a specific model.

### Signature
```rust
pub fn chat(&self, model: impl Into<String>) -> ChatSession<'_>
```
```
Tokens:
Raw