reasonkit-web

ReasonKit Web (Rust Edition)

High-Performance Web Sensing & Browser Automation Layer Rust-Native Implementation

The Eyes and Ears of AI Reasoning - Now Blazingly Fast

Documentation | Crates.io | ReasonKit Core | Website

---

Note: This is the Rust implementation of the ReasonKit Web Sensing layer. It supersedes the legacy Python prototype for performance-critical deployments.

Web sensing and browser automation layer for ReasonKit. Implements the Model Context Protocol (MCP) for seamless web interactions with AI reasoning systems, powered by Rust and ChromiumOxide.

Features

Use Cases

Performance

Installation

Universal Installer (Recommended)

Installs all 4 ReasonKit projects together:

curl -fsSL https://get.reasonkit.sh | bash -s -- --with-web

Platform & Shell Support:

• ✅ All platforms (Linux/macOS/Windows/WSL)
• ✅ All shells (Bash/Zsh/Fish/Nu/PowerShell/Elvish)
• ✅ Auto-detects shell and configures PATH
• ✅ Beautiful progress visualization

Cargo (Rust Library)

Add to your Cargo.toml:

[dependencies]
reasonkit-web = "0.1"
tokio = { version = "1", features = ["full"] }

Quick Start

As a Library

use reasonkit_web::BrowserController;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create browser controller
    let controller = BrowserController::new().await?;

    // Navigate to a page
    let page = controller.navigate("https://example.com").await?;

    // Extract content
    let content = page.content().await?;
    println!("Page content: {}", content);

    Ok(())
}

As an MCP Server

# Build the MCP server binary
cargo build --release

# Run the MCP server
./target/release/reasonkit-web

# Or with cargo
cargo run --release

Content Extraction

use reasonkit_web::{ContentExtractor, MetadataExtractor};

// Extract structured content from HTML
let html = "<html><body><h1>Title</h1><p>Content</p></body></html>";
let extractor = ContentExtractor::new();
let content = extractor.extract(html)?;

// Extract metadata
let meta_extractor = MetadataExtractor::new();
let metadata = meta_extractor.extract(html)?;

API Workflow

Architecture

The ReasonKit Web layer implements a high-performance web sensing architecture designed for AI reasoning systems:

System Topology

Core Architecture

The Rust Engine

Key Design Principles

Performance-First: Built in Rust with async/await for maximum throughput Protocol-Driven: Implements Model Context Protocol (MCP) for AI integration Modular Design: Separates capture, extraction, and memory for flexibility Security-Focused: Headless browser isolation and content sanitization

Integration Flow

Security & Privacy

ReasonKit Web is built with a "GDPR by Default" philosophy, ensuring that AI reasoning systems can interact with the web safely and compliantly.

Key Security Features

• PII Redaction Engine: Automatically detects and redacts sensitive information (emails, phone numbers, secrets) before it leaves the secure runtime.
• Headless Isolation: Browser sessions run in isolated containers with no persistent state.
• Content Sanitization: Malicious scripts and trackers are stripped at the DOM level.

For detailed technical specifications, see docs/ARCHITECTURE.md.

Technology Stack

Version & Maturity

Component	Status	Notes
MCP Server	✅ Stable	Model Context Protocol integration
CDP Client	✅ Stable	Chrome DevTools Protocol via chromiumoxide
Content Extraction	✅ Stable	HTML parsing, metadata extraction
PII Redaction	✅ Stable	GDPR-compliant data handling
WASM Support	🔶 Beta	Browser-native execution

Current Version: v0.1.3 | CHANGELOG | Releases

Verify Installation

# Build and run MCP server
cargo build --release
./target/release/reasonkit-web --help

# Or test as a library
cargo test

License

Apache License 2.0 - see LICENSE

---

Part of the ReasonKit Ecosystem

ReasonKit Core • ReasonKit Mem • Website

"See How Your AI Thinks"