langchain-rust

The langchain-rust library is organized into several core modules that provide the building blocks for LLM applications. Key modules include:

• agent: For creating autonomous agents that use tools.
• chain: For composing multiple components into a sequence of operations.
• document_loaders: For importing data from various sources into the system.
• embedding: For generating vector representations of text.
• language_models & llm: For interacting with Large Language Models.
• memory: For maintaining state and context in conversational applications.
• output_parsers: For transforming LLM raw text into structured data.
• prompt: For managing and constructing prompt templates.
• schemas: For core data structures and types.
• semantic_router: For routing queries based on semantic meaning.
• text_splitter: For breaking down large documents into smaller chunks.
• tools: For defining capabilities that agents can invoke.
• vectorstore: For storing and retrieving embeddings.

The SQLDatabaseChain allows you to interact with a SQL database using human language. It works by taking a natural language query, using an LLM to generate the corresponding SQL, executing that SQL against the database, and then using the LLM again to format the final answer.

Key Input Variables

• query: The natural language question (e.g., "What is the phone number of Luis?"). This is the primary input required.
• table_names (optional): A JSON array of strings representing the specific tables to include in the context. If not provided, the chain uses its internal logic to determine table information.

Usage Pattern

You can provide inputs using the prompt_builder() helper or by manually constructing PromptArgs using the prompt_args! macro.

// 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: {:?}", e),
}

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

This example demonstrates how to initialize an OpenAI model, define a prompt template using macros like message_formatter!, fmt_message!, and fmt_template!, and build an LLMChain using LLMChainBuilder. It also shows how to handle conversation history using the fmt_placeholder! macro and prompt_args! for input injection.

use langchain_rust::{
    chain::{Chain, LLMChainBuilder},
    fmt_message, fmt_placeholder, fmt_template, 
    language_models::llm::LLM,
    llm::openai::{OpenAI, OpenAIModel},
    message_formatter,
    prompt::HumanMessagePromptTemplate,
    prompt_args,
    schemas::messages::Message,
    template_fstring,
};

#[tokio::main]
async fn main() {
    // Initialize the model
    let open_ai = OpenAI::default().with_model(OpenAIModel::Gpt4oMini.to_string());

    // Define a prompt template with a system message and a human message template
    let prompt = message_formatter![
        fmt_message!(Message::new_system_message(
            "You are world class technical documentation writer."
        )),
        fmt_template!(HumanMessagePromptTemplate::new(template_fstring!(
            "{input}", "input"
        )))
    ];

    // Build the LLM chain
    let chain = LLMChainBuilder::new()
        .prompt(prompt.clone())
        .llm(open_ai.clone())
        .build()
        .unwrap();

    // Invoke the chain with arguments
    match chain
        .invoke(prompt_args! {
        "input" => "Quien es el escritor de 20000 millas de viaje submarino",
           })
        .await
    {
        Ok(result) => println!("Result: {:?}", result),
        Err(e) => panic!("Error invoking LLMChain: {:?}", e),
    }

    // Example with conversation history using fmt_placeholder!
    let prompt_with_history = message_formatter![
        fmt_message!(Message::new_system_message(
            "You are world class technical documentation writer."
        )),
        fmt_placeholder!("history"),
        fmt_template!(HumanMessagePromptTemplate::new(template_fstring!(
            "{input}", "input"
        ))),
    ];

    let chain_with_history = LLMChainBuilder::new()
        .prompt(prompt_with_history.clone())
        .llm(open_ai)
        .build()
        .unwrap();

    match chain_with_history
        .invoke(prompt_args! {
        "input" => "Who is the writer of 20,000 Leagues Under the Sea, and what is my name?”,
        "history" => vec![
                Message::new_human_message("My name is: luis"),
                Message::new_ai_message("Hi luis"),
                ],
        })
        .await
    {
        Ok(result) => println!("Result: {:?}", result),
        Err(e) => panic!("Error invoking LLMChain: {:?}", e),
    }
}