ssh root@your-vps-ip

curl -fsSL https://ollama.com/install.sh | sh

ollama --version
# Expected: ollama version 0.x.x

systemctl status ollama
# Should show: active (running)

# Edit the Ollama service configuration
systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

systemctl daemon-reload
systemctl restart ollama

# Pull the model (takes 30-60 seconds on a good connection)
ollama pull minicpm-v-4.6

# Test with a text-only query
ollama run minicpm-v-4.6 "What is machine learning?"

# Describe an image
ollama run minicpm-v-4.6 "Describe this image in detail" --image /path/to/photo.jpg

# OCR: extract text from a screenshot
ollama run minicpm-v-4.6 "Extract all the text from this image" --image ./screenshot.png

# Analyze a chart
ollama run minicpm-v-4.6 "What are the key trends shown in this chart?" --image ./chart.png

# Describe a photo
ollama run minicpm-v-4.6 "Describe this photo in detail, including objects, colors, and setting" --image ./photo.jpg

# Code from screenshot
ollama run minicpm-v-4.6 "Read the code in this screenshot and explain what it does" --image ./code-screenshot.png

curl http://localhost:11434/api/generate -d '{
  "model": "minicpm-v-4.6",
  "prompt": "Explain neural networks in simple terms",
  "stream": false
}'

# Encode image to base64 (strip newlines)
IMAGE_B64=$(base64 -w0 /path/to/image.jpg)

curl http://localhost:11434/api/generate -d "{
  \"model\": \"minicpm-v-4.6\",
  \"prompt\": \"What is shown in this image?\",
  \"images\": [\"$IMAGE_B64\"],
  \"stream\": false
}" | jq -r '.response'

import requests
import base64
import json

def analyze_image(image_path: str, prompt: str) -> str:
    """Analyze an image using MiniCPM-V-4.6 via Ollama API."""
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": "minicpm-v-4.6",
            "prompt": prompt,
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

# Example usage
result = analyze_image("dashboard-screenshot.png", 
    "Analyze this dashboard screenshot. What metrics are shown? "
    "Are there any anomalies or warnings?")
print(result)

pip install requests
python analyze.py

docker run -d -p 3000:8080 \
  --name open-webui \
  --restart always \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://localhost:11434 \
  ghcr.io/open-webui/open-webui:main

pip install open-webui
open-webui serve

# Install vLLM
pip install vllm

# Serve the model
python -m vllm.entrypoints.openai.api_server \
  --model openbmb/MiniCPM-V-4.6 \
  --max-model-len 8192 \
  --dtype float16

# Create a 4GB swap file
fallocate -l 4G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# Make permanent
echo '/swapfile none swap sw 0 0' | tee -a /etc/fstab

# Adjust swappiness for SSD
sysctl vm.swappiness=10
echo 'vm.swappiness=10' | tee -a /etc/sysctl.conf

# Install Nginx
apt install -y nginx

# Create a password
apt install -y apache2-utils
htpasswd -c /etc/nginx/.htpasswd admin

server {
    listen 80;
    server_name your-domain.com;

    # Redirect to HTTPS (optional but recommended)
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your-domain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;

    # Open WebUI
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_buffering off;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    # Ollama API (password protected)
    location /ollama/ {
        auth_basic "Restricted Access";
        auth_basic_user_file /etc/nginx/.htpasswd;

        proxy_pass http://127.0.0.1:11434/;
        proxy_set_header Host $host;
    }
}

ln -s /etc/nginx/sites-available/open-webui /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx

#!/usr/bin/env python3
"""Monitor a directory for new images and analyze them with MiniCPM-V-4.6."""
import time
import os
import requests
import base64
import json

WATCH_DIR = "/data/images"
PROCESSED_DIR = "/data/processed"
OLLAMA_URL = "http://localhost:11434/api/generate"
POLL_INTERVAL = 10  # seconds

os.makedirs(PROCESSED_DIR, exist_ok=True)

def analyze_image(image_path):
    with open(image_path, "rb") as f:
        img_b64 = base64.b64encode(f.read()).decode()
    
    response = requests.post(OLLAMA_URL, json={
        "model": "minicpm-v-4.6",
        "prompt": "Analyze this image comprehensively. Describe what you see, "
                  "extract any text, identify any issues or anomalies.",
        "images": [img_b64],
        "stream": False
    })
    return response.json().get("response", "")

def main():
    print(f"Watching {WATCH_DIR} for new images...")
    seen = set()
    
    while True:
        for fname in os.listdir(WATCH_DIR):
            if fname in seen:
                continue
            fpath = os.path.join(WATCH_DIR, fname)
            if not os.path.isfile(fpath):
                continue
            ext = os.path.splitext(fname)[1].lower()
            if ext not in ('.png', '.jpg', '.jpeg', '.webp'):
                continue
            
            print(f"[{time.ctime()}] Processing: {fname}")
            result = analyze_image(fpath)
            
            # Save analysis result
            report_path = os.path.join(PROCESSED_DIR, f"{fname}.txt")
            with open(report_path, "w") as f:
                f.write(f"File: {fname}\n")
                f.write(f"Time: {time.ctime()}\n")
                f.write(f"Analysis:\n{result}\n")
            
            seen.add(fname)
            print(f"[{time.ctime()}] Done: {fname} → {report_path}")
        
        time.sleep(POLL_INTERVAL)

if __name__ == "__main__":
    main()