Skip to content

README.it.md

Latest commit

 

History

History
914 lines (666 loc) · 42.3 KB

README.it.md

File metadata and controls

914 lines (666 loc) · 42.3 KB

ZeroClaw

ZeroClaw 🦀

Zero overhead. Zero compromesso. 100% Rust. 100% Agnostico.
⚡️ Gira su hardware da $10 con <5MB di RAM: È il 99% di memoria in meno di OpenClaw e il 98% più economico di un Mac mini!

License: MIT OR Apache-2.0 Contributors Buy Me a Coffee X: @zeroclawlabs WeChat Group Xiaohongshu: Official Telegram: @zeroclawlabs Facebook Group Reddit: r/zeroclawlabs

Costruito da studenti e membri delle comunità Harvard, MIT e Sundai.Club.

🌐 Lingue:🇺🇸 English · 🇨🇳 简体中文 · 🇯🇵 日本語 · 🇰🇷 한국어 · 🇻🇳 Tiếng Việt · 🇵🇭 Tagalog · 🇪🇸 Español · 🇧🇷 Português · 🇮🇹 Italiano · 🇩🇪 Deutsch · 🇫🇷 Français · 🇸🇦 العربية · 🇮🇳 हिन्दी · 🇷🇺 Русский · 🇧🇩 বাংলা · 🇮🇱 עברית · 🇵🇱 Polski · 🇨🇿 Čeština · 🇳🇱 Nederlands · 🇹🇷 Türkçe · 🇺🇦 Українська · 🇮🇩 Bahasa Indonesia · 🇹🇭 ไทย · 🇵🇰 اردو · 🇷🇴 Română · 🇸🇪 Svenska · 🇬🇷 Ελληνικά · 🇭🇺 Magyar · 🇫🇮 Suomi · 🇩🇰 Dansk · 🇳🇴 Norsk

Avvio Rapido | Configurazione con Un Clic | Hub Documentazione | Indice Documentazione

Accessi rapidi: Riferimento · Operazioni · Risoluzione Problemi · Sicurezza · Hardware · Contribuire

Infrastruttura assistente AI veloce, leggera e completamente autonoma
Distribuisci ovunque. Scambia qualsiasi cosa.

ZeroClaw è il sistema operativo runtime per i workflow degli agenti — un'infrastruttura che astrae modelli, strumenti, memoria ed esecuzione per costruire agenti una volta e eseguirli ovunque.

Architettura basata su trait · runtime sicuro di default · provider/canale/strumento intercambiabili · tutto è collegabile

📢 Annunci

Usa questa tabella per avvisi importanti (cambiamenti di compatibilità, avvisi di sicurezza, finestre di manutenzione e blocchi di versione).

Data (UTC) Livello Avviso Azione
2026-02-19 Critico Non siamo affiliati con openagen/zeroclaw o zeroclaw.org. Il dominio zeroclaw.org punta attualmente al fork openagen/zeroclaw, e questo dominio/repository sta contraffacendo il nostro sito web/progetto ufficiale. Non fidarti di informazioni, binari, raccolte fondi o annunci da queste fonti. Usa solo questo repository e i nostri account social verificati.
2026-02-21 Importante Il nostro sito ufficiale è ora online: zeroclawlabs.ai. Grazie per la pazienza durante l'attesa. Rileviamo ancora tentativi di contraffazione: non partecipare ad alcuna attività di investimento/finanziamento a nome di ZeroClaw se non pubblicata tramite i nostri canali ufficiali. Usa questo repository come unica fonte di verità. Segui X (@zeroclawlabs), Telegram (@zeroclawlabs), Facebook (gruppo), Reddit (r/zeroclawlabs), e Xiaohongshu per aggiornamenti ufficiali.
2026-02-19 Importante Anthropic ha aggiornato i termini di utilizzo di autenticazione e credenziali il 2026-02-19. L'autenticazione OAuth (Free, Pro, Max) è esclusivamente per Claude Code e Claude.ai; l'uso di token OAuth di Claude Free/Pro/Max in qualsiasi altro prodotto, strumento o servizio (incluso Agent SDK) non è consentito e può violare i Termini di Utilizzo del Consumatore. Si prega di evitare temporaneamente le integrazioni OAuth di Claude Code per prevenire qualsiasi potenziale perdita. Clausola originale: Authentication and Credential Use.

✨ Funzionalità

  • 🏎️ Runtime Leggero di Default: I workflow CLI comuni e i comandi di stato girano all'interno di uno spazio di memoria di pochi megabyte nelle build di produzione.
  • 💰 Distribuzione Economica: Progettato per schede a basso costo e piccole istanze cloud senza dipendenze runtime pesanti.
  • ⚡ Avvii a Freddo Rapidi: Il runtime Rust a binario singolo mantiene l'avvio di comandi e demoni quasi istantaneo per le operazioni quotidiane.
  • 🌍 Architettura Portabile: Un workflow a binario singolo su ARM, x86 e RISC-V con provider/canale/strumento intercambiabili.

Perché i team scelgono ZeroClaw

  • Leggero di default: binario Rust piccolo, avvio rapido, basso impatto di memoria.
  • Sicuro per design: pairing, sandboxing rigoroso, liste di autorizzazione esplicite, scope del workspace.
  • Completamente intercambiabile: i sistemi centrali sono trait (provider, canali, strumenti, memoria, tunnel).
  • Nessun lock-in del provider: supporto provider compatibile OpenAI + endpoint personalizzati collegabili.

Snapshot Benchmark (ZeroClaw vs OpenClaw, Riproducibile)

Benchmark rapido su macchina locale (macOS arm64, feb. 2026) normalizzato per hardware edge a 0.8 GHz.

OpenClaw NanoBot PicoClaw ZeroClaw 🦀
Linguaggio TypeScript Python Go Rust
RAM > 1 GB > 100 MB < 10 MB < 5 MB
Avvio (core 0.8 GHz) > 500s > 30s < 1s < 10ms
Dimensione Binario ~28 MB (dist) N/A (Scripts) ~8 MB 3.4 MB
Costo Mac Mini $599 Linux SBC ~$50 Scheda Linux $10 Qualsiasi hardware $10

Note: I risultati di ZeroClaw sono misurati su build di produzione usando /usr/bin/time -l. OpenClaw richiede il runtime Node.js (tipicamente ~390 MB di overhead memoria aggiuntivo), mentre NanoBot richiede il runtime Python. PicoClaw e ZeroClaw sono binari statici. Le cifre RAM sopra sono memoria runtime; i requisiti di compilazione in build-time sono maggiori.

Confronto ZeroClaw vs OpenClaw

Misurazione Locale Riproducibile

Le affermazioni di benchmark possono derivare man mano che il codice e le toolchain evolvono, quindi misura sempre la tua build attuale localmente:

cargo build --release
ls -lh target/release/zeroclaw

/usr/bin/time -l target/release/zeroclaw --help
/usr/bin/time -l target/release/zeroclaw status

Esempio di campione (macOS arm64, misurato il 18 febbraio 2026):

  • Dimensione binario release: 8.8M
  • zeroclaw --help: tempo reale circa 0.02s, impatto memoria massimo ~3.9 MB
  • zeroclaw status: tempo reale circa 0.01s, impatto memoria massimo ~4.1 MB

Prerequisiti

Windows

Windows — Richiesto

  1. Visual Studio Build Tools (fornisce il linker MSVC e il Windows SDK):

    winget install Microsoft.VisualStudio.2022.BuildTools

    Durante l'installazione (o via Visual Studio Installer), seleziona il carico di lavoro "Sviluppo desktop con C++".

  2. Toolchain Rust:

    winget install Rustlang.Rustup

    Dopo l'installazione, apri un nuovo terminale ed esegui rustup default stable per assicurarti che la toolchain stabile sia attiva.

  3. Verifica che entrambi funzionano:

    rustc --version
cargo --version

Windows — Opzionale

  • Docker Desktop — richiesto solo se usi il runtime Docker sandboxed (runtime.kind = "docker"). Installa via winget install Docker.DockerDesktop.
Linux / macOS

Linux / macOS — Richiesto

  1. Strumenti di build essenziali:

    • Linux (Debian/Ubuntu): sudo apt install build-essential pkg-config
    • Linux (Fedora/RHEL): sudo dnf group install development-tools && sudo dnf install pkg-config
    • macOS: Installa Xcode Command Line Tools: xcode-select --install

  2. Toolchain Rust:

    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

    Vedi rustup.rs per dettagli.

  3. Verifica:

    rustc --version
cargo --version

Linux / macOS — Opzionale

Avvio Rapido

Opzione 1: Configurazione automatizzata (consigliata)

Lo script bootstrap.sh installa Rust, clona ZeroClaw, lo compila, e configura il tuo ambiente di sviluppo iniziale:

curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/bootstrap.sh | bash

Questo:

  1. Installerà Rust (se non presente)
  2. Clonerà il repository ZeroClaw
  3. Compilerà ZeroClaw in modalità release
  4. Installerà zeroclaw in ~/.cargo/bin/
  5. Creerà la struttura del workspace di default in ~/.zeroclaw/workspace/
  6. Genererà un file di configurazione iniziale ~/.zeroclaw/workspace/config.toml

Dopo il bootstrap, ricarica la tua shell o esegui source ~/.cargo/env per usare il comando zeroclaw globalmente.

Opzione 2: Installazione manuale

Clicca per vedere i passaggi di installazione manuale 
# 1. Clona il repository
git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw

# 2. Compila in release
cargo build --release --locked

# 3. Installa il binario
cargo install --path . --locked

# 4. Inizializza il workspace
zeroclaw init

# 5. Verifica l'installazione
zeroclaw --version
zeroclaw status

Dopo l'installazione

Una volta installato (via bootstrap o manualmente), dovresti vedere:

~/.zeroclaw/workspace/
├── config.toml          # Configurazione principale
├── .pairing             # Segreti di pairing (generati al primo avvio)
├── logs/                # Log di daemon/agent
├── skills/              # Competenze personalizzate
└── memory/              # Archiviazione contesto conversazionale

Prossimi passi:

  1. Configura i tuoi provider AI in ~/.zeroclaw/workspace/config.toml
  2. Controlla la riferimento configurazione per opzioni avanzate
  3. Avvia l'agente: zeroclaw agent start
  4. Testa tramite il tuo canale preferito (vedi riferimento canali)

Configurazione

Modifica ~/.zeroclaw/workspace/config.toml per configurare provider, canali e comportamento del sistema.

Riferimento Configurazione Rapida

[providers.anthropic]
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"

[providers.openai]
api_key = "sk-..."
model = "gpt-4o"

[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."

[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@bot:matrix.org"
password = "..."

[memory]
kind = "markdown"  # o "sqlite" o "none"

[runtime]
kind = "native"    # o "docker" (richiede Docker)

Documenti di riferimento completi:

Supporto Runtime (attuale)

ZeroClaw supporta due backend di esecuzione del codice:

  • native (default) — esecuzione processo diretta, percorso più veloce, ideale per ambienti fidati
  • docker — isolamento container completo, politiche di sicurezza potenziate, richiede Docker

Usa runtime.kind = "docker" se hai bisogno di sandboxing rigoroso o isolamento rete. Vedi riferimento configurazione per dettagli completi.

Comandi

# Gestione workspace
zeroclaw init                # Inizializza un nuovo workspace
zeroclaw status              # Mostra stato daemon/agent
zeroclaw config validate     # Verifica sintassi e valori di config.toml

# Gestione daemon
zeroclaw daemon start        # Avvia il daemon in background
zeroclaw daemon stop         # Ferma il daemon in esecuzione
zeroclaw daemon restart      # Riavvia il daemon (ricaricamento config)
zeroclaw daemon logs         # Mostra log del daemon

# Gestione agent
zeroclaw agent start         # Avvia l'agent (richiede daemon in esecuzione)
zeroclaw agent stop          # Ferma l'agent
zeroclaw agent restart       # Riavvia l'agent (ricaricamento config)

# Operazioni di pairing
zeroclaw pairing init        # Genera un nuovo segreto di pairing
zeroclaw pairing rotate      # Ruota il segreto di pairing esistente

# Tunneling (per esposizione pubblica)
zeroclaw tunnel start        # Avvia un tunnel verso il daemon locale
zeroclaw tunnel stop         # Ferma il tunnel attivo

# Diagnostica
zeroclaw doctor              # Esegue controlli di salute del sistema
zeroclaw version             # Mostra versione e informazioni di build

Vedi Riferimento Comandi per opzioni ed esempi completi.

Architettura

┌─────────────────────────────────────────────────────────────────┐
│                        Canali (trait)                           │
│  Telegram │ Matrix │ Slack │ Discord │ Web │ CLI │ Custom       │
└─────────────────────────┬───────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Agente Orchestratore                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Routing    │  │   Contesto   │  │  Esecuzione  │          │
│  │   Messaggio  │  │   Memoria    │  │   Strumento  │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└─────────────────────────┬───────────────────────────────────────┘
                          │
          ┌───────────────┼───────────────┐
          ▼               ▼               ▼
┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│   Provider   │  │   Memoria    │  │  Strumenti   │
│   (trait)    │  │   (trait)    │  │   (trait)    │
├──────────────┤  ├──────────────┤  ├──────────────┤
│  Anthropic   │  │   Markdown   │  │  Filesystem  │
│   OpenAI     │  │    SQLite    │  │     Bash     │
│   Gemini     │  │     None     │  │   Web Fetch  │
│   Ollama     │  │    Custom    │  │   Custom     │
│   Custom     │  └──────────────┘  └──────────────┘
└──────────────┘
          │
          ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Runtime (trait)                               │
│                  Native │ Docker                                │
└─────────────────────────────────────────────────────────────────┘

Principi chiave:

  • Tutto è un trait — provider, canali, strumenti, memoria, tunnel
  • I canali chiamano l'orchestratore; l'orchestratore chiama provider + strumenti
  • Il sistema memoria gestisce il contesto conversazionale (markdown, SQLite, o nessuno)
  • Il runtime astrae l'esecuzione del codice (nativo o Docker)
  • Nessun lock-in del provider — scambia Anthropic ↔ OpenAI ↔ Gemini ↔ Ollama senza modifiche al codice

Vedi documentazione architettura per diagrammi dettagliati e dettagli di implementazione.

Esempi

Bot Telegram

[channels.telegram]
enabled = true
bot_token = "123456:ABC-DEF..."
allowed_users = [987654321]  # Il tuo ID utente Telegram

Avvia il daemon + agent, poi invia un messaggio al tuo bot su Telegram:

/start
Ciao! Potresti aiutarmi a scrivere uno script Python?

Il bot risponde con codice generato dall'AI, esegue strumenti se richiesto, e mantiene il contesto della conversazione.

Matrix (crittografia end-to-end)

[channels.matrix]
enabled = true
homeserver_url = "https://matrix.org"
username = "@zeroclaw:matrix.org"
password = "..."
device_name = "zeroclaw-prod"
e2ee_enabled = true

Invita @zeroclaw:matrix.org in una stanza crittografata, e il bot risponderà con crittografia completa. Vedi Guida Matrix E2EE per la configurazione della verifica dispositivo.

Multi-Provider

[providers.anthropic]
enabled = true
api_key = "sk-ant-..."
model = "claude-sonnet-4-20250514"

[providers.openai]
enabled = true
api_key = "sk-..."
model = "gpt-4o"

[orchestrator]
default_provider = "anthropic"
fallback_providers = ["openai"]  # Failover su errore del provider

Se Anthropic fallisce o va in rate-limit, l'orchestratore passa automaticamente a OpenAI.

Memoria Personalizzata

[memory]
kind = "sqlite"
path = "~/.zeroclaw/workspace/memory/conversations.db"
retention_days = 90  # Eliminazione automatica dopo 90 giorni

O usa Markdown per un archiviazione leggibile dall'uomo:

[memory]
kind = "markdown"
path = "~/.zeroclaw/workspace/memory/"

Vedi Riferimento Configurazione per tutte le opzioni memoria.

Supporto Provider

Provider Stato API Key Modelli di Esempio
Anthropic ✅ Stabile ANTHROPIC_API_KEY claude-sonnet-4-20250514, claude-opus-4-20250514
OpenAI ✅ Stabile OPENAI_API_KEY gpt-4o, gpt-4o-mini, o1, o1-mini
Google Gemini ✅ Stabile GOOGLE_API_KEY gemini-2.0-flash-exp, gemini-exp-1206
Ollama ✅ Stabile N/A (locale) llama3.3, qwen2.5, phi4
Cerebras ✅ Stabile CEREBRAS_API_KEY llama-3.3-70b
Groq ✅ Stabile GROQ_API_KEY llama-3.3-70b-versatile
Mistral 🚧 Pianificato MISTRAL_API_KEY TBD
Cohere 🚧 Pianificato COHERE_API_KEY TBD

Endpoint Personalizzati

ZeroClaw supporta endpoint compatibili con OpenAI:

[providers.custom]
enabled = true
api_key = "..."
base_url = "https://api.your-llm-provider.com/v1"
model = "your-model-name"

Esempio: usa LiteLLM come proxy per accedere a qualsiasi LLM tramite l'interfaccia OpenAI.

Vedi Riferimento Provider per dettagli di configurazione completi.

Supporto Canali

Canale Stato Autenticazione Note
Telegram ✅ Stabile Bot Token Supporto completo inclusi file, immagini, pulsanti inline
Matrix ✅ Stabile Password o Token Supporto E2EE con verifica dispositivo
Slack 🚧 Pianificato OAuth o Bot Token Richiede accesso workspace
Discord 🚧 Pianificato Bot Token Richiede permessi guild
WhatsApp 🚧 Pianificato Twilio o API ufficiale Richiede account business
CLI ✅ Stabile Nessuno Interfaccia conversazionale diretta
Web 🚧 Pianificato API Key o OAuth Interfaccia chat basata su browser

Vedi Riferimento Canali per istruzioni di configurazione complete.

Supporto Strumenti

ZeroClaw fornisce strumenti integrati per l'esecuzione del codice, l'accesso al filesystem e il recupero web:

Strumento Descrizione Runtime Richiesto
bash Esegue comandi shell Nativo o Docker
python Esegue script Python Python 3.8+ (nativo) o Docker
javascript Esegue codice Node.js Node.js 18+ (nativo) o Docker
filesystem_read Legge file Nativo o Docker
filesystem_write Scrive file Nativo o Docker
web_fetch Recupera contenuti web Nativo o Docker

Sicurezza dell'Esecuzione

  • Runtime Nativo — gira come processo utente del daemon, accesso completo al filesystem
  • Runtime Docker — isolamento container completo, filesystem e reti separati

Configura la politica di esecuzione in config.toml:

[runtime]
kind = "docker"
allowed_tools = ["bash", "python", "filesystem_read"]  # Lista di autorizzazione esplicita

Vedi Riferimento Configurazione per opzioni di sicurezza complete.

Distribuzione

Distribuzione Locale (Sviluppo)

zeroclaw daemon start
zeroclaw agent start

Distribuzione Server (Produzione)

Usa systemd per gestire daemon e agent come servizi:

# Installa il binario
cargo install --path . --locked

# Configura il workspace
zeroclaw init

# Crea i file di servizio systemd
sudo cp deployment/systemd/zeroclaw-daemon.service /etc/systemd/system/
sudo cp deployment/systemd/zeroclaw-agent.service /etc/systemd/system/

# Abilita e avvia i servizi
sudo systemctl enable zeroclaw-daemon zeroclaw-agent
sudo systemctl start zeroclaw-daemon zeroclaw-agent

# Verifica lo stato
sudo systemctl status zeroclaw-daemon
sudo systemctl status zeroclaw-agent

Vedi Guida Distribuzione di Rete per istruzioni complete di distribuzione in produzione.

Docker

# Compila l'immagine
docker build -t zeroclaw:latest .

# Esegui il container
docker run -d \
  --name zeroclaw \
  -v ~/.zeroclaw/workspace:/workspace \
  -e ANTHROPIC_API_KEY=sk-ant-... \
  zeroclaw:latest

Vedi Dockerfile per dettagli di build e opzioni di configurazione.

Hardware Edge

ZeroClaw è progettato per girare su hardware a basso consumo:

  • Raspberry Pi Zero 2 W — ~512 MB RAM, singolo core ARMv8, < $5 costo hardware
  • Raspberry Pi 4/5 — 1 GB+ RAM, multi-core, ideale per workload concorrenti
  • Orange Pi Zero 2 — ~512 MB RAM, quad-core ARMv8, costo ultra-basso
  • SBC x86 (Intel N100) — 4-8 GB RAM, build veloci, supporto Docker nativo

Vedi Guida Hardware per istruzioni di configurazione specifiche per dispositivo.

Tunneling (Esposizione Pubblica)

Espone il tuo daemon ZeroClaw locale alla rete pubblica tramite tunnel sicuri:

zeroclaw tunnel start --provider cloudflare

Provider di tunnel supportati:

  • Cloudflare Tunnel — HTTPS gratuito, nessuna esposizione di porte, supporto multi-dominio
  • Ngrok — configurazione rapida, domini personalizzati (piano a pagamento)
  • Tailscale — rete mesh privata, nessuna porta pubblica

Vedi Riferimento Configurazione per opzioni di configurazione complete.

Sicurezza

ZeroClaw implementa molteplici livelli di sicurezza:

Pairing

Il daemon genera un segreto di pairing al primo avvio memorizzato in ~/.zeroclaw/workspace/.pairing. I client (agent, CLI) devono presentare questo segreto per connettersi.

zeroclaw pairing rotate  # Genera un nuovo segreto e invalida quello precedente

Sandboxing

  • Runtime Docker — isolamento container completo con filesystem e reti separati
  • Runtime Nativo — gira come processo utente, con scope del workspace di default

Liste di Autorizzazione

I canali possono limitare l'accesso per ID utente:

[channels.telegram]
enabled = true
allowed_users = [123456789, 987654321]  # Lista di autorizzazione esplicita

Crittografia

  • Matrix E2EE — crittografia end-to-end completa con verifica dispositivo
  • Trasporto TLS — tutto il traffico API e tunnel usa HTTPS/TLS

Vedi Documentazione Sicurezza per politiche e pratiche complete.

Osservabilità

ZeroClaw registra i log in ~/.zeroclaw/workspace/logs/ di default. I log sono memorizzati per componente:

~/.zeroclaw/workspace/logs/
├── daemon.log           # Log del daemon (avvio, richieste API, errori)
├── agent.log            # Log dell'agent (routing messaggi, esecuzione strumenti)
├── telegram.log         # Log specifici del canale (se abilitato)
└── matrix.log           # Log specifici del canale (se abilitato)

Configurazione Logging

[logging]
level = "info"                           # debug, info, warn, error
path = "~/.zeroclaw/workspace/logs/"
rotation = "daily"                       # daily, hourly, size
max_size_mb = 100                        # Per rotazione basata sulla dimensione
retention_days = 30                      # Eliminazione automatica dopo N giorni

Vedi Riferimento Configurazione per tutte le opzioni di logging.

Metriche (Pianificato)

Supporto metriche Prometheus per il monitoraggio in produzione in arrivo. Tracciamento in #234.

Competenze (Skills)

ZeroClaw supporta competenze personalizzate — moduli riutilizzabili che estendono le capacità del sistema.

Definizione Competenza

Le competenze sono memorizzate in ~/.zeroclaw/workspace/skills/<skill-name>/ con questa struttura:

skills/
└── my-skill/
    ├── skill.toml       # Metadati competenza (nome, descrizione, dipendenze)
    ├── prompt.md        # Prompt di sistema per l'AI
    └── tools/           # Strumenti personalizzati opzionali
        └── my_tool.py

Esempio Competenza

# skills/web-research/skill.toml
[skill]
name = "web-research"
description = "Cerca sul web e riassume i risultati"
version = "1.0.0"

[dependencies]
tools = ["web_fetch", "bash"]
<!-- skills/web-research/prompt.md -->

Sei un assistente di ricerca. Quando ti viene chiesto di cercare qualcosa:

1. Usa web_fetch per recuperare il contenuto
2. Riassume i risultati in un formato facile da leggere
3. Cita le fonti con gli URL

Uso delle Competenze

Le competenze sono caricate automaticamente all'avvio dell'agent. Fai riferimento ad esse per nome nelle conversazioni:

Utente: Usa la competenza web-research per trovare le ultime notizie AI
Bot: [carica la competenza web-research, esegue web_fetch, riassume i risultati]

Vedi sezione Competenze (Skills) per istruzioni complete sulla creazione di competenze.

Open Skills

ZeroClaw supporta Open Skills — un sistema modulare e agnostico del provider per estendere le capacità degli agent AI.

Abilita Open Skills

[skills]
open_skills_enabled = true
# open_skills_dir = "/path/to/open-skills"  # opzionale

Puoi anche sovrascrivere a runtime con ZEROCLAW_OPEN_SKILLS_ENABLED e ZEROCLAW_OPEN_SKILLS_DIR.

Sviluppo

cargo build              # Build di sviluppo
cargo build --release    # Build release (codegen-units=1, funziona su tutti i dispositivi incluso Raspberry Pi)
cargo build --profile release-fast    # Build più veloce (codegen-units=8, richiede 16 GB+ RAM)
cargo test               # Esegue la suite di test completa
cargo clippy --locked --all-targets -- -D clippy::correctness
cargo fmt                # Formattazione

# Esegue il benchmark di confronto SQLite vs Markdown
cargo test --test memory_comparison -- --nocapture

Hook pre-push

Un hook git esegue cargo fmt --check, cargo clippy -- -D warnings, e cargo test prima di ogni push. Attivalo una volta:

git config core.hooksPath .githooks

Risoluzione Problemi di Build (errori OpenSSL su Linux)

Se incontri un errore di build openssl-sys, sincronizza le dipendenze e ricompila con il lockfile del repository:

git pull
cargo build --release --locked
cargo install --path . --force --locked

ZeroClaw è configurato per usare rustls per le dipendenze HTTP/TLS; --locked mantiene il grafo transitivo deterministico in ambienti puliti.

Per saltare l'hook quando hai bisogno di un push veloce durante lo sviluppo:

git push --no-verify

Collaborazione e Docs

Inizia con l'hub della documentazione per una mappa basata sui task:

Riferimenti principali di collaborazione:

Per distribuzione e operazioni runtime:

Supportare ZeroClaw

Se ZeroClaw aiuta il tuo lavoro e desideri supportare lo sviluppo continuo, puoi donare qui:

Offrimi un Caffè

🙏 Ringraziamenti Speciali

Un sincero ringraziamento alle comunità e istituzioni che ispirano e alimentano questo lavoro open-source:

  • Harvard University — per favorire la curiosità intellettuale e spingere i confini del possibile.
  • MIT — per difendere la conoscenza aperta, l'open source, e la convinzione che la tecnologia dovrebbe essere accessibile a tutti.
  • Sundai Club — per la comunità, l'energia, e la volontà incessante di costruire cose che contano.
  • Il Mondo e Oltre 🌍✨ — a ogni contributore, sognatore, e costruttore là fuori che rende l'open source una forza per il bene. Questo è per te.

Costruiamo in open source perché le migliori idee vengono da ovunque. Se stai leggendo questo, ne fai parte. Benvenuto. 🦀❤️

⚠️ Repository Ufficiale e Avviso di Contraffazione

Questo è l'unico repository ufficiale di ZeroClaw:

https://github.com/zeroclaw-labs/zeroclaw

Qualsiasi altro repository, organizzazione, dominio o pacchetto che afferma di essere "ZeroClaw" o che implica affiliazione con ZeroClaw Labs è non autorizzato e non affiliato a questo progetto. I fork non autorizzati noti saranno elencati in TRADEMARK.md.

Se incontri contraffazione o uso improprio del marchio, per favore apri una issue.

Licenza

ZeroClaw è doppia licenza per massima apertura e protezione dei contributori:

Licenza Casi d'Uso
MIT Open-source, ricerca, accademico, uso personale
Apache 2.0 Protezione brevetti, istituzionale, distribuzione commerciale

Puoi scegliere una delle due licenze. I contributori concedono automaticamente diritti sotto entrambe — vedi CLA.md per l'accordo completo dei contributori.

Marchio

Il nome ZeroClaw e il logo sono marchi registrati di ZeroClaw Labs. Questa licenza non concede il permesso di usarli per implicare approvazione o affiliazione. Vedi TRADEMARK.md per usi permessi e proibiti.

Protezioni dei Contributori

  • Mantieni i diritti d'autore dei tuoi contributi
  • Concessione brevetti (Apache 2.0) ti protegge da reclami di brevetti da parte di altri contributori
  • I tuoi contributi sono attribuiti permanentemente nella cronologia dei commit e NOTICE
  • Nessun diritto di marchio viene trasferito contribuendo

Contribuire

Vedi CONTRIBUTING.md e CLA.md. Implementa un trait, invia una PR:

  • Guida workflow CI: docs/ci-map.md
  • Nuovo Provider → src/providers/
  • Nuovo Channel → src/channels/
  • Nuovo Observer → src/observability/
  • Nuovo Tool → src/tools/
  • Nuova Memory → src/memory/
  • Nuovo Tunnel → src/tunnel/
  • Nuova Skill → ~/.zeroclaw/workspace/skills/<n>/

ZeroClaw — Zero overhead. Zero compromesso. Distribuisci ovunque. Scambia qualsiasi cosa. 🦀

Storico Stelle

Grafico Storico Stelle