# macOS
brew install --cask gpt4all

# Windows
# Download from: https://gpt4all.io

# Linux
# AppImage available at: https://gpt4all.io

# In GPT4All UI:
# 1. Click "Models" in sidebar
# 2. Browse available models
# 3. Click download for:
#    - gpt4all-13b-snoozy (best overall)
#    - mistral-7b-openorca (fast)
#    - orca-mini-3b (low memory)

# Example: Use GPT4All for code review
# Just paste your code and ask:

"""
Review this Python function for bugs and improvements:

def get_user_data(user_id):
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")
    return cursor.fetchone()
"""

# GPT4All will respond:
"""
Security Issues:
1. SQL Injection vulnerability - use parameterized queries
2. No error handling for database failures
3. Connection not closed (resource leak)

Improvements:
- Use context managers
- Add input validation
- Handle exceptions
"""

# macOS
brew install --cask lm-studio

# Windows
# Download from: https://lmstudio.ai

# Linux
# Experimental AppImage available

# In LM Studio UI:
# 1. Search for models in sidebar
# 2. Recommended coding models:
#    - CodeLlama 13B (best for code)
#    - DeepSeek Coder 33B (excellent, larger)
#    - Mistral 7B (balanced)
#    - Qwen 2.5 Coder (new, excellent)

# 3. Click "Load" to load into memory
# 4. Adjust settings:
#    - GPU offload: 35-40 layers
#    - Context length: 4K-8K
#    - Temperature: 0.2-0.5 for coding

# LM Studio chat interface:

User: "Write a Rust function to parse CSV with Serde"

Model response:
```rust
use csv::ReaderBuilder;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Record {
    name: String,
    email: String,
    age: u32,
}

fn parse_csv(path: &str) -> Result<Vec<Record>, csv::Error> {
    let mut reader = ReaderBuilder::new()
        .has_headers(true)
        .from_path(path)?;
    
    let mut records = Vec::new();
    for result in reader.deserialize() {
        let record = result?;
        records.push(record);
    }
    
    Ok(records)
}

# Docker (recommended)
docker run -p 8080:8080 --name local-ai \
  -v $(pwd)/models:/models \
  quay.io/go-skynet/local-ai:latest

# Or binary
curl -L -o local-ai https://github.com/mudler/LocalAI/releases/download/v2.0.0/local-ai-linux-amd64
chmod +x local-ai
./local-ai

# Download models to ./models directory
# Supported formats: GGUF, GPTQ, ONNX

# For coding, download:
# - codellama-7b-instruct-q4_K_M.gguf
# - mistral-7b-instruct-v0.2.gguf

# Example: Download CodeLlama
wget -O models/codellama-7b-instruct-q4_K_M.gguf \
  "https://huggingface.co/TheBloke/CodeLlama-7B-Instruct-GGUF/resolve/main/codellama-7b-instruct-q4_K_M.gguf"

# Chat completion
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "codellama-7b-instruct-q4_K_M",
    "messages": [{"role": "user", "content": "Write a Go HTTP handler"}],
    "temperature": 0.3
  }'

# Embeddings
curl http://localhost:8080/v1/embeddings \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sentence-transformers",
    "input": "Hello world"
  }'

# Image generation (stable diffusion)
curl http://localhost:8080/v1/images/generations \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stablediffusion",
    "prompt": "a beautiful sunset"
  }'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"
)

# Use for code completion
def complete_code(prompt: str) -> str:
    response = client.chat.completions.create(
        model="codellama-7b-instruct-q4_K_M",
        messages=[
            {"role": "system", "content": "You are a coding assistant. Write clean, efficient code."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.2,
        max_tokens=500
    )
    return response.choices[0].message.content

# Use for code review
def review_code(code: str) -> str:
    return complete_code(f"Review this code for bugs and improvements:\n\n{code}")

# Use for documentation
def document_code(code: str) -> str:
    return complete_code(f"Add docstrings to this code:\n\n{code}")

# VSCode
# 1. Open VSCode Extensions
# 2. Search "Continue"
# 3. Install

# Or JetBrains
# Search "Continue" in JetBrains Marketplace

// ~/.continue/config.json
{
  "models": [
    {
      "provider": "ollama",
      "model": "codestral"
    },
    {
      "provider": "openai",
      "model": "gpt-4",
      "apiKey": "${env.OPENAI_API_KEY}"
    },
    {
      "provider": "anthropic", 
      "model": "claude-3-5-sonnet-20241022",
      "apiKey": "${env.ANTHROPIC_API_KEY}"
    }
  ],
  "tabAutocompleteModel": {
    "provider": "ollama",
    "model": "codestral"
  },
  "contextProviders": [
    {"name": "github"},
    {"name": "grep"},
    {"name": "file"},
    {"name": "url"}
  ]
}

# VSCode keyboard shortcuts:
# Cmd+L - Edit highlighted code
# Cmd+Shift+L - Chat with selected context
# Cmd+K - Autocomplete (inline)
# Cmd+Shift+Enter - Accept suggestion

# JetBrains:
# Ctrl+L - Edit code
# Ctrl+Shift+L - Chat
# Tab - Accept autocomplete

# Highlight code and press Cmd+L

# Ask: "Add error handling and logging"
# Continue responds with improved code:

import logging

logger = logging.getLogger(__name__)

def process_data(data: dict) -> dict:
    """Process input data with error handling."""
    try:
        # Validate input
        if not data.get('id'):
            raise ValueError("Missing required field: id")
        
        # Process
        result = transform(data)
        
        logger.info(f"Successfully processed data: {data['id']}")
        return result
        
    except ValueError as e:
        logger.error(f"Validation error: {e}")
        raise
    except Exception as e:
        logger.exception(f"Unexpected error processing data")
        raise

# Continue can index your codebase for context-aware assistance

# 1. Right-click in file tree
# 2. "Index this Project"
# 3. Wait for indexing to complete

# Now you can ask:
# "How does authentication work in this codebase?"
# "Find all uses of the User model"
# "Where is the payment processing logic?"

# Docker (recommended)
docker run -d \
  --name tabby \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  tabbyml/tabby:latest \
  --device cuda

# Or binary release
curl -L -o tabby.tar.gz https://github.com/TabbyML/tabby/releases/download/v0.8.0/tabby_x86_64-linux_gnu.tar.gz
tar -xzf tabby.tar.gz
./tabby serve --model StarCoder-1B --device cuda

# VSCode - Install "Tabby" extension
# JetBrains - Install "Tabby" plugin
# Vim/Neovim - Use Tabby extension

# Connect to local server:
# Host: localhost
# Port: 8080

# Tabby provides inline code completion

# Start typing:
def calculate_fibonacci(n: int) -> list[int]:
    """Calculate Fibonacci sequence up to n numbers."""
    
# Tabby suggests:
    if n <= 0:
        return []
    
    fib = [0, 1]
    while len(fib) < n:
        fib.append(fib[-1] + fib[-2])
    return fib[:n]
# Press Tab to accept

# Or for more complex:
def process_user(user_data: dict) -> User:
    # Tabby suggests full function

# If running out of VRAM, try:

# 1. Quantized models (Q4_K_M, Q5_K_S)
# Smaller file, less memory, slight quality loss

# 2. Reduce GPU layers
# In Ollama: GPU_LAYERS=20 ollama run model
# In LM Studio: Adjust "GPU offload" slider

# 3. Use smaller models
# 7B instead of 13B, 13B instead of 34B

# 4. CPU fallback
# Works without GPU, much slower

# Ollama optimization
export OLLAMA_GPU_LAYERS=35
export OLLAMA_FLASH_ATTENTION=1
export OCL_XTSetPreferenceAMD_GPU_BLOCK_SIZE=32

# LM Studio settings
# GPU Settings:
#   - Context Length: 4096
#   - GPU Offload: 35 layers
#   - Threads: Auto

# Temperature guide:
# 0.0-0.2: Precise, factual (code explanation)
# 0.3-0.5: Balanced (general coding)
# 0.6-0.8: Creative (writing tests, comments)
# 0.9+: Very creative (avoid for code)