Notes

nanite_user_guide

7 min read

Nanite Linux Distribution: User Guide

This comprehensive guide provides all the information you need to understand, build, and use Nanite, a specialized Debian-based Linux distribution for AI engineers and Vibe Coders.

What is Nanite?

Nanite is a specialized Linux distribution designed for AI engineers and Vibe Coders. It integrates various AI models, agents, and applications directly into the operating system, providing users with immediate access to AI assistance through Large Language Models (LLMs).

Key Features

  • Debian-based: Built on the solid foundation of Debian Linux
  • AI Integration: Various AI models and agents integrated directly into the system
  • Development Tools: Comprehensive suite of tools for AI development
  • User-friendly: Intuitive interfaces for accessing AI capabilities
  • Privacy-focused: All AI processing happens locally by default

Use Cases

  • AI Development: Rapid prototyping and development of AI applications
  • Creative Coding: AI-assisted creative coding and generative art
  • Data Science: AI-enhanced data analysis and visualization
  • Research: Experimentation with various AI models and techniques
  • Education: Learning about AI and machine learning

Getting Started

System Requirements

To run Nanite effectively, your system should meet these minimum requirements:

  • CPU: x86_64 processor, 4+ cores recommended
  • RAM: 16GB minimum, 32GB recommended for running larger models
  • Storage: 30GB minimum for base system, 100GB+ recommended with models
  • GPU: NVIDIA GPU with 8GB+ VRAM (for CUDA acceleration) or AMD GPU with ROCm support

Installation Options

Nanite can be installed in several ways:

  1. Direct Installation: Install from the ISO image
  2. Virtual Machine: Run in a virtual machine using the provided VM images
  3. Live Boot: Boot from the ISO without installation for testing

Using the Live Environment

To use the live environment:

  1. Download the Nanite ISO image
  2. Create a bootable USB drive or DVD
  3. Boot your computer from the media
  4. Select “Live Boot” from the boot menu
  5. Explore Nanite without making any changes to your system

Installation Process

To install Nanite on your system:

  1. Boot from the Nanite ISO image
  2. Select “Install Nanite” from the boot menu
  3. Follow the installation wizard
  4. Reboot into your new Nanite system

Using Nanite

Desktop Environment

Nanite uses the XFCE desktop environment, providing a lightweight yet customizable interface. The desktop includes:

  • AI Assistant Panel: Quick access to the AI assistant
  • Application Menu: Access to all installed applications
  • File Manager: For navigating the file system
  • Terminal: For command-line operations

AI Features

AI Assistant

The Nanite AI Assistant provides system-wide AI assistance through both GUI and CLI interfaces.

GUI Interface:

  • Launch from the panel or Applications menu
  • Type questions or commands in the input field
  • View responses in the conversation area

CLI Interface:

  • Use the nanite-ask command: 
    nanite-ask How do I install Python packages?

Language Models (LLMs)

Nanite uses Ollama to manage and run language models. Common commands:

# List available models
ollama list
 
# Run a specific model in chat mode
ollama run mistral
 
# Pull additional models
ollama pull codellama

Retrieval-Augmented Generation (RAG)

Use the nanite-rag command for knowledge-based queries:

# Query a document
nanite-rag /path/to/document.txt "What is the main topic of this document?"

Speech Recognition and Synthesis

Use the nanite-speech command:

# Transcribe audio to text
nanite-speech transcribe audio.mp3
 
# Convert text to speech
nanite-speech synthesize "Hello, this is Nanite speaking" --output hello.wav

Image Generation

Generate images from text descriptions using the nanite-image-gen command:

# Generate an image
nanite-image-gen "A futuristic city with flying cars" --output city.png

Code Assistance

Get AI-powered coding help with the nanite-code-assist command:

# Generate code from description
nanite-code-assist generate "A function that calculates fibonacci numbers" --language python
 
# Complete code
nanite-code-assist complete mycode.py
 
# Explain code
nanite-code-assist explain mycode.py

Development Environment

Nanite includes a comprehensive development environment for AI and machine learning:

  • VSCode: With AI-related extensions
  • JupyterLab: For interactive notebooks
  • Python: With AI/ML libraries pre-installed
  • Git: For version control
  • Docker: For containerization

Building Nanite

If you want to build Nanite yourself or customize it for your needs, follow these steps:

Prerequisites

Before building Nanite, ensure you have:

  • A Debian-based system (Debian or Ubuntu recommended)
  • At least 20GB of free disk space
  • Good internet connection
  • Basic familiarity with Linux and command line

Building Process Overview

The build process involves these main steps:

  1. Set up the build environment
  2. Configure the live-build system
  3. Customize the distribution
  4. Build the ISO image
  5. Test the resulting image
  6. Create VM images (optional)

For detailed instructions, refer to the following guides:

  • Live-build Documentation: Understanding the build system
  • Live-build Configuration: Setting up the build configuration
  • AI Integration Guide: Integrating AI models and applications
  • Build and Test Guide: Building and testing the ISO
  • VM Image Creation Guide: Creating virtual machine images

Customizing Nanite

Nanite is designed to be highly customizable. Here are some common customizations:

Adding Custom Models

To add custom AI models:

  1. Use Ollama to create or pull models:

    ollama pull <model-name>

  2. Create custom models with specific parameters:

    cat > modelfile << EOF
FROM mistral:latest
PARAMETER temperature 0.7
SYSTEM You are a helpful assistant.
EOF
 
ollama create my-assistant -f modelfile

Customizing the Desktop

To customize the desktop environment:

  1. Right-click on the desktop and select “Desktop Settings”
  2. Use the XFCE Settings Manager for more advanced customization
  3. Edit panel settings by right-clicking on the panel and selecting “Panel Preferences”

Adding Custom Applications

To add custom applications:

  1. Install using apt:

    sudo apt install <package-name>

  2. Install Python packages:

    pip install <package-name>

  3. Install from source:

    git clone <repository-url>
cd <repository-directory>
# Follow installation instructions

Troubleshooting

Common Issues

AI Models Not Loading

If AI models fail to load:

  1. Check if Ollama service is running:

    systemctl status ollama

  2. Restart the service:

    sudo systemctl restart ollama

  3. Check available disk space:

    df -h

AI Assistant Not Responding

If the AI assistant is not responding:

  1. Check if the assistant service is running:

    systemctl status nanite-assistant

  2. Restart the service:

    sudo systemctl restart nanite-assistant

  3. Check logs for errors:

    journalctl -u nanite-assistant

Performance Issues

If experiencing performance issues:

  1. Check system resources:

    htop

  2. Monitor GPU usage:

    nvidia-smi -l 1

  3. Adjust model settings for lower resource usage:

    # Edit /etc/ollama/config to reduce GPU layers

Getting Help

If you encounter issues not covered in this guide:

  1. Check the documentation in /usr/share/doc/nanite/
  2. Visit the Nanite community forums
  3. Submit issues to the Nanite GitHub repository

Advanced Topics

Creating Custom AI Agents

To create custom AI agents:

  1. Use the LangChain framework:

    from langchain_community.llms import Ollama
from langchain.agents import initialize_agent, Tool
 
llm = Ollama(model="nanite-assistant")
tools = [
    Tool(
        name="Search",
        func=lambda q: "Search results for: " + q,
        description="Useful for searching information"
    )
]
 
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)
agent.run("What is the capital of France?")

  2. Save your agents in /usr/share/nanite/agents/

Integrating with External Services

To integrate with external services:

  1. Use API keys stored in environment variables
  2. Create configuration files in /etc/nanite/
  3. Use the Nanite plugin system to add new capabilities

Creating Custom Distributions

To create your own custom distribution based on Nanite:

  1. Follow the build process documentation
  2. Modify the configuration files to suit your needs
  3. Add or remove packages as required
  4. Customize the branding and appearance
  5. Build your custom ISO

Conclusion

Nanite provides a powerful, integrated environment for AI development, creative coding, and exploration. By combining the stability of Debian with cutting-edge AI capabilities, it offers a unique platform for innovation and creativity.

Whether you’re using the pre-built images or building your own custom version, Nanite empowers you to leverage the full potential of AI in your projects.

For more information and updates, visit the Nanite project website and community forums.

Graph View

Backlinks