mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
582 lines
31 KiB
HTML
582 lines
31 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>discover-hanzo</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/discover-hanzo.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/discover-hanzo">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/discover-hanzo.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>discover-hanzo</h1><p class="lede">Gateway to the Hanzo ecosystem — AI infrastructure, local AI, MCP, privacy-preserving inference and agentic workflows. Use when a task mentions Hanzo or needs orientation before reaching for a more specific Hanzo skill.</p><h1>Discover Hanzo - AI Infrastructure & Development Ecosystem</h1>
|
|
<p><strong>Gateway Skill</strong>: Auto-activates on keywords like "hanzo", "local ai", "mcp", "privacy ai", "agentic workflow"</p>
|
|
<h2>Overview</h2>
|
|
<p>Hanzo is a comprehensive AI infrastructure ecosystem focused on <strong>privacy-first, locally-run AI</strong> with composable, production-ready abstractions. Rather than building AI systems line-by-line, Hanzo provides higher-level "legos" that integrate seamlessly for agentic workflows, distributed AI, and blockchain-powered applications.</p>
|
|
<h3>Core Philosophy</h3>
|
|
<ul><li><strong>Local-First AI</strong>: Run foundational models on your infrastructure for privacy and cost control</li><li><strong>Composable Abstractions</strong>: Use high-level SDKs and components instead of raw code</li><li><strong>MCP-Native</strong>: Built for Model Context Protocol to enable seamless agentic workflows</li><li><strong>Open Source</strong>: All core infrastructure is open and extensible</li></ul>
|
|
<h3>Hanzo Product Stack</h3>
|
|
<pre><code>┌─────────────────────────────────────────────────────────┐
|
|
│ Application Layer │
|
|
│ @hanzo/ui (React) │ Hanzo Dev (Terminal) │ Custom Apps │
|
|
└─────────────────────────────────────────────────────────┘
|
|
↓ (MCP, HTTP, gRPC)
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ Integration & Orchestration Layer │
|
|
│ Hanzo MCP (Agentic) │ Python SDK │ Ruby SDK │ Terraform│
|
|
└─────────────────────────────────────────────────────────┘
|
|
↓ (Hanzo Protocol)
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ Infrastructure Layer │
|
|
│ Hanzo Node (Rust) - Mining, Inference, P2P Networking │
|
|
│ Hanzo Live - Real-time Generative AI Pipelines │
|
|
└─────────────────────────────────────────────────────────┘</code></pre>
|
|
<h2>Quick Reference</h2>
|
|
<h3>Hanzo Node (Rust)</h3>
|
|
<p><strong>Purpose</strong>: Distributed AI compute network for mining and local inference <strong>Key Features</strong>: GPU/CPU scheduling, P2P networking, consensus engine <strong>Use When</strong>: Running local models privately, joining AI network</p>
|
|
<pre><code class="lang-bash">cargo build --release
|
|
hanzo-node start --mine --gpu
|
|
hanzo-node status</code></pre>
|
|
<h3>Hanzo MCP</h3>
|
|
<p><strong>Purpose</strong>: Model Context Protocol integration for agentic workflows <strong>Key Features</strong>: Tool orchestration, context sharing, multi-agent coordination <strong>Use When</strong>: Building AI agents, exposing capabilities via MCP</p>
|
|
<pre><code class="lang-typescript">import { MCPServer } from '@hanzo/mcp'
|
|
|
|
const server = new MCPServer({
|
|
tools: [hanzoNodeTool, uiComponentTool],
|
|
resources: [localAI, vectorDB]
|
|
})</code></pre>
|
|
<h3>@hanzo/ui</h3>
|
|
<p><strong>Purpose</strong>: React component library for AI+Blockchain applications <strong>Key Features</strong>: Pre-built AI components, wallet integration, elegant design <strong>Use When</strong>: Building AI dashboards, blockchain UIs, agent interfaces</p>
|
|
<pre><code class="lang-bash">pnpm add @hanzo/ui</code></pre>
|
|
<pre><code class="lang-typescript">import { AIChat, ModelSelector, WalletConnect } from '@hanzo/ui'
|
|
|
|
<AIChat model="local-llama" onMessage={handleMessage} /></code></pre>
|
|
<h3>Python SDK</h3>
|
|
<p><strong>Purpose</strong>: Unified gateway to foundational models and AI cloud <strong>Key Features</strong>: Multi-provider support, local inference, automatic routing <strong>Use When</strong>: Integrating AI into Python applications</p>
|
|
<pre><code class="lang-python">from hanzo import Hanzo
|
|
|
|
hanzo = Hanzo(inference_mode='local') # or 'cloud', 'hybrid'
|
|
response = hanzo.chat.completions.create(
|
|
model='llama-3-8b',
|
|
messages=[{'role': 'user', 'content': 'Explain Rust'}]
|
|
)</code></pre>
|
|
<h3>Hanzo Dev</h3>
|
|
<p><strong>Purpose</strong>: Terminal-based AI coding agent (like Claude Code, but CLI) <strong>Key Features</strong>: MCP integration, local AI, project understanding <strong>Use When</strong>: Agentic coding workflows, terminal-based development</p>
|
|
<pre><code class="lang-bash">hanzo-dev chat
|
|
hanzo-dev task "Add authentication to API"
|
|
hanzo-dev --mcp hanzo-node,hanzo-ui</code></pre>
|
|
<h3>Hanzo Live</h3>
|
|
<p><strong>Purpose</strong>: Real-time generative AI pipeline execution <strong>Key Features</strong>: Streaming inference, pipeline composition, live updates <strong>Use When</strong>: Building real-time AI features, streaming generation</p>
|
|
<h3>Additional Tools</h3>
|
|
<ul><li><strong>Hanzo Chat</strong>: AI conversation interface</li><li><strong>Hanzo Desktop</strong>: Desktop application for AI workflows</li><li><strong>Ruby SDK</strong>: Ruby language support</li><li><strong>Terraform Provider</strong>: Infrastructure-as-code for Hanzo deployments</li><li><strong>Skills Repository</strong>: This repository - contextual AI workflows</li></ul>
|
|
<h2>When to Use Hanzo</h2>
|
|
<h3>✅ Perfect For</h3>
|
|
<p><strong>Privacy-First AI</strong></p>
|
|
<ul><li>Healthcare, finance, legal applications with sensitive data</li><li>GDPR, HIPAA, SOC 2 compliance requirements</li><li>No data leaves your infrastructure</li></ul>
|
|
<p><strong>Local AI Deployment</strong></p>
|
|
<ul><li>On-premise inference with consumer GPUs</li><li>Edge deployment on devices</li><li>No API costs, no rate limits</li></ul>
|
|
<p><strong>Agentic Development</strong></p>
|
|
<ul><li>Building multi-agent workflows with MCP</li><li>Tool orchestration across AI capabilities</li><li>Terminal-based coding agents</li></ul>
|
|
<p><strong>AI+Blockchain Integration</strong></p>
|
|
<ul><li>DeFi with AI features</li><li>NFT platforms with AI generation</li><li>DAO governance with AI analysis</li></ul>
|
|
<p><strong>Distributed AI Compute</strong></p>
|
|
<ul><li>Joining mining network for inference</li><li>Load balancing across nodes</li><li>High-availability AI services</li></ul>
|
|
<h3>🔧 Hanzo's Higher-Level Abstractions</h3>
|
|
<p><strong>Instead of writing:</strong></p>
|
|
<pre><code class="lang-python"># Manual model routing
|
|
if complexity == "high":
|
|
model = "gpt-4"
|
|
elif cost_sensitive:
|
|
model = "llama-3-70b-local"
|
|
else:
|
|
model = "claude-sonnet"
|
|
|
|
response = requests.post(f"{model_endpoint}/chat", ...)</code></pre>
|
|
<p><strong>Use Hanzo:</strong></p>
|
|
<pre><code class="lang-python"># Automatic routing with cost optimization
|
|
from hanzo import Hanzo
|
|
|
|
hanzo = Hanzo(inference_mode='hybrid')
|
|
response = hanzo.chat.completions.create(
|
|
messages=[...],
|
|
auto_route=True # Handles complexity, cost, latency
|
|
)</code></pre>
|
|
<p><strong>Instead of:</strong></p>
|
|
<pre><code class="lang-typescript">// Manual UI for AI chat
|
|
const [messages, setMessages] = useState([])
|
|
const [loading, setLoading] = useState(false)
|
|
// 200+ lines of chat logic, streaming, error handling...</code></pre>
|
|
<p><strong>Use Hanzo:</strong></p>
|
|
<pre><code class="lang-typescript">// Production-ready AI chat component
|
|
import { AIChat } from '@hanzo/ui'
|
|
|
|
<AIChat
|
|
model="local-llama"
|
|
onMessage={handleMessage}
|
|
streaming
|
|
darkMode
|
|
/></code></pre>
|
|
<h2>Loading Skills by Category</h2>
|
|
<h3>Core AI Infrastructure</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-engine.md # Rust inference engine
|
|
cat skills/hanzo/hanzo-node.md # Distributed AI node
|
|
cat skills/hanzo/hanzo-network.md # AI agent topology
|
|
cat skills/hanzo/hanzo-llm-gateway.md # Unified LLM proxy (100+ providers)
|
|
cat skills/hanzo/hanzo-mcp.md # Model Context Protocol tools
|
|
cat skills/hanzo/hanzo-agent.md # Multi-agent SDK</code></pre>
|
|
<h3>Cloud Services</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-chat.md # Unified LLM API (86+ models)
|
|
cat skills/hanzo/hanzo-cloud.md # Cloud dashboard & management
|
|
cat skills/hanzo/hanzo-console.md # AI observability & tracing
|
|
cat skills/hanzo/hanzo-commerce-api.md # Billing & payments
|
|
cat skills/hanzo/hanzo-web3.md # Blockchain API (100+ chains)</code></pre>
|
|
<h3>Platform & Deployment</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-platform.md # PaaS (Agnost fork)
|
|
cat skills/hanzo/hanzo-studio.md # Visual AI workflows (ComfyUI fork)
|
|
cat skills/hanzo/hanzo-search.md # AI-powered search
|
|
cat skills/hanzo/hanzo-flow.md # Visual workflow builder
|
|
cat skills/hanzo/hanzo-stack.md # Local dev environment
|
|
cat skills/hanzo/hanzo-universe.md # Production K8s infrastructure</code></pre>
|
|
<h3>SDKs & Libraries</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/python-sdk.md # Python SDK
|
|
cat skills/hanzo/js-sdk.md # TypeScript SDK
|
|
cat skills/hanzo/go-sdk.md # Go SDK
|
|
cat skills/hanzo/rust-sdk.md # Rust SDK
|
|
cat skills/hanzo/hanzo-orm.md # Go generics ORM</code></pre>
|
|
<h3>Identity & Security</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-id.md # Identity & OAuth2/OIDC
|
|
cat skills/hanzo/hanzo-kms.md # Secret management (Hanzo KMS)
|
|
cat skills/hanzo/hanzo-vault.md # PCI card tokenization</code></pre>
|
|
<h3>Developer Tools</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-extension.md # Browser & IDE extensions
|
|
cat skills/hanzo/hanzo-cli.md # Command-line interface
|
|
cat skills/hanzo/hanzo-operative.md # Computer use agent
|
|
cat skills/hanzo/hanzo-dev.md # Terminal coding agent</code></pre>
|
|
<h3>AI/ML & Research</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/zenlm.md # Zen frontier models
|
|
cat skills/hanzo/hanzo-jin.md # Multimodal LLM (text/vision/audio)
|
|
cat skills/hanzo/hanzo-candle.md # Rust ML framework
|
|
cat skills/hanzo/hanzo-ane.md # Apple Neural Engine training
|
|
cat skills/hanzo/hanzo-evm.md # Rust EVM execution engine</code></pre>
|
|
<h3>Data & Observability</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/hanzo-database.md # PostgreSQL, Redis, pgvector
|
|
cat skills/hanzo/hanzo-datastore.md # Vector database
|
|
cat skills/hanzo/hanzo-o11y.md # Monitoring, tracing, errors
|
|
cat skills/hanzo/hanzo-insights.md # Analytics SDKs</code></pre>
|
|
<h3>Browse All Hanzo Skills (50+)</h3>
|
|
<pre><code class="lang-bash">cat skills/hanzo/INDEX.md</code></pre>
|
|
<h2>Integration Patterns</h2>
|
|
<h3>Pattern 1: Local AI with Privacy</h3>
|
|
<pre><code class="lang-python">from hanzo import Hanzo
|
|
|
|
# All inference happens locally - no external API calls
|
|
hanzo = Hanzo(
|
|
inference_mode='local',
|
|
node_url='http://localhost:8080'
|
|
)
|
|
|
|
# Process sensitive data privately
|
|
response = hanzo.chat.completions.create(
|
|
model='llama-3-8b',
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': sensitive_patient_data
|
|
}]
|
|
)</code></pre>
|
|
<h3>Pattern 2: MCP-Powered Agentic Workflows</h3>
|
|
<pre><code class="lang-bash"># Configure MCP servers
|
|
hanzo-dev config mcp add hanzo-node http://localhost:8080
|
|
hanzo-dev config mcp add hanzo-ui http://localhost:3000
|
|
|
|
# Execute multi-step workflow with MCP tools
|
|
hanzo-dev workflow "
|
|
1. Generate component using @hanzo/ui tool
|
|
2. Deploy model to Hanzo Node
|
|
3. Run integration tests
|
|
4. Update documentation
|
|
"</code></pre>
|
|
<h3>Pattern 3: Real-Time AI UI</h3>
|
|
<pre><code class="lang-typescript">import { AIChat, useHanzoLive } from '@hanzo/ui'
|
|
|
|
export function LiveAIDashboard() {
|
|
// Real-time pipeline updates
|
|
const { data, status } = useHanzoLive({
|
|
pipeline: 'text-generation-stream'
|
|
})
|
|
|
|
// Local inference via Hanzo Node
|
|
return (
|
|
<AIChat
|
|
inference="local"
|
|
model="llama-3-8b"
|
|
streaming
|
|
live
|
|
/>
|
|
)
|
|
}</code></pre>
|
|
<h3>Pattern 4: Distributed AI Cluster</h3>
|
|
<pre><code class="lang-yaml"># kubernetes/hanzo-cluster.yaml
|
|
apiVersion: apps/v1
|
|
kind: StatefulSet
|
|
metadata:
|
|
name: hanzo-node-cluster
|
|
spec:
|
|
serviceName: hanzo-nodes
|
|
replicas: 3
|
|
template:
|
|
spec:
|
|
containers:
|
|
- name: hanzo-node
|
|
image: hanzoai/node:latest
|
|
args:
|
|
- --mine
|
|
- --cluster-mode
|
|
- --gpu
|
|
resources:
|
|
limits:
|
|
nvidia.com/gpu: 1</code></pre>
|
|
<h2>Common Workflows</h2>
|
|
<h3>1. Setting Up Local AI Environment</h3>
|
|
<p><strong>Objective</strong>: Run AI locally for privacy and cost savings</p>
|
|
<pre><code class="lang-bash"># Install Hanzo Node
|
|
cargo install hanzo-node
|
|
|
|
# Initialize configuration
|
|
hanzo-node init --network mainnet
|
|
|
|
# Download models (GGUF format)
|
|
hanzo-node models pull llama-3-8b
|
|
hanzo-node models pull mistral-7b
|
|
|
|
# Start node with GPU acceleration
|
|
hanzo-node start --mine --gpu --layers 35
|
|
|
|
# Verify node status
|
|
hanzo-node status
|
|
hanzo-node peers # See connected nodes</code></pre>
|
|
<p><strong>Python SDK Connection</strong>:</p>
|
|
<pre><code class="lang-python">from hanzo import Hanzo
|
|
|
|
hanzo = Hanzo(
|
|
inference_mode='local',
|
|
node_url='http://localhost:8080'
|
|
)
|
|
|
|
# Test inference
|
|
response = hanzo.chat.completions.create(
|
|
model='llama-3-8b',
|
|
messages=[{'role': 'user', 'content': 'Hello!'}]
|
|
)
|
|
print(response.choices[0].message.content)</code></pre>
|
|
<h3>2. Building AI Dashboard with @hanzo/ui</h3>
|
|
<p><strong>Objective</strong>: Create production-ready AI interface quickly</p>
|
|
<pre><code class="lang-bash"># Create Next.js app
|
|
pnpm create next-app my-ai-app
|
|
cd my-ai-app
|
|
|
|
# Install Hanzo UI
|
|
pnpm add @hanzo/ui @hanzo/live</code></pre>
|
|
<pre><code class="lang-typescript">// app/page.tsx
|
|
import { AIChat, ModelSelector, TokenUsage, MetricsCard } from '@hanzo/ui'
|
|
import { useHanzoNode } from '@hanzo/ui/hooks'
|
|
|
|
export default function Dashboard() {
|
|
const node = useHanzoNode({ url: 'http://localhost:8080' })
|
|
|
|
return (
|
|
<div className="hanzo-dashboard">
|
|
<ModelSelector
|
|
models={node.models}
|
|
onSelect={node.selectModel}
|
|
/>
|
|
|
|
<AIChat
|
|
inference={node.infer}
|
|
streaming
|
|
darkMode
|
|
/>
|
|
|
|
<div className="metrics">
|
|
<MetricsCard title="Tokens" value={node.tokenUsage} />
|
|
<MetricsCard title="Latency" value={node.latency} />
|
|
</div>
|
|
</div>
|
|
)
|
|
}</code></pre>
|
|
<h3>3. Exposing Capabilities via MCP</h3>
|
|
<p><strong>Objective</strong>: Make Hanzo tools available to AI agents</p>
|
|
<pre><code class="lang-typescript">// mcp-server.ts
|
|
import { MCPServer, Tool, Resource } from '@hanzo/mcp'
|
|
import { HanzoNode } from '@hanzo/node'
|
|
|
|
const node = new HanzoNode({ url: 'http://localhost:8080' })
|
|
|
|
// Define tools
|
|
const inferTool: Tool = {
|
|
name: 'hanzo_infer',
|
|
description: 'Run inference on local Hanzo Node',
|
|
parameters: {
|
|
model: { type: 'string', required: true },
|
|
prompt: { type: 'string', required: true },
|
|
temperature: { type: 'number', default: 0.7 }
|
|
},
|
|
async execute({ model, prompt, temperature }) {
|
|
return await node.infer({ model, prompt, temperature })
|
|
}
|
|
}
|
|
|
|
// Define resources
|
|
const modelsResource: Resource = {
|
|
uri: 'hanzo://models',
|
|
name: 'Available Models',
|
|
description: 'List of models on local Hanzo Node',
|
|
async read() {
|
|
return await node.listModels()
|
|
}
|
|
}
|
|
|
|
// Start MCP server
|
|
const server = new MCPServer({
|
|
name: 'hanzo-node-mcp',
|
|
tools: [inferTool],
|
|
resources: [modelsResource]
|
|
})
|
|
|
|
server.listen(8081)</code></pre>
|
|
<h3>4. Agentic Coding with Hanzo Dev</h3>
|
|
<p><strong>Objective</strong>: Use AI agent for terminal-based development</p>
|
|
<pre><code class="lang-bash"># Interactive chat mode
|
|
hanzo-dev chat
|
|
|
|
> "Add authentication middleware to Express API"
|
|
# Hanzo Dev analyzes codebase, generates middleware, updates routes
|
|
|
|
# Task mode (non-interactive)
|
|
hanzo-dev task "Refactor database layer to use repository pattern"
|
|
|
|
# Workflow with MCP tools
|
|
hanzo-dev --mcp hanzo-node,hanzo-ui workflow "
|
|
1. Generate React dashboard using @hanzo/ui components
|
|
2. Add real-time updates via Hanzo Live
|
|
3. Deploy inference backend to Hanzo Node
|
|
4. Write integration tests
|
|
"</code></pre>
|
|
<h2>Hanzo vs Traditional Approaches</h2>
|
|
<p>| Task | Traditional | Hanzo | |------|------------|-------| | <strong>Model Inference</strong> | 200 lines (HTTP, retries, parsing) | 5 lines (SDK) | | <strong>UI Chat Component</strong> | 500 lines (state, streaming, errors) | 1 component | | <strong>MCP Integration</strong> | Custom protocol implementation | Import <code>@hanzo/mcp</code> | | <strong>Local AI Setup</strong> | Docker, CUDA, model conversion | <code>hanzo-node start</code> | | <strong>Distributed Compute</strong> | K8s, load balancers, health checks | Hanzo Node cluster | | <strong>Privacy</strong> | Custom encryption, auth, auditing | Built-in (local-first) |</p>
|
|
<h2>Related Skills</h2>
|
|
<p><strong>Prerequisites</strong>:</p>
|
|
<ul><li><code>zig/zig-project-setup.md</code> - For understanding Rust patterns (similar concepts)</li><li><code>containers/docker-compose-development.md</code> - For local Hanzo Node setup</li><li><code>frontend/react-state-management.md</code> - For @hanzo/ui integration</li></ul>
|
|
<p><strong>Related Workflows</strong>:</p>
|
|
<ul><li><code>ml/llm-model-routing.md</code> - Hanzo SDK handles this automatically</li><li><code>ml/llm-model-selection.md</code> - Updated with Hanzo patterns</li><li><code>workflow/beads-workflow.md</code> - Agentic task management</li><li><code>observability/prometheus-monitoring.md</code> - Monitoring Hanzo Node</li></ul>
|
|
<p><strong>Next Steps</strong>:</p>
|
|
<ul><li><code>hanzo/hanzo-node.md</code> - Deep dive into Rust node architecture</li><li><code>hanzo/hanzo-mcp.md</code> - Comprehensive MCP patterns</li><li><code>hanzo/python-sdk.md</code> - Full SDK API reference</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-28 <strong>Category</strong>: Hanzo Ecosystem <strong>Related</strong>: ml, infrastructure, frontend, workflow <strong>Prerequisites</strong>: Docker, Node.js, Rust (for Hanzo Node development)</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/discover-hanzo.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div>
|
|
</body></html> |