Instructions to use OmnipotentFool/Aurvion with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use OmnipotentFool/Aurvion with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf OmnipotentFool/Aurvion:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf OmnipotentFool/Aurvion:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf OmnipotentFool/Aurvion:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf OmnipotentFool/Aurvion:Q4_K_M

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf OmnipotentFool/Aurvion:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf OmnipotentFool/Aurvion:Q4_K_M

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf OmnipotentFool/Aurvion:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf OmnipotentFool/Aurvion:Q4_K_M

Use Docker

docker model run hf.co/OmnipotentFool/Aurvion:Q4_K_M

LM Studio
Jan

vLLM

How to use OmnipotentFool/Aurvion with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "OmnipotentFool/Aurvion"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OmnipotentFool/Aurvion",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/OmnipotentFool/Aurvion:Q4_K_M

Ollama
How to use OmnipotentFool/Aurvion with Ollama:
```
ollama run hf.co/OmnipotentFool/Aurvion:Q4_K_M
```
Unsloth Desktop
Docker Model Runner
How to use OmnipotentFool/Aurvion with Docker Model Runner:
```
docker model run hf.co/OmnipotentFool/Aurvion:Q4_K_M
```

Lemonade

How to use OmnipotentFool/Aurvion with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull OmnipotentFool/Aurvion:Q4_K_M

Run and chat with the model

lemonade run user.Aurvion-Q4_K_M

List all available models

lemonade list

Atomic Chat

Aurvion / llama.cpp /tools /ui /src /lib /utils /process-uploaded-files.ts

OmnipotentFool

Add files using upload-large-folder tool

6b9d0d8 verified 4 months ago

Raw History Blame Contribute Delete

5.2 kB

import { isSvgMimeType, svgBase64UrlToPngDataURL } from './svg-to-png';
import { isWebpMimeType, webpBase64UrlToPngDataURL } from './webp-to-png';
import { heicFileToJpegDataURL, isHeicMimeType } from './heic-to-jpeg';
import { FileTypeCategory } from '$lib/enums';
import { SETTINGS_KEYS } from '$lib/constants';
import { modelsStore } from '$lib/stores/models.svelte';
import { settingsStore } from '$lib/stores/settings.svelte';
import { toast } from 'svelte-sonner';
import { getFileTypeCategory } from '$lib/utils';
import { convertPDFToText } from './pdf-processing';

/**
 * Read a file as a data URL (base64 encoded)
 * @param file - The file to read
 * @returns Promise resolving to the data URL string
 */
function readFileAsDataURL(file: File): Promise<string> {
	return new Promise((resolve, reject) => {
		const reader = new FileReader();
		reader.onload = () => resolve(reader.result as string);
		reader.onerror = () => reject(reader.error);
		reader.readAsDataURL(file);
	});
}

/**
 * Read a file as UTF-8 text
 * @param file - The file to read
 * @returns Promise resolving to the text content
 */
function readFileAsUTF8(file: File): Promise<string> {
	return new Promise((resolve, reject) => {
		const reader = new FileReader();
		reader.onload = () => resolve(reader.result as string);
		reader.onerror = () => reject(reader.error);
		reader.readAsText(file);
	});
}

/**
 * Process uploaded files into ChatUploadedFile format with previews and content
 *
 * This function processes various file types and generates appropriate previews:
 * - Images: Base64 data URLs with format normalization (SVG/WebP → PNG)
 * - Text files: UTF-8 content extraction
 * - PDFs: Metadata only (processed later in conversion pipeline)
 * - Audio: Base64 data URLs for preview
 *
 * @param files - Array of File objects to process
 * @returns Promise resolving to array of ChatUploadedFile objects
 */
export async function processFilesToChatUploaded(
	files: File[],
	activeModelId?: string
): Promise<ChatUploadedFile[]> {
	const results: ChatUploadedFile[] = [];

	for (const file of files) {
		const id = Date.now().toString() + Math.random().toString(36).substr(2, 9);
		const base: ChatUploadedFile = {
			id,
			name: file.name,
			size: file.size,
			type: file.type,
			file
		};

		try {
			if (getFileTypeCategory(file.type) === FileTypeCategory.IMAGE) {
				let preview = await readFileAsDataURL(file);

				// Normalize SVG and WebP to PNG, and HEIC to compressed JPEG, in previews
				if (isSvgMimeType(file.type)) {
					try {
						preview = await svgBase64UrlToPngDataURL(preview);
					} catch (err) {
						console.error('Failed to convert SVG to PNG:', err);
					}
				} else if (isWebpMimeType(file.type)) {
					try {
						preview = await webpBase64UrlToPngDataURL(preview);
					} catch (err) {
						console.error('Failed to convert WebP to PNG:', err);
					}
				} else if (isHeicMimeType(file.type)) {
					try {
						preview = await heicFileToJpegDataURL(file);
					} catch (err) {
						console.error('Failed to convert HEIC to PNG:', err);
						continue;
					}
				}

				results.push({ ...base, preview });
			} else if (getFileTypeCategory(file.type) === FileTypeCategory.PDF) {
				// Extract text content from PDF for preview
				try {
					const textContent = await convertPDFToText(file);
					results.push({ ...base, textContent });
				} catch (err) {
					console.warn('Failed to extract text from PDF, adding without content:', err);
					results.push(base);
				}

				// Show suggestion toast if vision model is available but PDF as image is disabled
				const hasVisionSupport = activeModelId
					? modelsStore.modelSupportsVision(activeModelId)
					: false;
				const currentConfig = settingsStore.config;
				if (hasVisionSupport && !currentConfig.pdfAsImage) {
					toast.info(`You can enable parsing PDF as images with vision models.`, {
						duration: 8000,
						action: {
							label: 'Enable PDF as Images',
							onClick: () => {
								settingsStore.updateConfig(SETTINGS_KEYS.PDF_AS_IMAGE, true);
								toast.success('PDF parsing as images enabled!', {
									duration: 3000
								});
							}
						}
					});
				}
			} else if (getFileTypeCategory(file.type) === FileTypeCategory.AUDIO) {
				// Generate preview URL for audio files
				const preview = await readFileAsDataURL(file);
				results.push({ ...base, preview });
			} else if (getFileTypeCategory(file.type) === FileTypeCategory.VIDEO) {
				// Generate preview URL for video files
				const preview = await readFileAsDataURL(file);
				results.push({ ...base, preview });
			} else {
				// Fallback: treat unknown files as text
				try {
					const textContent = await readFileAsUTF8(file);
					results.push({ ...base, textContent });
				} catch (err) {
					console.warn('Failed to read file as text, adding without content:', err);
					results.push(base);
				}
			}
		} catch (error) {
			console.error('Error processing file', file.name, error);
			results.push(base);
		}
	}

	return results;
}

	import { isSvgMimeType, svgBase64UrlToPngDataURL } from './svg-to-png';
	import { isWebpMimeType, webpBase64UrlToPngDataURL } from './webp-to-png';
	import { heicFileToJpegDataURL, isHeicMimeType } from './heic-to-jpeg';
	import { FileTypeCategory } from '$lib/enums';
	import { SETTINGS_KEYS } from '$lib/constants';
	import { modelsStore } from '$lib/stores/models.svelte';
	import { settingsStore } from '$lib/stores/settings.svelte';
	import { toast } from 'svelte-sonner';
	import { getFileTypeCategory } from '$lib/utils';
	import { convertPDFToText } from './pdf-processing';

	/**
	* Read a file as a data URL (base64 encoded)
	* @param file - The file to read
	* @returns Promise resolving to the data URL string
	*/
	function readFileAsDataURL(file: File): Promise<string> {
	return new Promise((resolve, reject) => {
	const reader = new FileReader();
	reader.onload = () => resolve(reader.result as string);
	reader.onerror = () => reject(reader.error);
	reader.readAsDataURL(file);
	});
	}

	/**
	* Read a file as UTF-8 text
	* @param file - The file to read
	* @returns Promise resolving to the text content
	*/
	function readFileAsUTF8(file: File): Promise<string> {
	return new Promise((resolve, reject) => {
	const reader = new FileReader();
	reader.onload = () => resolve(reader.result as string);
	reader.onerror = () => reject(reader.error);
	reader.readAsText(file);
	});
	}

	/**
	* Process uploaded files into ChatUploadedFile format with previews and content
	*
	* This function processes various file types and generates appropriate previews:
	* - Images: Base64 data URLs with format normalization (SVG/WebP → PNG)
	* - Text files: UTF-8 content extraction
	* - PDFs: Metadata only (processed later in conversion pipeline)
	* - Audio: Base64 data URLs for preview
	*
	* @param files - Array of File objects to process
	* @returns Promise resolving to array of ChatUploadedFile objects
	*/
	export async function processFilesToChatUploaded(
	files: File[],
	activeModelId?: string
	): Promise<ChatUploadedFile[]> {
	const results: ChatUploadedFile[] = [];

	for (const file of files) {
	const id = Date.now().toString() + Math.random().toString(36).substr(2, 9);
	const base: ChatUploadedFile = {
	id,
	name: file.name,
	size: file.size,
	type: file.type,
	file
	};

	try {
	if (getFileTypeCategory(file.type) === FileTypeCategory.IMAGE) {
	let preview = await readFileAsDataURL(file);

	// Normalize SVG and WebP to PNG, and HEIC to compressed JPEG, in previews
	if (isSvgMimeType(file.type)) {
	try {
	preview = await svgBase64UrlToPngDataURL(preview);
	} catch (err) {
	console.error('Failed to convert SVG to PNG:', err);
	}
	} else if (isWebpMimeType(file.type)) {
	try {
	preview = await webpBase64UrlToPngDataURL(preview);
	} catch (err) {
	console.error('Failed to convert WebP to PNG:', err);
	}
	} else if (isHeicMimeType(file.type)) {
	try {
	preview = await heicFileToJpegDataURL(file);
	} catch (err) {
	console.error('Failed to convert HEIC to PNG:', err);
	continue;
	}
	}

	results.push({ ...base, preview });
	} else if (getFileTypeCategory(file.type) === FileTypeCategory.PDF) {
	// Extract text content from PDF for preview
	try {
	const textContent = await convertPDFToText(file);
	results.push({ ...base, textContent });
	} catch (err) {
	console.warn('Failed to extract text from PDF, adding without content:', err);
	results.push(base);
	}

	// Show suggestion toast if vision model is available but PDF as image is disabled
	const hasVisionSupport = activeModelId
	? modelsStore.modelSupportsVision(activeModelId)
	: false;
	const currentConfig = settingsStore.config;
	if (hasVisionSupport && !currentConfig.pdfAsImage) {
	toast.info(`You can enable parsing PDF as images with vision models.`, {
	duration: 8000,
	action: {
	label: 'Enable PDF as Images',
	onClick: () => {
	settingsStore.updateConfig(SETTINGS_KEYS.PDF_AS_IMAGE, true);
	toast.success('PDF parsing as images enabled!', {
	duration: 3000
	});
	}
	}
	});
	}
	} else if (getFileTypeCategory(file.type) === FileTypeCategory.AUDIO) {
	// Generate preview URL for audio files
	const preview = await readFileAsDataURL(file);
	results.push({ ...base, preview });
	} else if (getFileTypeCategory(file.type) === FileTypeCategory.VIDEO) {
	// Generate preview URL for video files
	const preview = await readFileAsDataURL(file);
	results.push({ ...base, preview });
	} else {
	// Fallback: treat unknown files as text
	try {
	const textContent = await readFileAsUTF8(file);
	results.push({ ...base, textContent });
	} catch (err) {
	console.warn('Failed to read file as text, adding without content:', err);
	results.push(base);
	}
	}
	} catch (error) {
	console.error('Error processing file', file.name, error);
	results.push(base);
	}
	}

	return results;
	}