langchainrust-cli 0.31.0

Command-line interface for langchainrust: init, run, serve, eval.
//! `lc init` — scaffold a new project from an embedded template.

use std::fs;
use std::path::Path;

const CARGO_TOML: &str = r#"[package]
name = "my-agent"
version = "0.1.0"
edition = "2021"

[dependencies]
# v0.31: the default build is the five main paths exposed by `prelude`,
# including `AgentBuilder::build_executor()`.
langchainrust = "0.31"
tokio = { version = "1", features = ["full"] }
"#;

const ENV_EXAMPLE: &str = r#"OPENAI_API_KEY=sk-...
# OPENAI_BASE_URL=https://api.openai.com/v1
# OPENAI_MODEL=gpt-4o-mini
"#;

const README_TEMPLATE: &str = r#"# {name}

Scaffolded with `lc init`.

```bash
export OPENAI_API_KEY=sk-...
cargo run
```
"#;

const MAIN_CHAT: &str = r#"//! Minimal chat example generated by `lc init`.
use langchainrust::core::Runnable;
use langchainrust::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let llm = OpenAIChat::new(OpenAIConfig::from_env_result()?);
    let res = llm
        .invoke(vec![Message::human("What is Rust?".to_string())], None)
        .await?;
    println!("{}", res.content);
    Ok(())
}
"#;

const MAIN_AGENT: &str = r#"//! Function-calling agent generated by `lc init`.
use langchainrust::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let executor = AgentBuilder::new()
        .llm(OpenAIChat::new(OpenAIConfig::from_env_result()?))
        .system("You are a concise assistant.")
        .tool(Calculator::new())
        .build_executor()?;
    println!("{}", executor.invoke("What is 25 * 37?".to_string()).await?);
    Ok(())
}
"#;

const MAIN_RAG: &str = r#"//! Minimal RAG example generated by `lc init`.
use std::collections::HashMap;
use std::sync::Arc;

use langchainrust::core::Runnable;
use langchainrust::prelude::*;
use langchainrust::retrieval::{BM25Retriever, ChunkedDocumentStore, Document, RetrieverTrait};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let llm = OpenAIChat::new(OpenAIConfig::from_env_result()?);

    let mut docs: Vec<Document> = vec![];
    docs.push(doc("Rust is a systems programming language focused on safety."));
    docs.push(doc("langchainrust is a Rust framework for building LLM applications."));
    docs.push(doc("Agents in langchainrust call tools in a loop until they finish."));

    let bm25 = BM25Retriever::<ChunkedDocumentStore>::new();
    bm25.add_documents_sync(docs);
    let retriever: Arc<dyn RetrieverTrait> = Arc::new(bm25);

    let pipeline = RAGPipelineBuilder::new()
        .llm(llm)
        .retriever_from_arc(retriever)
        .retrieve_k(2)
        .system("Answer using only the retrieved context.")
        .build()?;

    for q in ["What is langchainrust?", "What is Rust?"] {
        println!("Q: {q}\nA: {}", pipeline.invoke(q.to_string()).await?);
    }
    Ok(())
}

fn doc(content: &str) -> Document {
    Document {
        content: content.to_string(),
        metadata: HashMap::new(),
        id: None,
    }
}
"#;

pub fn run(dir: &Path, template: &str, _provider: &str) -> Result<(), Box<dyn std::error::Error>> {
    ensure_directory(dir)?;
    let main = match template {
        "rag" => MAIN_RAG,
        _ => MAIN_AGENT,
    };
    // `chat` uses a different body than the default `agent`.
    let main = if template == "chat" { MAIN_CHAT } else { main };

    let name = dir
        .file_name()
        .map(|s| s.to_string_lossy().to_string())
        .unwrap_or_else(|| "my-agent".to_string());

    fs::create_dir_all(dir.join("src"))?;
    fs::write(dir.join("Cargo.toml"), CARGO_TOML)?;
    fs::write(dir.join("src/main.rs"), main)?;
    fs::write(dir.join(".env.example"), ENV_EXAMPLE)?;
    fs::write(
        dir.join("README.md"),
        README_TEMPLATE.replace("{name}", &name),
    )?;

    println!("Created project at {}", dir.display());
    println!("Next:");
    println!("  cd {}", dir.display());
    println!("  export OPENAI_API_KEY=sk-...   # or copy .env.example to .env");
    println!("  cargo run");
    Ok(())
}

fn ensure_directory(dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
    if dir.exists() {
        let non_empty = fs::read_dir(dir)?.next().is_some();
        if non_empty {
            return Err(format!(
                "{} is not empty; refusing to overwrite it",
                dir.display()
            )
            .into());
        }
    } else {
        fs::create_dir_all(dir)?;
    }
    Ok(())
}