Kowalski

https://github.com/yarenty/kowalski
Admin
Kowalski is a sophisticated Rust-based multi-agent framework for interacting with LLM providers,...
Tokens:50,645
Snippets:191
Trust Score:6.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Kowalski CLI Interactive Development Session Example

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

An example of starting an interactive development session using the Kowalski CLI, specifically for coding tasks, with a specified agent, model, and system prompt.

```bash
# Start a coding session
kowalski chat --agent code --model codellama --prompt "You are a Rust expert"
```

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

### SQL Query for In-Tool Data Analysis

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

Shows an example SQL query that can be passed to a tool integrated with a query engine like DataFusion. This allows the agent to request specific data aggregations directly from the tool.

```SQL
SELECT AVG(salary) FROM employees WHERE department = 'Engineering'
```

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

### Rust Function Description for AI Agent

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

Provides a comprehensive description for an AI agent tool, detailing its functionality, parameters, and return value. This documentation is crucial for the LLM to correctly utilize the tool.

```Rust
fn process_csv(file_path: String)

Description: "Processes a CSV file located at the given `file_path`. It performs a full statistical analysis of the data, including column types, counts, averages, min/max for numeric columns, and value distributions for categorical columns. Returns a structured JSON object summarizing the analysis."
```

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

### Install Kowalski CLI from Source

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Installs the Kowalski CLI by cloning the repository and using Cargo to build and install the command-line tool.

```bash
git clone https://github.com/yarenty/kowalski.git
cd kowalski
cargo install --path kowalski-cli
```

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

### Kowalski CLI Example Configuration

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

An example TOML configuration file for the Kowalski CLI, showing settings for Ollama connection, chat parameters, and logging.

```toml
# ~/.config/kowalski/config.toml
[ollama]
host = "localhost"
port = 11434
model = "llama2"

[chat]
max_history = 100
enable_streaming = true
temperature = 0.7
max_tokens = 2048

[logging]
level = "info"
format = "json"
```

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

### Kowalski CLI Usage Examples

Source: https://github.com/yarenty/kowalski/blob/main/README.md

Demonstrates various command-line interface commands for interacting with Kowalski agents. These examples cover chatting with an LLM, analyzing academic papers, performing web searches, and analyzing code files.

```Bash
# Chat with an LLM
kowalski chat "What's the best way to learn Rust?"

# Analyze a PDF
kowalski academic --file research.pdf

# Web search
kowalski tool search "rust async programming"

# Code analysis
kowalski tool code ./src/main.rs
```

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

### Rust Function Signature: Bad vs. Good

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

Illustrates the importance of descriptive naming for function parameters in AI agent tools. A clear signature helps the LLM understand the tool's purpose and required inputs.

```Rust
fn analyze(p: String)
```

```Rust
fn process_csv(file_path: String)
```

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

### ReAct-Style Tool Calling Example in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-web-agent/README.md

A conceptual example in Rust demonstrating how the Kowalski Web Agent uses ReAct-style tool calling. It outlines the automated process of searching, scraping, and synthesizing information to answer a user's query.

```rust
// The agent will automatically:
// 1. Use web_search to find relevant URLs
// 2. Use web_scrape to extract content from promising URLs
// 3. Synthesize the information into a comprehensive answer
let response = agent.chat_with_tools(&conv_id, "What are the latest developments in AI?").await?;
```

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

### Install Kowalski CLI from Crates.io

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Installs the Kowalski CLI using Cargo, assuming it has been published to crates.io.

```bash
cargo install kowalski-cli
```

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

### Verbalize Findings with JSON Summary

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

This snippet demonstrates how a tool can provide a concise natural language summary of its findings in a JSON format, alongside a flag indicating the availability of a full summary. This allows agents to quickly grasp key information.

```JSON
{
  "status": "success",
  "verbal_summary": "Successfully analyzed the 10,000-row CSV. Key findings: The 'age' column has an average of 35.5. The 'department' column is dominated by 'Engineering' (65%).",
  "has_full_summary": true
}
```

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

### Initialize and Use Academic Agent in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-academic-agent/README.md

Demonstrates how to initialize the Kowalski Academic Agent with default configuration, start a conversation, and process a research paper using its chat history functionality. This is a foundational example for interacting with the agent.

```Rust
use kowalski_academic_agent::AcademicAgent;
use kowalski_core::config::Config;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the academic agent
    let config = Config::default();
    let mut academic_agent = AcademicAgent::new(config).await?;
    
    // Start a conversation
    let conversation_id = academic_agent.start_conversation("llama3.2");
    
    // Process a research paper
    let paper_path = "path/to/research_paper.pdf";
    let response = academic_agent
        .chat_with_history(&conversation_id, paper_path, None)
        .await?;
    
    // Process streaming response...
    Ok(())
}
```

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

### Advanced Tool-Calling Usage in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-web-agent/README.md

Illustrates advanced usage of the Kowalski Web Agent with ReAct-style tool calling in Rust. This example shows how to start a conversation and use the agent to answer complex queries by automatically chaining search and scraping tools.

```rust
use kowalski_web_agent::WebAgent;
use kowalski_core::config::Config;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::default();
    let mut agent = WebAgent::new(config).await?;
    
    // Start a conversation
    let conv_id = agent.start_conversation("llama3.2");
    
    // Use ReAct-style tool calling for complex queries
    let response = agent.chat_with_tools(&conv_id, "What's the latest news about AI?").await?;
    println!("Response: {}", response);
    
    // The agent will automatically:
    // 1. Search for recent AI news
    // 2. Scrape relevant articles
    // 3. Synthesize the information
    // 4. Provide a comprehensive answer
    
    Ok(())
}
```

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

### Run CSV Analysis Example

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-data-agent/README.md

This snippet shows the command to execute the csv_analysis example, which processes CSV data and generates various outputs.

```bash
`/opt/ml/kowalski/target/debug/examples/csv_analysis`
```

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

### Build and Run Kowalski CLI

Source: https://github.com/yarenty/kowalski/blob/main/README.md

This snippet shows how to clone the Kowalski repository, build the project in release mode, and then run the command-line interface. It's the primary way to interact with Kowalski after setup.

```Bash
git clone https://github.com/yarenty/kowalski.git
cd kowalski
cargo build --release

cargo run --release --bin kowalski-cli
# Or use the CLI directly after building
./target/release/kowalski chat "Hello, world!"
```

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

### Tool Response with Query Result

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

Illustrates the expected JSON response from a tool after executing an in-tool query. The response contains the specific result requested by the agent, maintaining context efficiency.

```JSON
{
  "status": "success",
  "data": [
    {
      "AVG(salary)": 85000.0
    }
  ]
}
```

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

### Standardized JSON Output for Tool Returns

Source: https://github.com/yarenty/kowalski/blob/main/docs/articel_tooling.md

Demonstrates a consistent and predictable JSON output format for AI agent tools, including status and data/error fields. This structure aids the agent in reliably processing tool responses.

```JSON
{
  "status": "success",
  "data": {
    "summary": "..."
  }
}
```

```JSON
{
  "status": "error",
  "error_message": "Specific error details"
}
```

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

### Run Kowalski Agents

Source: https://github.com/yarenty/kowalski/blob/main/docs/article_vesion050.md

Demonstrates how to start the Ollama service, pull a model, and then run the Kowalski CLI for chat and the code agent for file analysis.

```Bash
ollama serve &
ollama pull llama3.2
./target/release/kowalski-cli chat "Hey Kowalski, what's up?"
./target/release/kowalski-code-agent --file src/main.rs
```

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

### Kowalski Error Handling Examples

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Illustrates common error messages from the Kowalski CLI and provides suggestions for resolution.

```bash
# If Ollama is not running
Error: Failed to connect to Ollama at localhost:11434
Suggestion: Start Ollama with 'ollama serve'
```

```bash
# If model is not found
Error: Model 'llama2' not found
Suggestion: Pull the model with 'ollama pull llama2'
```

```bash
# If file is not found
Error: File 'nonexistent.pdf' not found
Suggestion: Check the file path and permissions
```

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

### Getting Help with Kowalski CLI

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Commands to access general help, command-specific help, enable debug mode, and check the version.

```bash
# General help
kowalski --help

# Command-specific help
kowalski chat --help
kowalski academic --help

# Debug mode
kowalski --log-level debug chat

# Check version and dependencies
kowalski --version
```

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

### Kowalski CLI Environment Variables

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Shows examples of environment variables that can be used to configure the Kowalski CLI, such as setting the Ollama host, default model, and log level.

```bash
# Set Ollama host
export KOWALSKI_OLLAMA_HOST=localhost

# Set default model
export KOWALSKI_OLLAMA_MODEL=llama2

# Set log level
export KOWALSKI_LOG_LEVEL=debug
```

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

### Basic CSV Analysis with Kowalski Data Agent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-data-agent/README.md

Demonstrates how to initialize the Kowalski Data Agent, start a conversation, process CSV data, and obtain AI-driven analysis results. It includes setting up the agent, providing sample CSV data, and formulating a prompt for analysis.

```rust
use kowalski_data_agent::DataAgent;
use kowalski_core::config::Config;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the data agent
    let config = Config::default();
    let mut data_agent = DataAgent::new(config).await?;
    
    // Start a conversation
    let conversation_id = data_agent.start_conversation("llama3.2");
    
    // Sample CSV data
    let csv_data = r#"name,age,city,salary,department
John Doe,30,New York,75000,Engineering
Jane Smith,28,San Francisco,85000,Marketing
Bob Johnson,35,Chicago,65000,Sales"#;
    
    // Process the CSV data
    let analysis_result = data_agent.process_csv(csv_data).await?;
    
    // Get AI analysis
    let analysis_prompt = format!(
        "Please analyze this CSV data and provide insights:\n\n{}\n\nAnalysis results:\n{}",
        csv_data,
        serde_json::to_string_pretty(&analysis_result.summary)?
    );
    
    let response = data_agent
        .chat_with_history(&conversation_id, &analysis_prompt, None)
        .await?;
    
    // Process streaming response...
    Ok(())
}

```

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

### Web Research Example - Kowalski Agent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-web-agent/README.md

Demonstrates the Kowalski agent performing a web search, listing results with titles, URLs, and snippets, processing a selected URL, and generating a summary. It handles streaming responses and conversation context.

```Shell
🤖 Starting web agent...
Web Agent Conversation ID: 12345678-90ab-cdef-1234-567890abcdef

🔍 Searching: AI

📑 Result:
Title: Artificial Intelligence - Wikipedia
URL: https://en.wikipedia.org/wiki/Artificial_intelligence
Snippet: Artificial intelligence (AI) is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and animals...

📑 Result:
Title: What is AI? | IBM
URL: https://www.ibm.com/topics/artificial-intelligence
Snippet: Artificial intelligence leverages computers and machines to mimic the problem-solving and decision-making capabilities of the human mind...

🌐 Processing first result: https://en.wikipedia.org/wiki/Artificial_intelligence

📝 Generating summary...
Artificial intelligence (AI) is when computers or machines are designed to think and learn like humans. It helps solve problems, make decisions, and can be found in things like voice assistants or self-driving cars.

✅ Summary complete!
```

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

### Python PEP 8: Comments and Docstrings

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-code-agent/README.md

This Python example emphasizes the PEP 8 recommendation for using comments to explain the 'why' rather than the 'what' of the code. It suggests using docstrings for comprehensive documentation of classes, methods, and functions.

```Python
# Current comment: "This is a sample data"
```

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

### Generate Citation in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-academic-agent/README.md

Demonstrates how to generate a citation for a given reference using the Academic Agent. The example shows how to retrieve and print the generated citation and its format.

```Rust
// Generate a citation for a reference
let citation = academic_agent.generate_citation("Attention Is All You Need").await?;
println!("Citation: {}", citation.citation);
println!("Format: {}", citation.format);
```

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

### Kowalski Rust API - Base Agent Initialization

Source: https://github.com/yarenty/kowalski/blob/main/README.md

This Rust code snippet illustrates how to initialize a base agent using the Kowalski core library. It sets up the agent with default configuration, a name, and a description, and starts a conversation with a specified LLM.

```Rust
use kowalski_core::{Agent, BaseAgent, Config};
let config = Config::default();
let mut agent = BaseAgent::new(config, "Demo Agent", "A test agent").await?;
let conv_id = agent.start_conversation("llama3.2");
agent.add_message(&conv_id, "user", "Hello, world!").await;
```

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

### Build Kowalski Project with Cargo

Source: https://github.com/yarenty/kowalski/blob/main/docs/index.html

This snippet demonstrates how to clone the Kowalski repository and build the project in release mode using Cargo, Rust's package manager. Ensure you have Rust and Ollama installed before execution.

```Shell
git clone https://github.com/yarenty/kowalski.git
cd kowalski
cargo build --release
```

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

### Extending Kowalski Data Agent with Additional Data Formats

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-data-agent/README.md

Provides a structural example of how the Kowalski Data Agent can be extended to support additional data formats such as JSON, XML, and Excel files by integrating specialized tools.

```rust
// Add support for JSON, XML, Excel files
pub struct ExtendedDataAgent {
    agent: DataAgent,
    json_tool: JsonTool,
    excel_tool: ExcelTool,
    xml_tool: XmlTool,
}

```

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

### Extend Academic Agent with More Databases in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-academic-agent/README.md

Provides a structural example of how the Academic Agent could be extended to integrate with additional academic search engines like ArXiv, PubMed, IEEE, and ACM by defining a new struct that includes these tools.

```Rust
// Integrate with more academic search engines
pub struct ExtendedAcademicAgent {
    agent: AcademicAgent,
    arxiv_tool: ArxivTool,
    pubmed_tool: PubMedTool,
    ieee_tool: IEEETool,
    acm_tool: ACMTool,
}
```

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

### Basic Kowalski CLI Commands

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Demonstrates basic commands for showing help and version information for the Kowalski CLI and its subcommands.

```bash
# Show help
kowalski --help

# Show version
kowalski --version

# Show help for a specific command
kowalski chat --help
kowalski academic --help
kowalski model --help
```

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

### Basic Web Agent Usage in Rust

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-web-agent/README.md

Demonstrates the basic usage of the Kowalski Web Agent in Rust. It shows how to initialize the agent, perform a web search, and fetch and display content from a web page.

```rust
use kowalski_web_agent::WebAgent;
use kowalski_core::config::Config;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::default();
    let mut web_agent = WebAgent::new(config).await?;

    // Perform a web search
    let results = web_agent.search("AI").await?;
    for result in &results {
        println!("Title: {}", result.title);
        println!("URL: {}", result.url);
        println!("Snippet: {}", result.snippet);
    }

    // Fetch and summarize a web page
    if let Some(first) = results.first() {
        let page = web_agent.fetch_page(&first.url).await?;
        println!("Page Title: {}", page.title);
        println!("Content: {}", &page.content[..100]);
    }

    Ok(())
}
```

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

### Basic Agent Initialization and Message

Source: https://github.com/yarenty/kowalski/blob/main/kowalski/README.md

Demonstrates how to create a basic AI agent using the Kowalski framework. It shows how to configure the agent with a model and system prompt, send a message, and process the response. This requires the `tokio` runtime.

```rust
use kowalski::{Agent, AgentBuilder, Result};

#[tokio::main]
async fn main() -> Result<()> {
    // Create a basic agent
    let agent = AgentBuilder::new()
        .with_model("llama2")
        .with_system_prompt("You are a helpful AI assistant.")
        .build()?;

    // Send a message
    let response = agent.send_message("Hello, how are you?").await?;
    println!("Response: {}", response.content);

    Ok(())
}
```

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

### Tool-Calling Demo - Kowalski Agent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-web-agent/README.md

Illustrates the Kowalski Web Agent's tool-calling capabilities using a ReAct-style approach for intelligent information gathering. It shows the process of querying, tool execution (web_search, web_scrape), and generating a final response.

```Shell
Kowalski Web Agent Tool-Calling Demo
=====================================
Conversation started with ID: abc123

--- Query: What's the latest news about AI? ---
Processing with ReAct-style tool calling...
[DEBUG] Iteration 1: What's the latest news about AI?
[DEBUG] Tool call detected: web_search with input: latest AI news 2024
[DEBUG] Tool web_search executed successfully: [search results...]
[DEBUG] Iteration 2: Based on the tool result: [search results...]
[DEBUG] Tool call detected: web_scrape with input: https://example-news-site.com
[DEBUG] Tool web_scrape executed successfully: [article content...]
Final Response: Based on recent news, AI developments include...

--- End Query ---
```

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

### Kowalski Agent Crate Example (Rust)

Source: https://github.com/yarenty/kowalski/blob/main/docs/key_technology.md

Agents in Kowalski are designed as independent crates, promoting separation of concerns and code reuse. This example demonstrates the basic structure of a Kowalski agent crate.

```Rust
use kowalski_core::KowalskiCore;

pub struct MyAgent {
    // Agent specific state
}

impl KowalskiCore for MyAgent {
    fn initialize(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        println!("MyAgent initialized.");
        Ok(())
    }

    fn process(&mut self, input: &str) -> Result<String, Box<dyn std::error::Error>> {
        Ok(format!("MyAgent processed: {}", input))
    }
}

// In Cargo.toml:
// [dependencies]
// kowalski-core = "0.1.0"
```

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

### Build Agent with Builder Pattern

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-agent-template/README.md

Demonstrates using the `AgentBuilder` to fluently configure an agent. This includes setting a system prompt, registering a `WebSearchTool`, and specifying a temperature.

```Rust
use kowalski_agent_template::builder::AgentBuilder;
use kowalski_tools::web::WebSearchTool;

let builder = AgentBuilder::new()
    .await
    .with_system_prompt("You are a helpful assistant.")
    .with_tool(WebSearchTool::new("duckduckgo".to_string()))
    .with_temperature(0.5);

let agent = builder.build().await?;
```

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

### Run Qdrant Docker Container

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-memory/README.md

This snippet demonstrates how to pull the latest Qdrant Docker image and run it as a container. It maps the necessary ports and sets up a volume for data persistence.

```bash
docker pull qdrant/qdrant

docker run -p 6333:6333 -p 6334:6334 \
    -v $(pwd)/qdrant_storage:/qdrant/storage \
    qdrant/qdrant
```

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

### Web Search Tool Execution

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-tools/README.md

Illustrates how to use the WebSearchTool to perform a web search. It shows how to instantiate the tool with a provider and execute a search query with specified parameters.

```Rust
use kowalski_tools::web::WebSearchTool;
use std::collections::HashMap;

// Assuming ToolInput and json! macro are available
// struct ToolInput { task_type: String, content: String, parameters: HashMap<String, serde_json::Value> };

let search_tool = WebSearchTool::new("duckduckgo".to_string());
let input = ToolInput {
    task_type: "search".to_string(),
    content: "".to_string(),
    parameters: {
        let mut params = HashMap::new();
        params.insert("query".to_string(), json!("Rust programming"));
        params.insert("num_results".to_string(), json!(5));
        params
    },
};

let result = search_tool.execute(input).await?;
```

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

### Embed Kowalski Agent in Rust Service

Source: https://github.com/yarenty/kowalski/blob/main/docs/article_vesion050.md

This Rust code snippet illustrates how to initialize a BaseAgent, start a conversation with a specified model, and add a user message to the conversation.

```Rust
use kowalski_core::{Config, BaseAgent};
let mut agent = BaseAgent::new(Config::default(), "Demo", "Agent v0.5.0").await?;
let conv = agent.start_conversation("llama3.2");
agent.add_message(&conv, "user", "Summarize this code module").await?;
```

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

### Fix PEP 8 Violations: Trailing Whitespace and Indentation

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-code-agent/README.md

Highlights common PEP 8 violations like trailing whitespace and inconsistent indentation. It shows an example of a line with trailing whitespace and its refactored version.

```Python
# Original line with trailing whitespace
print("Error: Data is empty")

# Refactored line without trailing whitespace
if len(self.data):
    logging.error("Data is empty")
else:
    # Code here

```

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

### CSV Tool Usage with ToolManager

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-tools/README.md

Demonstrates how to initialize a ToolManager, register a CsvTool, and execute a CSV analysis task. It shows the structure of ToolInput and how to pass parameters.

```Rust
use kowalski_tools::{CsvTool, ToolManager};
use std::collections::HashMap;

// Assuming ToolInput and json! macro are available
// struct ToolInput { task_type: String, content: String, parameters: HashMap<String, serde_json::Value> };

let mut manager = ToolManager::new();
let csv_tool = CsvTool::new(1000, 50);
manager.register_tool(csv_tool);

// Execute CSV analysis
let input = ToolInput {
    task_type: "analyze_csv".to_string(),
    content: csv_content,
    parameters: HashMap::new(),
};

let result = manager.execute_tool("csv_tool", input).await?;
```

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

### Add Kowalski Dependency to Cargo.toml

Source: https://github.com/yarenty/kowalski/blob/main/kowalski/README.md

This snippet shows how to add the Kowalski framework as a dependency in your Rust project's Cargo.toml file. It includes an example of how to enable optional features, such as data analysis capabilities.

```toml
[dependencies]
kowalski = "0.5.0"

# Optional: Enable data analysis capabilities
kowalski = { version = "0.5.0", features = ["data"] }
```

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

### Kowalski CLI Global Options

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Lists global command-line options available for the Kowalski CLI, including configuration file specification, log level, and output verbosity.

```bash
- `--config <FILE>`: Specify configuration file
- `--log-level <LEVEL>`: Set logging level (debug, info, warn, error)
- `--quiet`: Suppress output
- `--verbose`: Enable verbose output
```

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

### Kowalski Agent Template (Rust)

Source: https://github.com/yarenty/kowalski/blob/main/docs/use_cases.md

The `kowalski-agent-template` provides a starting point for creating custom AI agents. It simplifies the process of composing new agents by offering a robust builder pattern and essential scaffolding.

```Rust
// Example of agent creation using a builder pattern (conceptual):
// use kowalski_core::agent::AgentBuilder;

// fn main() {
//     let agent = AgentBuilder::new()
//         .with_name("Data Analyst Agent")
//         .add_tool(kowalski_tools::PdfParser::new())
//         .build();
//
//     // Agent is now ready to execute tasks
// }
```

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

### Troubleshooting Missing Models

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Instructions for listing available models and pulling missing ones for use with Kowalski.

```bash
# List available models
ollama list

# Pull missing model
ollama pull llama2
```

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

### Python Code Analysis Tool

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-tools/README.md

Conducts Python-specific code analysis, including PEP 8 style guide compliance checking. It identifies functions, classes, and imports, and provides code quality suggestions tailored for Python development.

```Python
import ast
import pycodestyle

class PythonAnalysisTool:
    """
    Performs Python code analysis, including PEP 8 compliance and metric calculation.
    """

    def __init__(self):
        pass

    def analyze_python_code(self, content: str) -> dict:
        """
        Analyzes the provided Python code content.

        Args:
            content: The Python code as a string.

        Returns:
            A dictionary containing the analysis results.
        """
        metrics = {
            "lines": len(content.splitlines()),
            "functions": 0,
            "classes": 0,
            "pep8_errors": []
        }

        try:
            tree = ast.parse(content)
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    metrics["functions"] += 1
                elif isinstance(node, ast.ClassDef):
                    metrics["classes"] += 1
        except SyntaxError as e:
            metrics["syntax_error"] = str(e)

        # PEP 8 analysis
        style_guide = pycodestyle.StyleGuide(quiet=True)
        report = style_guide.input_source(content)
        metrics["pep8_errors"] = report.get_count()

        # Simulate quality suggestions
        suggestions = []
        if metrics["functions"] > 10:
            suggestions.append("Consider refactoring large functions.")
        if metrics["pep8_errors"] > 5:
            suggestions.append("Address PEP 8 violations for better readability.")

        return {
            "metrics": metrics,
            "suggestions": suggestions
        }

# Example usage:
# analyzer = PythonAnalysisTool()
# code = "def my_func():\n    pass\n\nclass MyClass:\n    pass"
# result = analyzer.analyze_python_code(code)
# print(result)

```

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

### Follow-up Questions with Kowalski Data Agent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-data-agent/README.md

Illustrates how to ask specific follow-up questions to the Kowalski Data Agent after an initial analysis to delve deeper into the data. This demonstrates the conversational and iterative nature of the agent.

```rust
// Ask specific follow-up questions
let follow_up = "What are the key insights about salary distribution across departments?";
let follow_up_response = data_agent
    .chat_with_history(&conversation_id, follow_up, None)
    .await?;

```

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

### Kowalski CLI Output Options

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Outlines command-line options related to output handling in the Kowalski CLI, including specifying output files, formats, and pretty-printing.

```bash
- `--output <FILE>`: Write output to file
- `--format <FORMAT>`: Output format (text, json, yaml)
- `--pretty`: Pretty-print JSON output
```

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

### Python PEP 8: Variable Naming Example

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-code-agent/README.md

This snippet demonstrates how to improve Python code by using more descriptive variable names, adhering to PEP 8 guidelines. It shows the refactoring of a generic `data` variable to a more specific `input_data`.

```Python
input_data = [10, 20, 30, 40, 50]
```

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

### Create Default General Agent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-agent-template/README.md

Initializes a general-purpose agent using the `GeneralTemplate`. This template includes basic tools like web search and PDF processing, with default prompt and temperature settings.

```Rust
use kowalski_agent_template::templates::general::GeneralTemplate;

let builder = GeneralTemplate::create_default_agent().await?;
let agent = builder.build().await?;
```

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

### Python PEP 8: Line Length Refactoring

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-code-agent/README.md

This example illustrates adhering to PEP 8's recommended line length (under 79 characters) in Python. It shows how to break down a long line, potentially containing a loop or complex expression, into multiple lines for better readability.

```Python
# Current line: 88 characters
long_line = (
    "for item in self.data:"
    "    total += item"
)

# Refactored line (under 79 characters)
for item in self.data:
    total += item
```

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

### Kowalski CLI Chat Interface

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Shows how to initiate interactive chat sessions with AI agents using the Kowalski CLI, with options to specify models, agent types, file contexts, and custom prompts.

```bash
# Start an interactive chat session
kowalski chat

# Chat with a specific model
kowalski chat --model llama2

# Chat with a specific agent type
kowalski chat --agent academic

# Chat with a file context
kowalski chat --file document.txt

# Chat with custom system prompt
kowalski chat --prompt "You are a helpful coding assistant"
```

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

### Yarenty Kowalski Plugin System

Source: https://github.com/yarenty/kowalski/wiki/Home

Illustrates the plugin system's architecture, showing its connections to CUSTOM, EXT_API, and WORKFLOW components.

```mermaid
graph TD
    %% Plugin System
    PLUGIN --> CUSTOM
    PLUGIN --> EXT_API
    PLUGIN --> WORKFLOW
```

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

### Troubleshooting Memory Issues

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Tips for managing memory usage, such as using smaller models or adjusting configuration.

```bash
# Use smaller models for limited memory
ollama pull llama2:7b

# Adjust model settings in config
```

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

### Kowalski CLI Code Analysis Commands

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Illustrates commands for code analysis using the Kowalski CLI, including analyzing files, refactoring code, generating documentation, reviewing quality, and suggesting improvements.

```bash
# Analyze a code file
kowalski code analyze src/main.rs

# Refactor code
kowalski code refactor src/main.rs

# Generate documentation
kowalski code docs src/main.rs

# Review code quality
kowalski code review src/main.rs

# Suggest improvements
kowalski code improve src/main.rs
```

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

### Kowalski CLI Model Options

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Details command-line options specific to model management in the Kowalski CLI, such as specifying the model name, host, and port.

```bash
- `--model <NAME>`: Specify model to use
- `--host <HOST>`: Ollama host address
- `--port <PORT>`: Ollama port number
```

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

### Yarenty Kowalski Data Storage Connections

Source: https://github.com/yarenty/kowalski/wiki/Home

Illustrates the data storage strategy, showing connections to DB from CM, HIST, and EVENTS, REDIS for CACHE, and S3 for RESP.

```mermaid
graph TD
    %% Data Storage
    CM --> DB
    HIST --> DB
    EVENTS --> DB
    CACHE --> REDIS
    RESP --> S3
```

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

### Create Basic TemplateAgent

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-agent-template/README.md

Instantiates a `TemplateAgent` with default configuration. This agent serves as a foundation for custom AI agents, allowing for the registration of tools and task handlers.

```Rust
use kowalski_agent_template::agent::TemplateAgent;
use kowalski_core::tools::{Tool, ToolInput, ToolOutput};
use kowalski_core::config::Config;

let config = Config::default();
let agent = TemplateAgent::new(config).await?;
// Register tools and handlers as needed
```

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

### Kowalski CLI Web Research Commands

Source: https://github.com/yarenty/kowalski/blob/main/kowalski-cli/README.md

Shows commands for performing web research using the Kowalski CLI, including searching the web, scraping webpages, researching topics, and extracting information from multiple sources.

```bash
# Search the web
kowalski web search "Rust async programming"

# Scrape a webpage
kowalski web scrape https://example.com

# Research a topic
kowalski web research "machine learning trends 2024"

# Extract information from multiple sources
kowalski web extract "climate change" --sources 5
```
Tokens:
Raw