sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-venv git build-essential

# Create virtual environment
python3 -m venv airllm-env
source airllm-env/bin/activate

# Upgrade packaging tools
pip install --upgrade pip setuptools wheel

# Core installation
pip install airllm

# Optional: for quantized inference (faster, small precision loss)
pip install -U bitsandbytes

# Verify installation
python3 -c "from airllm import AutoModel; print('AirLLM installed successfully!')"

# Create models directory
mkdir -p ~/models && cd ~/models

# Download model (first run will be slow - downloads ~7GB)
python3 -c "
from airllm import AutoModel
model = AutoModel.from_pretrained('microsoft/Phi-3-mini-4k-instruct')
print('Model downloaded and initialized!')
"

from airllm import AutoModel
import time

print("Loading model...")
start = time.time()
model = AutoModel.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
print(f"Model loaded in {time.time() - start:.1f} seconds")

prompt = "Explain artificial intelligence in one sentence"
print(f"\nPrompt: {prompt}")

print("\nGenerating response...")
start = time.time()
output = model.generate([prompt], max_new_tokens=50, temperature=0.7, do_sample=True)
print(f"Generation took {time.time() - start:.1f} seconds")

response = model.tokenizer.decode(output[0], skip_special_tokens=True)
# Remove the prompt from the response
if prompt in response:
    response = response[len(prompt):].strip()

print(f"\nResponse: {response}")

python3 test_airllm.py

# kb_qa.py
from airllm import AutoModel

class OfflineKBQA:
    def __init__(self, model_name="microsoft/Phi-3-mini-4k-instruct"):
        print("Initializing offline knowledge base...")
        self.model = AutoModel.from_pretrained(model_name)
        self.kb = self._load_kb()

    def _load_kb(self):
        """Simple knowledge base - replace with your documents"""
        return {
            "raspberry pi": "Raspberry Pi is a series of small single-board computers developed in the UK.",
            "airllm": "AirLLM enables running large language models on low-VRAM GPUs via layer-wise inference.",
            "llm": "Large Language Models are AI models with billions of parameters trained on vast text corpora."
        }

    def answer(self, question):
        # Simple keyword match (use embeddings/vector DB for production)
        context = "\n".join([f"{k}: {v}" for k, v in self.kb.items() 
                           if any(word in question.lower() for word in k.split())])

        if not context:
            context = "No specific information found in knowledge base."

        prompt = f"""Based on the following information, answer the question:
{context}

Question: {question}
Answer:"""

        output = self.model.generate([prompt], max_new_tokens=100, temperature=0.3)
        response = self.model.tokenizer.decode(output[0], skip_special_tokens=True)

        if "Answer:" in response:
            return response.split("Answer:")[-1].strip()
        return response.strip()

# Example usage
if __name__ == "__main__":
    qa = OfflineKBQA()
    print(qa.answer("What is Raspberry Pi?"))
    print(qa.answer("How does AirLLM work?"))

# voice_assistant.py
import speech_recognition as sr
import pyttsx3
from airllm import AutoModel

class VoiceAssistant:
    def __init__(self):
        print("Initializing voice assistant...")

        # Speech components
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
        self.tts = pyttsx3.init()

        # Configure TTS
        voices = self.tts.getProperty('voices')
        self.tts.setProperty('voice', voices[0].id)
        self.tts.setProperty('rate', 150)

        # Load model
        self.model = AutoModel.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
        self.history = []

        print("Voice assistant ready! Say 'exit' to quit.")

    def listen(self):
        with self.microphone as source:
            print("\n🎤 Listening...")
            self.recognizer.adjust_for_ambient_noise(source, duration=0.5)
            audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=10)

        try:
            return self.recognizer.recognize_google(audio, language='en-US')
        except:
            return None

    def speak(self, text):
        print(f"🤖 Assistant: {text}")
        self.tts.say(text)
        self.tts.runAndWait()

    def respond(self, user_input):
        # Build conversation context
        history = "\n".join(self.history[-4:])  # Last 4 exchanges
        prompt = f"{history}\nUser: {user_input}\nAssistant:" if history else f"User: {user_input}\nAssistant:"

        output = self.model.generate([prompt], max_new_tokens=150, temperature=0.7)
        response = self.model.tokenizer.decode(output[0], skip_special_tokens=True)

        if "Assistant:" in response:
            return response.split("Assistant:")[-1].strip()
        return response.strip()

    def run(self):
        try:
            while True:
                user_input = self.listen()
                if not user_input:
                    continue

                if user_input.lower() in ['exit', 'quit', 'goodbye']:
                    self.speak("Goodbye!")
                    break

                response = self.respond(user_input)
                self.speak(response)

                # Update history
                self.history.extend([f"User: {user_input}", f"Assistant: {response}"])
        except KeyboardInterrupt:
            print("\nAssistant stopped.")

if __name__ == "__main__":
    VoiceAssistant().run()

pip install prompt-toolkit

# coding_assistant.py
from airllm import AutoModel
from prompt_toolkit import PromptSession
from prompt_toolkit.history import FileHistory

def main():
    print("🤖 AirLLM Coding Assistant - Type 'exit' to quit\n")

    model = AutoModel.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
    session = PromptSession(history=FileHistory('~/.coding_assistant_history'))

    while True:
        try:
            user_input = session.prompt("💻 You: ")
            if user_input.lower() in ['exit', 'quit']:
                break
            if not user_input.strip():
                continue

            prompt = f"""You are an expert programmer. Provide clear, working code to solve this request:
{user_input}

Code solution:"""

            print("\n🤖 Thinking...")
            output = model.generate([prompt], max_new_tokens=300, temperature=0.2)
            response = model.tokenizer.decode(output[0], skip_special_tokens=True)

            # Extract code blocks if present
            if "```python" in response:
                start = response.find("```python") + 9
                end = response.find("```", start)
                if end != -1:
                    code = response[start:end].strip()
                    print(f"\n💡 Suggested code:\n{code}\n")
                else:
                    print(f"\n💡 Response:\n{response}\n")
            else:
                print(f"\n💡 Response:\n{response}\n")

        except (EOFError, KeyboardInterrupt):
            print("\n👋 Goodbye!")
            break

if __name__ == "__main__":
    main()