Hanzo Edge

use hanzo_edge_core::{load_model, InferenceSession, SamplingParams};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let model = load_model("zenlm/zen4-mini-gguf", None)?;
    let session = InferenceSession::new(model, SamplingParams::default());

    let output = session.generate("Explain quantum computing")?;
    println!("{output}");

    Ok(())
}

import { EdgeModel } from 'hanzo-edge-wasm';

// Load model bytes (from fetch, IndexedDB, etc.)
const model = await EdgeModel.new(modelBytes, tokenizerBytes);

// Streaming generation
model.generate_stream("Hello!", (token) => {
  process.stdout.write(token);
});

// Or await full response
const response = await model.generate("Explain quantum computing");
console.log(response);

from openai import OpenAI

# Connect to local hanzo-edge server
client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="local"
)

response = client.chat.completions.create(
    model="zen4-mini",
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.choices[0].message.content)

import HanzoEdge

let model = try EdgeModel(path: "zen4-mini.gguf")

// Single generation
let response = try model.generate("Hello, world!")
print(response)

// Streaming
for try await token in model.stream("Explain quantum computing") {
    print(token, terminator: "")
}

import ai.hanzo.edge.EdgeModel

val model = EdgeModel.load("zen4-mini.gguf")

// Single generation
val response = model.generate("Hello, world!")
println(response)

// Streaming with coroutines
model.stream("Explain quantum computing").collect { token ->
    print(token)
}