Features

​

Overview

​

Multi-LLM Provider Support

let agent = Agent::with_provider(
    Provider::Anthropic("your-api-key")
).await?;

let agent = Agent::with_provider(
    Provider::Gemini("your-api-key")
).await?;

​

Built-in Tool System

​

File Operations

• Read Files: Read content from local files
• Write Files: Create or update files
• Glob Patterns: Search for files using glob patterns
• Grep Search: Search file contents with regex patterns

​

System Integration

• Bash Execution: Run shell commands
• Environment Variables: Access system environment
• Process Management: Manage subprocess execution

​

Model Context Protocol (MCP)

use picrust::mcp::MCPClient;

// Connect to an MCP server
let mcp = MCPClient::connect("http://localhost:3000").await?;
agent.add_mcp_client(mcp);

• Extensibility: Add custom tools without modifying the SDK
• Standardization: Use the industry-standard protocol
• Modularity: Mix and match different MCP servers

​

Async Runtime

let mut stream = agent.execute_stream("Complex task").await?;

while let Some(chunk) = stream.next().await {
    print!("{}", chunk);
}

let task1 = agent.execute("Task 1");
let task2 = agent.execute("Task 2");

let (result1, result2) = tokio::join!(task1, task2);

​

Logging & Observability

use tracing::{info, debug};

// Logs are automatically structured and filterable
info!("Agent initialized");
debug!(task = "analysis", "Starting task execution");

RUST_LOG=debug cargo run

​

Type Safety

• Compile-time Guarantees: Catch errors before runtime
• Zero-cost Abstractions: High-level APIs with no performance penalty
• Memory Safety: No data races or memory leaks

​

Session Management

// Maintain conversation context
let session = agent.create_session().await?;

session.send("What is Rust?").await?;
session.send("Can you give me an example?").await?;
// Agent remembers previous context

​

Error Handling

use anyhow::{Result, Context};

let result = agent.execute("task")
    .await
    .context("Failed to execute task")?;

​

Performance

• Async I/O: Non-blocking operations
• Connection Pooling: Efficient API request handling
• Stream Processing: Handle large responses efficiently
• Zero-copy Serialization: Minimal overhead

​

Next Steps