LangChain Rust

https://docs.rs/langchain-rust/latest/langchain_rust/
Admin
LangChain Rust is a Rust implementation of the LangChain framework that enables building...
Tokens:432,381
Snippets:4,148
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Document Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/schemas/document/struct.Document.html

Example demonstrating how to create and initialize a Document instance.

```APIDOC
## Usage

```rust
let my_doc = Document::new("This is the document content.".to_string())
   .with_metadata({
      let mut metadata = HashMap::new();
      metadata.insert("author".to_string(), json!("John Doe"));
      metadata
  })
   .with_score(0.75);
```
```

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

### Example run Method Implementation

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/trait.Tool.html

An example implementation of the `run` method for a tool, demonstrating how to process a string input and call another method for execution.

```rust
async fn run(&self, input: Value) -> Result<String, Box<dyn Error>> {
    let input_str = input.as_str().ok_or("Input should be a string")?;
    self.simple_search(input_str).await
}
```

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

### Execute Chain Method Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=

Demonstrates executing a chain to get the generation result formatted as a HashMap, including additional information like token consumption. The output key can be specified during chain building.

```rust
let llm = OpenAI::default().with_model(OpenAIModel::Gpt35);
let memory = SimpleMemory::new();

let chain = ConversationalChainBuilder::new()
    .llm(llm)
    .memory(memory.into())
    .output_key("name")
    .build().expect("Error building ConversationalChain");

let input_variables = prompt_args! {
    "input" => "Im from Peru",
};

match chain.execute(input_variables).await {
    Ok(result) => {
        println!("Result: {:?}", result);
    },
    Err(e) => panic!("Error executing Chain: {:?}", e),
};
```

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

### Example Usage

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/ollama/openai/struct.OllamaConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize and use OllamaConfig with OpenAI compatibility.

```APIDOC
## Example Usage

```rust
let ollama = OpenAI::new(OllamaConfig::default()).with_model("llama3.2");
let response = ollama.invoke("Say hello!").await.unwrap();
```
```

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

### Example Usage

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/ollama/openai/struct.OllamaConfig.html?search=std%3A%3Avec

Demonstrates how to initialize and use OllamaConfig with OpenAI compatibility.

```APIDOC
## Example Usage

### Description
This example shows how to create an `OpenAI` client using `OllamaConfig` and invoke a model.

### Code
```rust
let ollama = OpenAI::new(OllamaConfig::default()).with_model("llama3.2");
let response = ollama.invoke("Say hello!").await.unwrap();
```
```

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

### Document Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/schemas/document/struct.Document.html?search=std%3A%3Avec

Demonstrates how to create and initialize a Document instance.

```APIDOC
## Usage
```rust
let my_doc = Document::new("This is the document content.".to_string())
   .with_metadata({
      let mut metadata = HashMap::new();
      metadata.insert("author".to_string(), json!("John Doe"));
      metadata
  })
   .with_score(0.75);
```
```

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

### SQLDatabaseChain Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=std%3A%3Avec

This example demonstrates how to initialize and use the SQLDatabaseChain to query a PostgreSQL database. It shows setting up the LLM, database engine, and building the chain with specific options.

```APIDOC
## SQLDatabaseChain Usage Example

This example demonstrates how to initialize and use the SQLDatabaseChain to query a PostgreSQL database. It shows setting up the LLM, database engine, and building the chain with specific options.

### Setup

```rust
use langchain_rust::chain::sql_database::SQLDatabaseChainBuilder;
use langchain_rust::llm::openai::OpenAI;
use langchain_rust::prompt_args;
use langchain_rust::sql_database::PostgreSQLEngine;
use langchain_rust::sql_database::SQLDatabaseBuilder;
use langchain_rust::callbacks::ChainCallOptions;

async fn example() {
    let options = ChainCallOptions::default();
    let llm = OpenAI::default();

    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let engine = PostgreSQLEngine::new(&db_url).await.unwrap();
    let db = SQLDatabaseBuilder::new(engine).build().await.unwrap();

    let chain = SQLDatabaseChainBuilder::new()
        .llm(llm)
        .top_k(4)
        .database(db)
        .options(options)
        .build()
        .expect("Failed to build LLMChain");

    // Example of invoking the chain
    let input_variables = prompt_args! {
        "query" => "Whats the phone number of luis"
    };
    // OR using the prompt_builder
    // let input_variables = chain.prompt_builder()
    //     .query("Whats the phone number of luis")
    //     .build();

    match chain.invoke(input_variables).await {
        Ok(result) => {
            println!("Result: {:?}", result);
        }
        Err(e) => panic!("Error invoking LLMChain: {:?}", e),
    }
}
```

### Key Components

*   **`SQLDatabaseChainBuilder`**: Used to construct an instance of `SQLDatabaseChain`.
*   **`OpenAI`**: An example LLM implementation.
*   **`PostgreSQLEngine`**: Connects to a PostgreSQL database.
*   **`SQLDatabaseBuilder`**: Builds a representation of the SQL database.
*   **`ChainCallOptions`**: Default options for chain calls.
*   **`prompt_args!` macro**: A convenient way to create input variables for the chain.
*   **`invoke` method**: Executes the chain with the provided input variables.
```

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

### SystemMessagePromptTemplate Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/struct.SystemMessagePromptTemplate.html?search=u32+-%3E+bool

Example of how to create and use a SystemMessagePromptTemplate.

```APIDOC
## Usage Example

```rust
let system_message_prompt = SystemMessagePromptTemplate::new(
   template_fstring!(
      "System alert: {alert_type} {alert_detail}",
      "alert_type",
      "alert_detail"
   )
);
```
```

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

### Example Search Queries

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/struct.PromptTemplate.html?search=

Common example search queries for exploring Rust functionalities.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

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

### Call Chain Method Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=

Demonstrates calling a chain to get the generation result along with additional information like token consumption. Requires `PromptArgs` as input.

```rust
let llm = OpenAI::default().with_model(OpenAIModel::Gpt35);
let memory = SimpleMemory::new();

let chain = ConversationalChainBuilder::new()
    .llm(llm)
    .memory(memory.into())
    .build().expect("Error building ConversationalChain");

let input_variables = prompt_args! {
    "input" => "Im from Peru",
};

match chain.call(input_variables).await {
    Ok(result) => {
        println!("Result: {:?}", result);
    },
    Err(e) => panic!("Error calling Chain: {:?}", e),
};
```

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

### Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/schemas/messages/enum.MessageType.html

Example demonstrating how to instantiate different variants of the MessageType enum.

```APIDOC
## Usage

```rust
let system_message_type = MessageType::SystemMessage;
let ai_message_type = MessageType::AIMessage;
let human_message_type = MessageType::HumanMessage;
```
```

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

### VecStoreOptions Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/vectorstore/struct.VecStoreOptions.html?search=

Demonstrates how to create and configure VecStoreOptions using its builder pattern.

```APIDOC
## VecStoreOptions

### Description

The `VecStoreOptions` struct is responsible for determining options when interacting with a Vector Store. The options include `name_space`, `score_threshold`, `filters`, and `embedder`.

### Usage

```rust
let options = VecStoreOptions::new()
    .with_name_space("my_custom_namespace")
    .with_score_threshold(0.5)
    .with_filters(json!({"genre": "Sci-Fi"}))
    .with_embedder(my_embedder);
```

### Fields

*   `name_space: Option<String>`: Specifies a custom namespace for the vector store.
*   `score_threshold: Option<f32>`: Sets a threshold for similarity scores.
*   `filters: Option<Value>`: Allows filtering of results based on provided criteria.
*   `embedder: Option<Arc<dyn Embedder>>`: An optional embedder to use for generating embeddings.
```

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

### Default OllamaConfig Initialization

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/ollama/openai/struct.OllamaConfig.html

Demonstrates how to get a default OllamaConfig instance. This is typically used as a starting point before customizing with specific API keys or base URLs.

```rust
pub fn default() -> Self
```

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

### HumanMessagePromptTemplate Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/struct.HumanMessagePromptTemplate.html?search=u32+-%3E+bool

An example demonstrating how to create and use a HumanMessagePromptTemplate.

```APIDOC
## Usage Example

```rust
let human_message_prompt = HumanMessagePromptTemplate::new(template_fstring!(
   "User says: {content}",
   "content",
));
```
```

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

### VecStoreOptions Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/vectorstore/struct.VecStoreOptions.html?search=u32+-%3E+bool

Demonstrates how to create and configure VecStoreOptions using its builder pattern methods.

```APIDOC
## VecStoreOptions

### Description
The `VecStoreOptions` struct is responsible for determining options when interacting with a Vector Store. The options include `name_space`, `score_threshold`, `filters`, and `embedder`.

### Usage
```rust
let options = VecStoreOptions::new()
    .with_name_space("my_custom_namespace")
    .with_score_threshold(0.5)
    .with_filters(json!({"genre": "Sci-Fi"}))
    .with_embedder(my_embedder);
```

### Fields
- `name_space`: `Option<String>` - Specifies a namespace for the vector store.
- `score_threshold`: `Option<f32>` - Sets a threshold for similarity scores.
- `filters`: `Option<Value>` - Allows filtering of results based on metadata.
- `embedder`: `Option<Arc<dyn Embedder>>` - Provides a custom embedder implementation.

### Methods
#### `new()`
Creates a new instance of `VecStoreOptions`.

#### `with_name_space<S: Into<String>>(self, name_space: S) -> Self`
Sets the `name_space` option.

#### `with_score_threshold(self, score_threshold: f32) -> Self`
Sets the `score_threshold` option.

#### `with_filters(self, filters: Value) -> Self`
Sets the `filters` option.

#### `with_embedder<E: Embedder + 'static>(self, embedder: E) -> Self`
Sets the `embedder` option.
```

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

### HumanMessagePromptTemplate Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/struct.HumanMessagePromptTemplate.html?search=std%3A%3Avec

Example of how to instantiate and use HumanMessagePromptTemplate.

```APIDOC
## Usage Example

```rust
let human_message_prompt = HumanMessagePromptTemplate::new(
   template_fstring!(
      "User says: {content}",
      "content",
   )
);
```
```

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

### Message Usage Examples

Source: https://docs.rs/langchain-rust/latest/langchain_rust/schemas/messages/struct.Message.html?search=u32+-%3E+bool

Demonstrates how to create different types of messages using the provided constructor functions.

```rust
let human_message = Message::new_human_message("Hello");
let system_message = Message::new_system_message("System Alert");
let ai_message = Message::new_ai_message("AI Response");
```

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

### Initialize Ollama with OpenAI Compatibility

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/ollama/openai/struct.OllamaConfig.html

Example of creating an Ollama client using OllamaConfig and specifying a model. This is useful for interacting with Ollama models through an OpenAI-compatible interface.

```rust
let ollama = OpenAI::new(OllamaConfig::default()).with_model("llama3.2");
let response = ollama.invoke("Say hello!").await.unwrap();
```

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

### SerpApi Initialization and Configuration

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.SerpApi.html?search=std%3A%3Avec

Demonstrates how to initialize the SerpApi tool with an API key and configure optional parameters like location, language, and Google domain.

```APIDOC
## SerpApi Initialization and Configuration

### Description
Initialize the SerpApi tool with your API key and configure various settings to tailor your search queries.

### Methods

#### `new(api_key: String) -> Self`
Creates a new instance of the SerpApi tool with the provided API key.

#### `with_location<S: Into<String>>(self, location: S) -> Self`
Sets the location for the search queries.

#### `with_hl<S: Into<String>>(self, hl: S) -> Self`
Sets the host language for the search results.

#### `with_gl(self, gl: String) -> Self`
Sets the Google domain for the search.

#### `with_google_domain<S: Into<String>>(self, google_domain: S) -> Self`
Sets the Google domain for the search.

#### `with_api_key<S: Into<String>>(self, api_key: S) -> Self`
Sets or updates the API key for the SerpApi tool.

### Example
```rust
use langchain_rust::tools::SerpApi;

let serpapi_tool = SerpApi::new("YOUR_API_KEY".to_string())
    .with_location("us")
    .with_hl("en")
    .with_google_domain("google.com");
```
```

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

### SQLDatabaseChain Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=

Demonstrates how to set up and use the SQLDatabaseChain to query a database using natural language. It includes setting up the database engine, building the chain, and invoking it with a query.

```APIDOC
## SQLDatabaseChain Usage Example

This example shows how to initialize and use the `SQLDatabaseChain` to interact with a SQL database using natural language queries.

### Setup

1.  **Initialize LLM**: Set up your language model (e.g., `OpenAI`).
2.  **Initialize Database Engine**: Create a database engine (e.g., `PostgreSQLEngine`) using a connection URL.
3.  **Build SQLDatabase**: Construct the `SQLDatabase` object from the engine.
4.  **Build SQLDatabaseChain**: Use `SQLDatabaseChainBuilder` to configure and build the chain, providing the LLM, database, and other options.

### Invocation

1.  **Prepare Input Variables**: Create a `PromptArgs` map with the key `"query"` and your natural language question as the value.
2.  **Invoke Chain**: Call the `invoke` method on the built chain with the input variables.
3.  **Handle Result**: Process the `Result` which can be either the generated output string or a `ChainError`.

```rust
use langchain_rust::chain::sql_database::{SQLDatabase, SQLDatabaseChainBuilder};
use langchain_rust::chain::{Chain, ChainCallOptions};
use langchain_rust::llm::openai::OpenAI;
use langchain_rust::sql::postgres::PostgreSQLEngine;
use langchain_rust::prompt_args;
use std::env;

async fn example() {
    let options = ChainCallOptions::default();
    let llm = OpenAI::default();

    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let engine = PostgreSQLEngine::new(&db_url).await.unwrap();
    let db = SQLDatabase::new(engine).await.unwrap();

    let chain = SQLDatabaseChainBuilder::new()
        .llm(llm)
        .top_k(4)
        .database(db)
        .options(options)
        .build()
        .expect("Failed to build SQLDatabaseChain");

    // Using prompt_args! macro
    let input_variables = prompt_args! {
        "query" => "Whats the phone number of luis"
    };

    // Alternatively, using the prompt_builder
    // let input_variables = chain.prompt_builder()
    //     .query("Whats the phone number of luis")
    //     .build();

    match chain.invoke(input_variables).await {
        Ok(result) => {
            println!("Result: {:?}", result);
        }
        Err(e) => {
            panic!("Error invoking SQLDatabaseChain: {:?}", e);
        }
    }
}
```
```

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

### SerpApi Constructor and Configuration

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.SerpApi.html

Demonstrates how to create a SerpApi instance and configure it with various options.

```APIDOC
## SerpApi Initialization and Configuration

### `new(api_key: String) -> Self`

Creates a new `SerpApi` instance with the provided API key.

### `with_location<S: Into<String>>(self, location: S) -> Self`

Sets the location for the search queries.

### `with_hl<S: Into<String>>(self, hl: S) -> Self`

Sets the host language for the search results.

### `with_gl(self, gl: String) -> Self`

Sets the Google domain for the search.

### `with_google_domain<S: Into<String>>(self, google_domain: S) -> Self`

Sets the Google domain for the search.

### `with_api_key<S: Into<String>>(self, api_key: S) -> Self`

Sets or updates the API key for the SerpApi client.
```

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

### Create a new AzureConfig

Source: https://docs.rs/langchain-rust/latest/langchain_rust/embedding/openai/openai_embedder/struct.AzureConfig.html

Initializes a new AzureConfig instance with default settings. This is the starting point for configuring Azure OpenAI.

```rust
pub fn new() -> AzureConfig>
```

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

### Claude Initialization and Configuration

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/claude/struct.Claude.html?search=

Demonstrates how to create and configure a Claude client instance.

```APIDOC
## Claude Struct Methods

### `new()`

Creates a new `Claude` instance with default settings.

### `with_model(model: S)`

Sets the specific Claude model to use.

### `with_options(options: CallOptions)`

Applies custom call options to the `Claude` instance.

### `with_api_key(api_key: S)`

Provides the API key for authentication.

### `with_anthropic_version(version: S)`

Specifies the Anthropic API version to use.
```

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

### SerpApi Initialization

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.SerpApi.html?search=

Demonstrates how to initialize the SerpApi tool with an API key and optional location settings.

```APIDOC
## SerpApi Initialization

### Description
Initializes the SerpApi tool with your SerpApi API key. You can also optionally set a location and preferred Google domain.

### Methods

#### `new(api_key: String) -> Self`
Creates a new instance of the SerpApi tool with the provided API key.

#### `with_location<S: Into<String>>(self, location: S) -> Self`
Sets the location for the search queries.

#### `with_hl<S: Into<String>>(self, hl: S) -> Self`
Sets the host language for the search results.

#### `with_gl(self, gl: String) -> Self`
Sets the Google domain for the search.

#### `with_google_domain<S: Into<String>>(self, google_domain: S) -> Self`
Sets the Google domain for the search.

#### `with_api_key<S: Into<String>>(self, api_key: S) -> Self`
Sets or updates the API key for the SerpApi tool.

### Example
```rust
let serpapi = SerpApi::new("YOUR_SERPAPI_KEY".to_string())
    .with_location("us".to_string())
    .with_hl("en".to_string());
```
```

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

### RouteLayerBuilder Usage Example

Source: https://docs.rs/langchain-rust/latest/langchain_rust/semantic_router/struct.RouteLayerBuilder.html

This example demonstrates how to use RouteLayerBuilder to create a RouteLayer with custom routes, an embedder, aggregation method, and threshold.

```APIDOC
## RouteLayerBuilder

### Description
A builder for creating a `RouteLayer`.

### Example
```rust
 let captial_route = Router::new(
     "captial",
     &[
         "Capital of France is Paris.",
         "What is the captial of France?",
     ],
 );
 let weather_route = Router::new(
     "temperature",
     &[
         "What is the temperature?",
         "Is it raining?",
         "Is it cloudy?",
     ],
 );
 let router_layer = RouteLayerBuilder::default()
     .embedder(OpenAiEmbedder::default())
     .add_route(captial_route)
     .add_route(weather_route)
     .aggregation_method(AggregationMethod::Sum)
     .threshold(0.82)
     .build()
     .await
     .unwrap();
```

## Methods

### `new()`

```rust
pub fn new() -> Self
```

### `top_k(self, top_k: usize) -> Self`

Sets the top-k value for route selection.

### `llm<L: LLM + 'static>(self, llm: L) -> Self`

Sets the LLM to be used with the RouteLayer.

### `index<I: Index + 'static>(self, index: I) -> Self`

Sets the index to be used with the RouteLayer.

### `embedder<E: Embedder + 'static>(self, embedder: E) -> Self`

Sets the embedder to be used for generating embeddings.

### `threshold(self, threshold: f64) -> Self`

The threshold is the minimum similarity score that a route must have to be considered. This depends on the similarity metric used by the embedder. For open ai text-embedding-ada-002, the best threshold is 0.82

### `add_route(self, route: Router) -> Self`

Adds a `Router` to the RouteLayer.

### `aggregation_method(self, aggregation_method: AggregationMethod) -> Self`

Sets the aggregation method for combining scores from multiple routes.

### `build(self) -> Result<RouteLayer, RouteLayerBuilderError>`

Builds the `RouteLayer` instance. This is an asynchronous operation.

## Default Implementation

### `default()`

```rust
fn default() -> Self
```

Returns the default value for `RouteLayerBuilder`.
```

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

### Creating and Configuring VecStoreOptions

Source: https://docs.rs/langchain-rust/latest/langchain_rust/vectorstore/struct.VecStoreOptions.html?search=u32+-%3E+bool

Demonstrates how to instantiate and configure VecStoreOptions using a builder pattern. Use this to set specific parameters for vector store queries.

```rust
let options = VecStoreOptions::new()
    .with_name_space("my_custom_namespace")
    .with_score_threshold(0.5)
    .with_filters(json!({"genre": "Sci-Fi"}))
    .with_embedder(my_embedder);
```

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

### Get multiple mutable references unchecked from HashMap

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/type.PromptArgs.html?search=std%3A%3Avec

Attempts to get mutable references to multiple values without validating uniqueness. Undefined behavior if keys overlap.

```rust
use std::collections::HashMap;

let mut libraries = HashMap::new();
libraries.insert("Bodleian Library".to_string(), 1602);
libraries.insert("Athenæum".to_string(), 1807);

// Get mutable references to two values
let got = libraries.get_disjoint_unchecked_mut([
    "Bodleian Library",
    "Athenæum",
]);
assert_eq!(
    got,
    [
        Some(&mut 1602),
        Some(&mut 1807),
    ],
);
```

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

### Wolfram::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.Wolfram.html?search=u32+-%3E+bool

Constructs a new Wolfram tool instance. Requires an application ID for authentication.

```APIDOC
## Wolfram::new

### Description
Constructs a new Wolfram tool instance, requiring an application ID.

### Signature
`pub fn new(app_id: String) -> Self`

### Parameters
* `app_id` (String) - The application ID for Wolfram Alpha.
```

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

### Example Usage of message_formatter Macro

Source: https://docs.rs/langchain-rust/latest/langchain_rust/macro.message_formatter.html?search=

Demonstrates how to use the message_formatter macro to create a message formatter with different message types and placeholders.

```rust
// Create an AI message prompt template
let ai_message_prompt = AIMessagePromptTemplate::new(
    template_fstring!(
        "AI response: {content} {test}",
        "content",
        "test"
    )
);


let human_msg = Message::new_human_message("Hello from user");

// Use the `message_formatter` macro to construct the formatter.
let formatter = message_formatter![
    fmt_message!(human_msg),
    fmt_template!(ai_message_prompt),
    fmt_placeholder!("history")
];
```

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

### SQLDatabaseChain Setup and Invocation

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=u32+-%3E+bool

Demonstrates how to set up and use the SQLDatabaseChain to query a PostgreSQL database. Ensure the DATABASE_URL environment variable is set. The chain can be invoked using either a direct prompt or a prompt builder.

```rust
let options = ChainCallOptions::default();
let llm = OpenAI::default();

let db = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let engine = PostgreSQLEngine::new(&db).await.unwrap();
let db = SQLDatabaseBuilder::new(engine).build().await.unwrap();
let chain = SQLDatabaseChainBuilder::new()
    .llm(llm)
    .top_k(4)
    .database(db)
    .options(options)
    .build()
    .expect("Failed to build LLMChain");

let input_variables = prompt_args! {
    "query" => "Whats the phone number of luis"
  };
  //OR
let input_variables = chain.prompt_builder()
    .query("Whats the phone number of luis")
    .build();
match chain.invoke(input_variables).await {
   Ok(result) => {
    println!("Result: {:?}", result);
}
Err(e) => panic!("Error invoking LLMChain: {:?}", e),
}

}
```

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

### Router Constructor and With Methods

Source: https://docs.rs/langchain-rust/latest/langchain_rust/semantic_router/struct.Router.html?search=std%3A%3Avec

Provides methods for creating and configuring a Router instance. `new` initializes a router with a name and utterances, while `with_embedding`, `with_tool_description`, and `with_similarity` allow for chaining configurations.

```APIDOC
### impl Router

#### pub fn new<S: AsRef<str>>(name: &str, utterances: &[S]) -> Self
Creates a new Router instance.

#### pub fn with_embedding(self, embedding: Vec<Vec<f64>>) -> Self
Sets the embedding vectors for the router.

#### pub fn with_tool_description<S: Into<String>>(self, tool_description: S) -> Self
Sets the tool description for the router.

#### pub fn with_similarity(self, similarity: f64) -> Self
Sets the similarity threshold for the router.
```

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

### Get multiple mutable references from HashMap

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/type.PromptArgs.html?search=std%3A%3Avec

Attempts to get mutable references to multiple values simultaneously. Returns an array of Option<&mut V>. Panics if keys overlap.

```rust
use std::collections::HashMap;

let mut libraries = HashMap::new();
libraries.insert("Bodleian Library".to_string(), 1602);
libraries.insert("Athenæum".to_string(), 1807);
libraries.insert("Herzogin-Anna-Amalia-Bibliothek".to_string(), 1691);
libraries.insert("Library of Congress".to_string(), 1800);

// Get Athenæum and Bodleian Library
let [Some(a), Some(b)] = libraries.get_disjoint_mut([
    "Athenæum",
    "Bodleian Library",
]) else { panic!() };

// Assert values of Athenæum and Library of Congress
let got = libraries.get_disjoint_mut([
    "Athenæum",
    "Library of Congress",
]);
assert_eq!(
    got,
    [
        Some(&mut 1807),
        Some(&mut 1800),
    ],
);

// Missing keys result in None
let got = libraries.get_disjoint_mut([
    "Athenæum",
    "New York Public Library",
]);
assert_eq!(
    got,
    [
        Some(&mut 1807),
        None
    ]
);
```

```rust
use std::collections::HashMap;

let mut libraries = HashMap::new();
libraries.insert("Athenæum".to_string(), 1807);

// Duplicate keys panic!
let got = libraries.get_disjoint_mut([
    "Athenæum",
    "Athenæum",
]);
```

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

### Any::type_id

Source: https://docs.rs/langchain-rust/latest/langchain_rust/embedding/openai/openai_embedder/struct.OpenAiEmbedder.html?search=std%3A%3Avec

Gets the `TypeId` of the implementing type.

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

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

### SQLDatabaseChain::get_output_keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the output keys for the chain.

```APIDOC
## SQLDatabaseChain::get_output_keys

### Description
Get the output keys for the chain. These are the keys under which the generated output will be stored in the result `HashMap` when using the `execute` method.

### Method
`get_output_keys`

### Response
#### Success Response
- **Vec<String>** - A vector of strings, where each string is an output key name.
```

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

### StuffQAPromptBuilder::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/struct.StuffQAPromptBuilder.html

Creates a new instance of StuffQAPromptBuilder.

```APIDOC
## StuffQAPromptBuilder::new

### Description
Creates a new instance of `StuffQAPromptBuilder`.

### Method
```rust
pub fn new() -> Self
```
```

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

### SQLDatabaseChain::get_input_keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the input keys for the chain.

```APIDOC
## SQLDatabaseChain::get_input_keys

### Description
Get the input keys for the chain. These are the expected variable names that should be provided in the `PromptArgs` when invoking the chain.

### Method
`get_input_keys`

### Response
#### Success Response
- **Vec<String>** - A vector of strings, where each string is an input key name.
```

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

### StuffQAPromptBuilder::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/struct.StuffQAPromptBuilder.html?search=

Creates a new instance of StuffQAPromptBuilder.

```APIDOC
## StuffQAPromptBuilder::new

### Description
Creates a new instance of `StuffQAPromptBuilder`.

### Method
`pub fn new() -> Self`
```

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

### Get Multiple Mutable References Unchecked

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/type.PromptArgs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to get mutable references to multiple values in the map at once, without validating that the values are unique. Returns an array of `Option<&mut V>` with the results. `None` is used if a key is missing. This is an unsafe alternative to `get_disjoint_mut`.

```rust
pub unsafe fn get_disjoint_unchecked_mut<Q, const N: usize>( &mut self, ks: [&Q; N], ) -> [Option<&mut V>; N]
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Attempts to get mutable references to `N` values in the map at once, without validating that the values are unique.
Returns an array of length `N` with the results of each query. `None` will be used if the key is missing.
For a safe alternative see `get_disjoint_mut`.
##### §Safety
Calling this method with overlapping keys is _undefined behavior_ even if the resulting references are not used.
```

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

### Usage Example of template_jinja2 Macro

Source: https://docs.rs/langchain-rust/latest/langchain_rust/macro.template_jinja2.html

Demonstrates how to use the template_jinja2 macro to create a PromptTemplate with a Jinja2 template string and variables. The macro returns a PromptTemplate object configured for Jinja2.

```rust
template_jinja2!(
    "Hello {{ name }}",
    "name"
)
```

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

### Tokenizer Utility

Source: https://docs.rs/langchain-rust/latest/langchain_rust/text_splitter/struct.SplitterOptions.html?search=u32+-%3E+bool

A utility function to get a tokenizer from a string.

```APIDOC
#### `get_tokenizer_from_str(s: &str) -> Option<Tokenizer>`

Attempts to create a `Tokenizer` instance from a given string. Returns `None` if the string is not a valid tokenizer name.
```

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

### Using message_formatter Macro

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/macro.message_formatter.html?search=u32+-%3E+bool

This example demonstrates how to create an AI message prompt template and then use the `message_formatter` macro to construct a formatter. It includes formatting a human message, an AI message prompt template, and a placeholder.

```rust
use langchain_rust::prompt::{AIMessagePromptTemplate, Message, template_fstring};
use langchain_rust::prompt::message_formatter::{fmt_message, fmt_template, fmt_placeholder};

// Create an AI message prompt template
let ai_message_prompt = AIMessagePromptTemplate::new(
    template_fstring!(
        "AI response: {content} {test}",
        "content",
        "test"
    )
);


let human_msg = Message::new_human_message("Hello from user");

// Use the `message_formatter` macro to construct the formatter.
let formatter = message_formatter![
    fmt_message!(human_msg),
    fmt_template!(ai_message_prompt),
    fmt_placeholder!("history")
];
```

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

### SplitterOptions::get_tokenizer_from_str()

Source: https://docs.rs/langchain-rust/latest/langchain_rust/text_splitter/struct.SplitterOptions.html?search=std%3A%3Avec

Attempts to get a Tokenizer from a string representation.

```APIDOC
## pub fn get_tokenizer_from_str(s: &str) -> Option<Tokenizer>

Attempts to get a Tokenizer from a string representation.
```

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

### OpenAI Constructor and Configuration Methods

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/openai/struct.OpenAI.html?search=

Provides methods to create and configure an OpenAI client instance.

```rust
pub fn new(config: C) -> Self
```

```rust
pub fn with_model<S: Into<String>>(self, model: S) -> Self
```

```rust
pub fn with_config(self, config: C) -> Self
```

```rust
pub fn with_options(self, options: CallOptions) -> Self
```

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

### SQLDatabaseChain::prompt_builder

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get a builder for constructing the prompt for the SQLDatabaseChain.

```APIDOC
## SQLDatabaseChain::prompt_builder

### Description
Get a builder for constructing the prompt for the SQLDatabaseChain. This allows for a more fluent way to set the input variables for the chain.

### Method
`prompt_builder`

### Response
#### Success Response
- **SqlChainPromptBuilder** - An instance of `SqlChainPromptBuilder` that can be used to build the prompt arguments.
```

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

### OpenAI::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/openai/struct.OpenAI.html?search=std%3A%3Avec

Creates a new instance of the OpenAI client with the provided configuration.

```APIDOC
## OpenAI::new

```rust
pub fn new(config: C) -> Self
```

### Description
Creates a new instance of the OpenAI client with the provided configuration.
```

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

### Get Output Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=u32+-%3E+bool

Retrieves the output keys for the chain.

```APIDOC
## fn get_output_keys(&self) -> Vec<String>

### Description
Returns a vector of strings representing the output keys for the chain.

### Method
`get_output_keys`

### Parameters
None

### Response
- Type: `Vec<String>` - Description: A vector containing the names of the output keys.
```

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

### OpenAI Constructor and Configuration

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/openai/struct.OpenAI.html

Methods for creating and configuring an OpenAI client. Use `new` for basic initialization, `with_model` to specify a model, `with_config` to provide custom configuration, and `with_options` to set call-specific options.

```rust
pub fn new(config: C) -> Self>
```

```rust
pub fn with_model<S: Into<String>>(self, model: S) -> Self>
```

```rust
pub fn with_config(self, config: C) -> Self>
```

```rust
pub fn with_options(self, options: CallOptions) -> Self>
```

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

### Get Input Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=u32+-%3E+bool

Retrieves the input keys for the chain.

```APIDOC
## fn get_input_keys(&self) -> Vec<String>

### Description
Returns a vector of strings representing the input keys for the chain.

### Method
`get_input_keys`

### Parameters
None

### Response
- Type: `Vec<String>` - Description: A vector containing the names of the input keys.
```

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

### SerpApi Constructor

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.SerpApi.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new instance of the SerpApi tool with the provided API key.

```APIDOC
## SerpApi::new

### Description
Creates a new SerpApi tool instance with the given API key.

### Signature
```rust
pub fn new(api_key: String) -> Self
```

### Parameters
* `api_key` (String) - The API key for authenticating with SerpApi.
```

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

### Creating and Customizing a Document

Source: https://docs.rs/langchain-rust/latest/langchain_rust/schemas/document/struct.Document.html

Demonstrates how to create a new Document instance and customize its metadata and score using builder-like methods.

```rust
let my_doc = Document::new("This is the document content.".to_string())
   .with_metadata({
      let mut metadata = HashMap::new();
      metadata.insert("author".to_string(), json!("John Doe"));
      metadata
  })
   .with_score(0.75);
```

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

### Get Text2SpeechOpenAI Tool Name

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.Text2SpeechOpenAI.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the name of the Text2SpeechOpenAI tool.

```rust
fn name(&self) -> String>
```

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

### Build QA Prompt with StuffDocument

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/struct.StuffDocument.html?search=u32+-%3E+bool

After initializing StuffDocument, use `qa_prompt_builder` to construct a prompt. This builder allows you to provide documents and a question, then `build` the final prompt for invocation.

```rust
let input = chain
.qa_prompt_builder()
.documents(&[
Document::new(format!(
"\nQuestion: {}\nAnswer: {}\n",
"Which is the favorite text editor of luis", "Nvim"
)),
Document::new(format!(
"\nQuestion: {}\nAnswer: {}\n",
"How old is Luis", "24"
)),
])
.question("How old is luis and whats his favorite text editor")
.build();
```

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

### Tokenizer Retrieval

Source: https://docs.rs/langchain-rust/latest/langchain_rust/text_splitter/struct.SplitterOptions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A utility method to get a tokenizer based on a string.

```APIDOC
## `get_tokenizer_from_str(s: &str) -> Option<Tokenizer>`

### Description
Attempts to retrieve a `Tokenizer` instance based on the provided string identifier.

### Parameters
* `s` (&str) - The string representing the tokenizer configuration.

### Returns
* `Option<Tokenizer>` - `Some(Tokenizer)` if successful, `None` otherwise.
```

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

### Get Template String

Source: https://docs.rs/langchain-rust/latest/langchain_rust/prompt/struct.PromptTemplate.html

Returns the template string associated with the PromptTemplate.

```rust
fn template(&self) -> String
```

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

### OpenAI::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/openai/struct.OpenAI.html

Creates a new OpenAI client with the provided configuration.

```APIDOC
## OpenAI::new

```rust
pub fn new(config: C) -> Self
```

Creates a new OpenAI client with the provided configuration.
```

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

### Get Output Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=

Retrieves the keys that the chain produces as output.

```APIDOC
#### fn get_output_keys(&self) -> Vec<String>

### Description
Returns the output keys for the chain.

### Method
GET (conceptual)

### Endpoint
None provided (method signature)

### Parameters
None

### Request Example
None provided

### Response
#### Success Response (200)
- **Vec<String>** - A vector of strings representing the output keys.

#### Response Example
None provided.
```

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

### Load StuffDocument for QA

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/struct.StuffDocument.html

Initializes a StuffDocument with a default prompt suitable for question answering. Requires an LLM instance.

```rust
let llm = OpenAI::default();
let chain = StuffDocument::load_stuff_qa(llm);
```

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

### SimpleParser::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/output_parsers/struct.SimpleParser.html?search=

Creates a new instance of SimpleParser with default settings.

```APIDOC
## SimpleParser::new

### Description
Creates a new instance of `SimpleParser`.

### Method
`pub fn new() -> Self`

### Returns
A new `SimpleParser` instance.
```

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

### Get Input Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=

Retrieves the keys that the chain expects as input.

```APIDOC
#### fn get_input_keys(&self) -> Vec<String>

### Description
Returns the input keys for the chain.

### Method
GET (conceptual)

### Endpoint
None provided (method signature)

### Parameters
None

### Request Example
None provided

### Response
#### Success Response (200)
- **Vec<String>** - A vector of strings representing the input keys.

#### Response Example
None provided.
```

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

### Get SQLDatabase Dialect

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.SQLDatabase.html

Retrieves the SQL dialect used by the database connection.

```rust
pub fn dialect(&self) -> Dialect
```

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

### ConversationalChain::stream

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/conversational/struct.ConversationalChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Streams the Chain and gets an asynchronous stream of chain generations.

```APIDOC
## Chain::stream for ConversationalChain

```rust
fn stream<'life0, 'async_trait>(
    &'life0 self,
    input_variables: PromptArgs,
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<StreamData, ChainError>> + Send>>, ChainError>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

**Description**: Provides an asynchronous stream of chain generations. The input is a set of variables passed as a `PromptArgs` hashmap. Note that if the chain has memory, the `stream` method may not automatically set the memory as it cannot determine how to extract the output message from the stream.

**Parameters**:

*   `input_variables` (`PromptArgs`): A hashmap containing the variables required for the prompt.
```

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

### OpenAI::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/llm/openai/struct.OpenAI.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the OpenAI LLM client with the provided configuration.

```APIDOC
## fn new(config: C) -> Self

Creates a new instance of the OpenAI LLM client with the provided configuration.
```

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

### Get Output Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=std%3A%3Avec

Retrieves the names of the output keys that the chain produces.

```APIDOC
## fn get_output_keys(&self) -> Vec<String>

### Description
Returns a vector of strings representing the output keys produced by the chain.

### Method
GET

### Endpoint
N/A (Method on a trait object)

### Parameters
None

### Response
#### Success Response (200)
- **Vec<String>** - A vector containing the names of the output keys.
```

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

### Get Input Keys

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/chain_trait/trait.Chain.html?search=std%3A%3Avec

Retrieves the names of the input keys that the chain expects.

```APIDOC
## fn get_input_keys(&self) -> Vec<String>

### Description
Returns a vector of strings representing the expected input keys for the chain.

### Method
GET

### Endpoint
N/A (Method on a trait object)

### Parameters
None

### Response
#### Success Response (200)
- **Vec<String>** - A vector containing the names of the input keys.
```

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

### SQLDatabaseChain Usage

Source: https://docs.rs/langchain-rust/latest/langchain_rust/chain/sql_datbase/struct.SQLDatabaseChain.html

This example demonstrates how to build and invoke a SQLDatabaseChain. It sets up an OpenAI LLM, a PostgreSQL database engine, and then builds the chain with specified options. Finally, it invokes the chain with a natural language query and prints the result.

```APIDOC
## SQLDatabaseChain Usage

### Description
This example demonstrates how to build and invoke a SQLDatabaseChain. It sets up an OpenAI LLM, a PostgreSQL database engine, and then builds the chain with specified options. Finally, it invokes the chain with a natural language query and prints the result.

### Method
```rust
let options = ChainCallOptions::default();
let llm = OpenAI::default();

let db = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let engine = PostgreSQLEngine::new(&db).await.unwrap();
let db = SQLDatabaseBuilder::new(engine).build().await.unwrap();
let chain = SQLDatabaseChainBuilder::new()
    .llm(llm)
    .top_k(4)
    .database(db)
    .options(options)
    .build()
    .expect("Failed to build LLMChain");

let input_variables = prompt_args! {
    "query" => "Whats the phone number of luis"
  };
  //OR
let input_variables = chain.prompt_builder()
    .query("Whats the phone number of luis")
    .build();
match chain.invoke(input_variables).await {
   Ok(result) => {
    println!("Result: {:?}", result);
}
Err(e) => panic!("Error invoking LLMChain: {:?}", e),
}
```

### Prompt Builder

#### Method
```rust
pub fn prompt_builder(&self) -> SqlChainPromptBuilder
```

### Chain Trait Implementations

#### `get_input_keys`

##### Method
```rust
fn get_input_keys(&self) -> Vec<String>
```

#### `call`

##### Description
Call the `Chain` and receive as output the result of the generation process along with additional information like token consumption. The input is a set of variables passed as a `PromptArgs` hashmap.

##### Method
```rust
fn call<'life0, 'async_trait>(
    &'life0 self,
    input_variables: PromptArgs,
) -> Pin<Box<dyn Future<Output = Result<GenerateResult, ChainError>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

#### `invoke`

##### Description
Invoke the `Chain` and receive just the generation result as a String. The input is a set of variables passed as a `PromptArgs` hashmap.

##### Method
```rust
fn invoke<'life0, 'async_trait>(
    &'life0 self,
    input_variables: PromptArgs,
) -> Pin<Box<dyn Future<Output = Result<String, ChainError>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

#### `stream`

##### Description
Stream the `Chain` and get an asynchronous stream of chain generations. The input is a set of variables passed as a `PromptArgs` hashmap. If the chain have memroy, the tream method will not be able to automaticaly set the memroy, bocause it will not know if the how to extract the output message out of the stram.

##### Method
```rust
fn stream<'life0, 'async_trait>(
    &'life0 self,
    input_variables: PromptArgs,
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<StreamData, ChainError>> + Send>>, ChainError>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

#### `execute`

##### Description
Execute the `Chain` and return the result of the generation process along with additional information like token consumption formatted as a `HashMap`. The input is a set of variables passed as a `PromptArgs` hashmap. The key for the generated output is specified by the `get_output_keys` method (default key is `output`).

##### Method
```rust
fn execute<'life0, 'async_trait>(
    &'life0 self,
    input_variables: PromptArgs,
) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Value>, ChainError>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

#### `get_output_keys`

##### Method
```rust
fn get_output_keys(&self) -> Vec<String>
```
```

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

### Wolfram::new

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.Wolfram.html?search=

Constructs a new Wolfram tool instance. GPT4 is recommended when using this tool within agents.

```APIDOC
## Wolfram::new

### Description
Constructs a new Wolfram tool instance. When being used within agents, GPT4 is recommended.

### Signature
```rust
pub fn new(app_id: String) -> Self
```

### Parameters
* **app_id** (String) - The application ID for Wolfram Alpha.
```

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

### Chain::stream

Source: https://docs.rs/langchain-rust/latest/langchain_rust/agent/struct.AgentExecutor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Streams the Chain and gets an asynchronous stream of chain generations.

```APIDOC
## Chain::stream

### Description
Streams the `Chain` and gets an asynchronous stream of chain generations. The input is a set of variables passed as a `PromptArgs` hashmap. If the chain has memory, the stream method will not be able to automatically set the memory, because it will not know how to extract the output message out of the stream.

### Signature
```rust
fn stream<'life0, 'async_trait>( &'life0 self, _input_variables: PromptArgs, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<StreamData, ChainError>> + Send>>, ChainError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,
```

### Parameters
* `_input_variables`: A `PromptArgs` hashmap containing the input variables for the chain. Note: Memory management might be affected when using this method with chains that have memory.
```

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

### Initialize DuckDuckGoSearchResults

Source: https://docs.rs/langchain-rust/latest/langchain_rust/tools/struct.DuckDuckGoSearchResults.html

Use `new()` to create a new instance with default settings. Use `with_max_results()` to specify the maximum number of search results to retrieve.

```rust
pub fn new() -> Self
```

```rust
pub fn with_max_results(self, max_results: usize) -> Self
```
Tokens:
Raw