### Install Example Dependencies

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Navigate to the example directory and install its dependencies.

```bash
cd example
npm install
```

--------------------------------

### systemPrompt Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting the systemPrompt configuration option.

```typescript
await llm.loadModel(modelPath, {
  systemPrompt: 'You are a helpful coding assistant. Answer questions concisely.'
});
```

--------------------------------

### Error Handling Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of how to handle configuration errors during model loading using a try-catch block.

```typescript
try {
  await llm.loadModel(modelPath, {
    backend: 'gpu',
    temperature: 2.5, // Too high
  });
} catch (e) {
  console.error('Configuration error:', e.message);
  // Fall back to defaults
  await llm.loadModel(modelPath);
}
```

--------------------------------

### topP Usage (Diverse)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting topP for more diverse exploration.

```typescript
// More diverse exploration
await llm.loadModel(modelPath, { topP: 0.98 });
```

--------------------------------

### Changing Configuration Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Demonstrates creating new LLM instances with different configurations.

```typescript
const llm1 = createLLM();
await llm1.loadModel(modelPath, { backend: 'cpu', temperature: 0.7 });

// ... use llm1 ...

llm1.close();

// Create new instance with different config
const llm2 = createLLM();
await llm2.loadModel(modelPath, { backend: 'gpu', temperature: 0.0 });
```

--------------------------------

### temperature Usage (Deterministic)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting temperature for deterministic Q&A.

```typescript
// Deterministic Q&A
await llm.loadModel(modelPath, { temperature: 0.0 });
```

--------------------------------

### topK Usage (Diverse)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting topK for diverse sampling.

```typescript
// Diverse: consider top 100 tokens
await llm.loadModel(modelPath, { topK: 100 });
```

--------------------------------

### Bare React Native Setup - iOS

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Install pods for bare React Native iOS setups.

```bash
cd ios && pod install
```

--------------------------------

### backend Usage (GPU)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of using the GPU backend on iOS.

```typescript
// Use GPU on iOS (Metal always available)
await llm.loadModel(modelPath, { backend: 'gpu' });
```

--------------------------------

### temperature Usage (Creative)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting temperature for creative writing.

```typescript
// Creative writing
await llm.loadModel(modelPath, { temperature: 0.9 });
```

--------------------------------

### topP Usage (Focused)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting topP for focused answers.

```typescript
// Focused answers
await llm.loadModel(modelPath, { topP: 0.9 });
```

--------------------------------

### Create and Run Development Build for Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Prebuild the example project with cleaning and then run it on Android or iOS.

```bash
npx expo prebuild --clean
npx expo run:android  # Android
npx expo run:ios      # iOS (pre-linked with CLiteRTLM.xcframework)
```

--------------------------------

### topK Usage (Conservative)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting topK for conservative sampling.

```typescript
// Conservative: only top 20 tokens
await llm.loadModel(modelPath, { topK: 20 });
```

--------------------------------

### backend Usage (Fallback Pattern)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of a safe fallback pattern for backend selection.

```typescript
// Safe fallback pattern
const backend = checkBackendSupport('gpu') ? 'cpu' : 'gpu';
await llm.loadModel(modelPath, { backend });
```

--------------------------------

### Code Examples Overview

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/MANIFEST.md

The documentation contains a wide variety of code examples covering different aspects of the library, including basic usage, hook patterns, inference methods, memory tracking, error handling, platform detection, configuration presets, and type usage. There are over 40 complete and runnable code examples.

```typescript
Basic usage: 4 examples
Hook patterns: 6 examples
Inference methods: 8 examples
Memory tracking: 4 examples
Error handling: 6 examples
Platform detection: 4 examples
Configuration presets: 5 examples
Type usage: 3 examples

**Total:** 40+ complete, runnable code examples
```

--------------------------------

### maxTokens Usage (Short Responses)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting maxTokens for short responses.

```typescript
// Short responses
await llm.loadModel(modelPath, { maxTokens: 256 });
```

--------------------------------

### Bare React Native Setup - Android

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Clean the Android project for bare React Native setups.

```bash
cd android && ./gradlew clean
```

--------------------------------

### Benchmark Configuration

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration optimized for benchmarking and performance testing.

```typescript
const config: LLMConfig = {
  backend: 'gpu',       // Fast
  temperature: 1.0,     // Doesn't matter; deterministic doesn't apply
  maxTokens: 256,       // Short to measure speed
  validate: true,       // Ensure backend is working
};
```

--------------------------------

### iOS Recommended Configuration

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Recommended configuration for iOS devices.

```typescript
const config: LLMConfig = {
  backend: 'gpu',       // Metal always available
  temperature: 0.7,
  maxTokens: 1024,
  // Multimodal NOT supported on current XCFramework
};
```

--------------------------------

### Android Recommended Configuration

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Recommended configuration for Android devices, including multimodal support.

```typescript
const config: LLMConfig = {
  backend: 'cpu',       // Fallback (GPU only on Pixel devices)
  temperature: 0.7,
  maxTokens: 1024,
  multimodal: true,     // Android supports image/audio
};
```

--------------------------------

### Installation with npm

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Install the react-native-litert-lm and react-native-nitro-modules packages using npm.

```bash
npm install react-native-litert-lm react-native-nitro-modules
```

--------------------------------

### Example for getPeakMemory method

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Demonstrates how to get the peak resident set size (RSS) and convert it to megabytes for display.

```typescript
const peakBytes = tracker.getPeakMemory();
const peakMB = peakBytes / 1024 / 1024;
console.log(`Peak memory: ${peakMB.toFixed(1)} MB`);
```

--------------------------------

### Recommended Model Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example demonstrating the recommended `GEMMA_4_E2B_IT` model with the `useModel` hook, including a basic button interaction to trigger model generation.

```typescript
import { useModel, GEMMA_4_E2B_IT } from 'react-native-litert-lm';

function App() {
  const { model, isReady, generate } = useModel(GEMMA_4_E2B_IT);
  
  return isReady ? (
    <Button 
      title="Ask Me Anything" 
      onPress={() => generate('What is photosynthesis?')}
    />
  ) : (
    <Text>Loading model...</Text>
  );
}
```

--------------------------------

### Utility Functions

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Examples of using utility functions to check backend and multimodal support, and to get the recommended backend.

```typescript
import {
  checkBackendSupport,
  checkMultimodalSupport,
  getRecommendedBackend,
} from "react-native-litert-lm";

// Check if GPU is supported on this device
const gpuWarning = checkBackendSupport("gpu");

// Check NPU support
const npuWarning = checkBackendSupport("npu"); // string | undefined

// Check multimodal support
const mmError = checkMultimodalSupport(); // string | undefined

// Get recommended backend
const backend = getRecommendedBackend(); // 'cpu'
```

--------------------------------

### Platform-specific example (Android) for backend selection

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/utilities.md

An example demonstrating how to choose a backend on Android, considering GPU risks.

```typescript
import { Platform } from 'react-native';
import { checkBackendSupport } from 'react-native-litert-lm';

function ChooseBackend() {
  let backend = 'cpu';
  
  if (Platform.OS === 'android') {
    // GPU on Android is risky; only use if explicitly supported
    const warning = checkBackendSupport('gpu');
    if (!warning) {
      backend = 'gpu'; // Safe on this device
    }
  } else if (Platform.OS === 'ios') {
    // iOS Metal is always available
    backend = 'gpu';
  }
  
  return backend;
}
```

--------------------------------

### Fast Q&A Configuration Preset

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration preset for fast question answering, focusing on deterministic and concise responses.

```typescript
const config: LLMConfig = {
  backend: 'gpu',
  temperature: 0.0,    // Deterministic
  topK: 20,             // Focused vocabulary
  topP: 0.9,            // Nucleus sampling
  maxTokens: 512,       // Shorter responses
};
```

--------------------------------

### getRecommendedBackend() Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/utilities.md

Demonstrates how to get the recommended backend and load a model with it.

```typescript
import { getRecommendedBackend } from 'react-native-litert-lm';

const backend = getRecommendedBackend();
console.log(backend); // 'cpu'

const llm = createLLM();
await llm.loadModel(modelPath, { backend });
```

--------------------------------

### maxTokens Usage (Longer Responses)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Example of setting maxTokens for longer responses.

```typescript
// Longer responses (uses more memory)
await llm.loadModel(modelPath, { maxTokens: 2048 });
```

--------------------------------

### getView() Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Get the Float64Array view over the native buffer.

```typescript
tracker.getView()
```

--------------------------------

### getSummary() Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Get a summary of memory usage statistics across all snapshots.

```typescript
const summary = tracker.getSummary();
console.log(`Peak RSS: ${summary.peakResidentBytes} bytes`);
console.log(`Average RSS: ${summary.averageResidentBytes} bytes`);
console.log(`RSS Delta: ${summary.residentDeltaBytes} bytes`);
```

--------------------------------

### Usage Example for GEMMA_4_E4B_IT

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example showing the usage of `GEMMA_4_E4B_IT` with the `useModel` hook, specifying the 'gpu' backend for potentially faster inference.

```typescript
const { model, isReady } = useModel(GEMMA_4_E4B_IT, {
  backend: 'gpu',
});
```

--------------------------------

### LLMConfig Interface

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Core configuration interface for model loading and inference behavior.

```typescript
interface LLMConfig {
  systemPrompt?: string;
  backend?: Backend;
  maxTokens?: number;
  temperature?: number;
  topK?: number;
  topP?: number;
  validate?: boolean;
  multimodal?: boolean;
  tools?: ToolDefinition[];
  enableSpeculativeDecoding?: boolean;
}
```

--------------------------------

### Low-Memory Devices Configuration

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration for devices with limited RAM (e.g., 4 GB), suggesting smaller models.

```typescript
const config: LLMConfig = {
  backend: 'cpu',       // Conservative
  maxTokens: 256,       // Shorter responses
  temperature: 0.5,     // Consistent
  // Use Gemma 3n E2B (1.3 GB) or smaller models
};
```

--------------------------------

### Code Generation Configuration Preset

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration preset for code generation, prioritizing focused and deterministic output.

```typescript
const config: LLMConfig = {
  backend: 'gpu',
  temperature: 0.2,     // Focused (code should be deterministic)
  topK: 40,             // Balanced
  topP: 0.95,           // Default
  maxTokens: 1024,
  systemPrompt: 'You are an expert programmer. Write clean, well-commented code.'
};
```

--------------------------------

### Chat Assistant Configuration Preset

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration preset for a chat assistant, balancing natural variation with tool integration capabilities.

```typescript
const config: LLMConfig = {
  backend: 'cpu',       // Reliable
  temperature: 0.7,     // Natural variation
  topK: 40,             // Balanced
  topP: 0.95,           // Default
  maxTokens: 512,
  systemPrompt: 'You are a helpful, friendly assistant.',
  tools: [
    // Add domain-specific tools here
  ]
};
```

--------------------------------

### Usage Example for GEMMA_3N_E2B_IT_INT4

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example demonstrating the usage of the `GEMMA_3N_E2B_IT_INT4` model, which does not require the extended virtual addressing entitlement on iOS.

```typescript
const { model, isReady } = useModel(GEMMA_3N_E2B_IT_INT4);
```

--------------------------------

### MultimodalPart Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/types.md

Example of sending a multimodal message with text and an image.

```typescript
const response = await llm.sendMultimodalMessage([
  { type: 'text', text: 'Describe this image:' },
  { type: 'image', imageBuffer },
]);
```

--------------------------------

### ToolDefinition Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/types.md

Example of defining tools for the model.

```typescript
const tools: ToolDefinition[] = [
  {
    name: 'get_weather',
    description: 'Get the current weather for a location',
    parametersJson: JSON.stringify({
      type: 'object',
      properties: {
        location: { type: 'string', description: 'City and state' },
        unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
      },
      required: ['location']
    })
  }
];
```

--------------------------------

### Usage Example for GEMMA_4_E2B_IT

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example demonstrating how to use the `GEMMA_4_E2B_IT` model URL with the `useModel` hook in a React Native component. It includes basic loading state handling.

```typescript
import { useModel, GEMMA_4_E2B_IT } from 'react-native-litert-lm';

function App() {
  const { model, isReady } = useModel(GEMMA_4_E2B_IT, {
    backend: 'cpu',
  });
  
  // ...
}
```

--------------------------------

### Example for getSnapshots method

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Illustrates how to retrieve all recorded memory snapshots and iterate through them.

```typescript
const snapshots = tracker.getSnapshots();
snapshots.forEach((snap, i) => {
  console.log(`Snapshot ${i}: RSS=${snap.residentBytes} bytes`);
});
```

--------------------------------

### createNativeBuffer() Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Example of allocating native memory and using it with TypedArray views.

```typescript
import { createNativeBuffer } from 'react-native-litert-lm';

// Allocate 1 MB of native memory
const buffer = createNativeBuffer(1024 * 1024);
console.log(`Allocated ${buffer.byteLength} bytes`);

// Use with TypedArray views
const uint8View = new Uint8Array(buffer);
const float32View = new Float32Array(buffer);
```

--------------------------------

### GenerationStats Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/types.md

Example of retrieving and logging generation statistics.

```typescript
const stats = llm.getStats();
console.log(`Generated ${stats.completionTokens} tokens`);
console.log(`Speed: ${stats.tokensPerSecond.toFixed(1)} tokens/sec`);
console.log(`Time to first token: ${stats.timeToFirstToken.toFixed(0)} ms`);
```

--------------------------------

### Example Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/coverage/lcov-report/memoryTracker.ts.html

Example of how to use the MemoryTracker to track peak RSS.

```typescript
import { createMemoryTracker } from "./memoryTracker";

const tracker = createMemoryTracker(100);

// Record some memory usage snapshots...

console.log(`Peak RSS: ${tracker.getPeakMemory()} bytes`);
```

--------------------------------

### Custom Model from HuggingFace

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example of using a custom .litertlm model hosted on HuggingFace.

```typescript
// Any model from litert-community on HuggingFace
const url = 'https://huggingface.co/litert-community/model-name/resolve/main/model.litertlm';
const { model } = useModel(url);
```

--------------------------------

### Example for record method

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Shows how to record a memory snapshot using the current memory usage obtained from llm.getMemoryUsage().

```typescript
const usage = llm.getMemoryUsage();
const recorded = tracker.record({
  timestamp: Date.now(),
  nativeHeapBytes: usage.nativeHeapBytes,
  residentBytes: usage.residentBytes,
  availableMemoryBytes: usage.availableMemoryBytes,
});
```

--------------------------------

### checkBackendSupport() Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/utilities.md

Shows how to check backend support and conditionally load a model.

```typescript
import {
  checkBackendSupport,
  createLLM,
} from 'react-native-litert-lm';

const llm = createLLM();

// Check GPU support
const gpuWarning = checkBackendSupport('gpu');
if (gpuWarning) {
  console.warn(gpuWarning);
  // Fall back to CPU
  await llm.loadModel(path, { backend: 'cpu' });
} else {
  // GPU is safe to use
  await llm.loadModel(path, { backend: 'gpu' });
}

// Check NPU support
const npuWarning = checkBackendSupport('npu');
const backendToUse = npuWarning ? 'gpu' : 'npu';
console.log(`Using backend: ${backendToUse}`);
```

--------------------------------

### Memory Tracker Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/coverage/lcov-report/memoryTracker.ts.html

Example demonstrating how to create and use the memory tracker to record memory usage snapshots.

```typescript
import { createMemoryTracker } from 'react-native-litert-lm';

const tracker = createMemoryTracker(100);

// Record a real snapshot (typically called internally after inference)
tracker.record({
  timestamp: Date.now(),
  nativeHeapBytes: usage.nativeHeapBytes,
  residentBytes: usage.residentBytes,
```

--------------------------------

### Usage Example for Models Enum

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example showing how to import and use the `Models` enum for internal model identifiers. Note that these are not URLs and should not be used directly with `useModel`.

```typescript
import { Models } from 'react-native-litert-lm';

// These are internal model identifiers, not URLs
const modelId = Models.GEMMA_4_E2B;
console.log(modelId); // "gemma-4-E2B-it-litert-lm"
```

--------------------------------

### MemoryTrackerSummary Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Example of how to use the MemoryTrackerSummary interface to log memory statistics.

```typescript
const summary = tracker.getSummary();

console.log('=== Memory Report ===');
console.log(`Snapshots: ${summary.snapshotCount}`);
console.log(`Peak RSS: ${(summary.peakResidentBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`Average RSS: ${(summary.averageResidentBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`Current RSS: ${(summary.currentResidentBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`RSS Delta: ${(summary.residentDeltaBytes / 1024 / 1024).toFixed(1)} MB`);
```

--------------------------------

### Usage Example for createMemoryTracker

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Demonstrates how to create a memory tracker, record a snapshot, and retrieve summary statistics and snapshots.

```typescript
import { createMemoryTracker } from 'react-native-litert-lm';

const tracker = createMemoryTracker(100);

// Record a memory snapshot (typically done internally)
const recorded = tracker.record({
  timestamp: Date.now(),
  nativeHeapBytes: 50_000_000,
  residentBytes: 200_000_000,
  availableMemoryBytes: 4_000_000_000,
});

if (!recorded) {
  console.warn('Buffer full, snapshot not recorded');
}

// Get summary stats
const summary = tracker.getSummary();
console.log(`Peak RSS: ${summary.peakResidentBytes} bytes`);

// Access all snapshots
const snapshots = tracker.getSnapshots();
console.log(`Recorded ${snapshots.length} snapshots`);

// Get the underlying native buffer (for native code interop)
const nativeBuffer = tracker.getNativeBuffer();
console.log(`Buffer size: ${nativeBuffer.byteLength} bytes`);
```

--------------------------------

### loadModel(modelPath, config?) Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Loads a .litertlm model file from a local path or HTTPS URL with specified configuration.

```typescript
const llm = createLLM();

// Load from local path
await llm.loadModel('/path/to/model.litertlm', {
  backend: 'gpu',
  systemPrompt: 'You are a helpful assistant.',
  temperature: 0.8,
});

// Check if ready
if (llm.isReady()) {
  console.log('Model ready for inference');
}
```

--------------------------------

### Creative Writing Configuration Preset

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Configuration preset for creative writing, emphasizing diverse vocabulary and longer responses.

```typescript
const config: LLMConfig = {
  backend: 'cpu',       // Stable
  temperature: 0.9,     // Creative
  topK: 100,            // Diverse vocabulary
  topP: 0.95,           // Balanced
  maxTokens: 2048,      // Long responses
  systemPrompt: 'You are a creative writer. Generate interesting stories.'
};
```

--------------------------------

### Ultra-Lightweight Model Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example for the Gemma 3 1B model, suitable for very constrained devices and speed-critical applications.

```typescript
// Barely bigger than a text editor
const modelPath = '/path/to/gemma-3-1b.litertlm';
const { model } = useModel(modelPath, { backend: 'gpu' });
```

--------------------------------

### createLLM Factory

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/README.md

Example of using the `createLLM` factory for manual LLM management.

```typescript
import { createLLM } from 'react-native-litert-lm';

const llm = createLLM();
await llm.loadModel(modelPath, { backend: 'cpu' });
const response = await llm.sendMessage('Hello');
llm.close();
```

--------------------------------

### Custom Model from Local Path

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example of using a custom .litertlm model provided via a local file path.

```typescript
// Downloaded separately or bundled with app
const { model } = useModel('/path/to/custom-model.litertlm');
```

--------------------------------

### sendMessageWithAudio Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Sends a message along with an audio file path to an audio-capable model, for tasks like transcription.

```typescript
const transcription = await llm.sendMessageWithAudio(
  'Transcribe this audio.',
  '/path/to/audio.wav'
);
console.log(transcription);
```

--------------------------------

### Example for getLatestSnapshot method

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Shows how to retrieve the most recent memory snapshot and log its resident bytes.

```typescript
const latest = tracker.getLatestSnapshot();
if (latest) {
  console.log(`Current RSS: ${latest.residentBytes} bytes`);
}
```

--------------------------------

### Manual Model Downloading and Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Example of manually downloading a model using expo/fetch and then using it with useModel, passing the local file path.

```typescript
import { fetch } from "expo/fetch";
import { File, Paths } from "expo-file-system";
import { useModel } from "react-native-litert-lm";

const MODEL_URL = "https://example.com/private-model.litertlm";

// Download with custom headers using expo/fetch
const response = await fetch(MODEL_URL, {
  headers: { Authorization: `Bearer ${token}` },
});
const modelFile = new File(Paths.cache, "my-model.litertlm");
modelFile.write(await response.bytes());

// Pass the local path — no download occurs
const { model, isReady } = useModel(modelFile.uri, { backend: "cpu" });
```

--------------------------------

### sendMessageWithImage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Sends a message along with an image file path to a vision model for analysis.

```typescript
const response = await llm.sendMessageWithImage(
  'Describe what you see in this image.',
  '/path/to/photo.jpg'
);
console.log(response);
```

--------------------------------

### Tools Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Defines a list of function/tool definitions that the model can request to execute. Parameters use JSON Schema format.

```typescript
interface ToolDefinition {
  name: string;
  description: string;
  parametersJson: string; // JSON-stringified schema
}

const tools: ToolDefinition[] = [
  {
    name: 'get_weather',
    description: 'Get the current weather for a location',
    parametersJson: JSON.stringify({
      type: 'object',
      properties: {
        location: {
          type: 'string',
          description: 'City and state, e.g. San Francisco, CA'
        },
        unit: {
          type: 'string',
          enum: ['celsius', 'fahrenheit'],
          description: 'Temperature unit'
        }
      },
      required: ['location']
    })
  },
  {
    name: 'search',
    description: 'Search the internet',
    parametersJson: JSON.stringify({
      type: 'object',
      properties: {
        query: { type: 'string' }
      },
      required: ['query']
    })
  }
];

await llm.loadModel(modelPath, { tools });
```

--------------------------------

### Start a new conversation

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Clears the current conversation context and initiates a new session.

```typescript
// Start a new conversation
llm.resetConversation();
const response = await llm.sendMessage('Hello, new conversation!');
```

--------------------------------

### Model Loading Error: Unsupported file format

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/errors.md

Example of attempting to load a file with an unsupported format.

```typescript
// ❌ Wrong file type
await llm.loadModel('/path/to/image.jpg');
// Error: Unsupported file format (native error from loader)
```

--------------------------------

### Small Device Model Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example of using the GEMMA_3N_E2B_IT_INT4 model, optimized for devices with limited RAM and fast inference.

```typescript
const { model, isReady } = useModel(GEMMA_3N_E2B_IT_INT4, {
  backend: 'cpu', // Conservative on resource-limited devices
});
```

--------------------------------

### High Quality Model Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example of how to use the GEMMA_4_E4B_IT model for complex reasoning and long-form writing.

```typescript
const { model, isReady } = useModel(GEMMA_4_E4B_IT, {
  maxTokens: 2048,
  systemPrompt: 'You are a thoughtful assistant. Think step-by-step.',
});
```

--------------------------------

### Manual Model Download Control

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/models.md

Example of manually controlling model downloads with custom headers and saving to a local file.

```typescript
import { fetch } from 'expo/fetch';
import { File, Paths } from 'expo-file-system';

const MODEL_URL = 'https://example.com/private-model.litertlm';

// Download with custom headers
const response = await fetch(MODEL_URL, {
  headers: { Authorization: `Bearer ${token}` },
});

// Save locally
const modelFile = new File(Paths.cache, 'my-model.litertlm');
modelFile.write(await response.bytes());

// Pass local path (no download occurs)
const { model, isReady } = useModel(modelFile.uri, {
  backend: 'cpu'
});
```

--------------------------------

### Using with fetch and ArrayBuffer (zero-copy)

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/utilities.md

An example of analyzing an image from a URL using fetch and ArrayBuffer for efficient multimodal processing.

```typescript
import { checkMultimodalSupport } from 'react-native-litert-lm';

async function analyzeImageFromUrl(imageUrl: string) {
  const mmError = checkMultimodalSupport();
  if (mmError) {
    throw new Error(mmError);
  }

  // Fetch image into zero-copy ArrayBuffer (efficient multimodal path)
  const response = await fetch(imageUrl);
  const imageBuffer = await response.arrayBuffer();

  return llm.sendMultimodalMessage([
    { type: 'text', text: 'Analyze this image' },
    { type: 'image', imageBuffer }
  ]);
}
```

--------------------------------

### Message Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/types.md

Example of a conversation history.

```typescript
const messages: Message[] = [
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'What is 2+2?' },
  { role: 'model', content: '2+2 equals 4.' }
];
```

--------------------------------

### Create Development Build for Expo

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Prebuild the Expo project and then run it on Android or iOS.

```bash
npx expo prebuild
npx expo run:android  # Android
npx expo run:ios      # iOS
```

--------------------------------

### MemoryUsage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/types.md

Example of retrieving and logging memory usage information.

```typescript
const usage = llm.getMemoryUsage();
console.log(`Resident memory: ${(usage.residentBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`Available: ${(usage.availableMemoryBytes / 1024 / 1024).toFixed(1)} MB`);
if (usage.isLowMemory) {
  console.warn('Device is low on memory');
}
```

--------------------------------

### Choose Best Backend for Device

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/README.md

Provides an example of how to select the best available backend (GPU, NPU, CPU) for model loading based on device support.

```typescript
import { checkBackendSupport, createLLM } from 'react-native-litert-lm';

async function selectBackend() {
  const backends = ['gpu', 'npu', 'cpu'] as const;
  
  for (const backend of backends) {
    if (!checkBackendSupport(backend)) {
      return backend; // Safe to use
    }
  }
  
  return 'cpu'; // Fallback
}

const llm = createLLM();
const backend = await selectBackend();
await llm.loadModel(modelPath, { backend });
```

--------------------------------

### Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/utilities.md

Demonstrates how to create an LLM instance, load a model, and use multimodal capabilities, including checking for support and falling back to text-only if necessary.

```typescript
import {
  checkMultimodalSupport,
  createLLM,
} from 'react-native-litert-lm';

const llm = createLLM();
await llm.loadModel(modelPath, { backend: 'cpu' });

// Check before using multimodal APIs
const error = checkMultimodalSupport();

if (error) {
  console.warn(error);
  // Fallback to text-only
  const response = await llm.sendMessage('Describe the image.');
} else {
  // Safe to use multimodal APIs
  const response = await llm.sendMessageWithImage(
    'What is in this image?',
    '/path/to/image.jpg'
  );
}
```

--------------------------------

### downloadModel Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Downloads a model file from a given URL, saves it to the app's cache, and provides progress updates. It then loads the model using the downloaded path.

```typescript
const modelPath = await llm.downloadModel(
  'https://example.com/model.litertlm',
  'my-model.litertlm',
  (progress) => {
    console.log(`Downloaded: ${Math.round(progress * 100)}%`);
  }
);

await llm.loadModel(modelPath, { backend: 'cpu' });
```

--------------------------------

### File Structure

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/MANIFEST.md

The directory structure of the generated documentation files.

```bash
output/
├── README.md                          # Documentation index and quick reference
├── api-reference/
│   ├── core.md                        # Core LLM engine and inference methods
│   ├── hooks.md                       # React hooks (useModel)
│   ├── memory.md                      # Memory tracking and snapshots
│   └── utilities.md                   # Helper functions
├── types.md                           # Complete type definitions
├── configuration.md                   # Configuration options and presets
├── models.md                          # Model URLs and selection guide
├── errors.md                          # Error handling and recovery
└── MANIFEST.md                        # This file

```

--------------------------------

### Safe Backend Selection

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/errors.md

Illustrates how to safely select a backend (GPU, NPU, CPU) for loading a model, with fallbacks for unsupported backends.

```typescript
import { checkBackendSupport } from 'react-native-litert-lm';

async function loadWithBestBackend(modelPath: string) {
  const backends = ['gpu', 'npu', 'cpu'] as const;
  
  for (const backend of backends) {
    const warning = checkBackendSupport(backend);
    
    try {
      if (warning) {
        console.log(`Skipping ${backend}: ${warning}`);
        continue;
      }
      
      await llm.loadModel(modelPath, { backend });
      console.log(`Loaded with ${backend} backend`);
      return backend;
    } catch (e) {
      console.error(`Failed to load with ${backend}:`, e);
      // Try next backend
    }
  }
  
  throw new Error('Failed to load with any backend');
}
```

--------------------------------

### reset() Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/memory.md

Clear all snapshots and reset the tracker.

```typescript
// Reset before a new inference phase
tracker.reset();
```

--------------------------------

### Usage Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Creates a new LiteRT-LM inference engine instance with memory tracking enabled, loads a model, generates text, accesses memory stats, and cleans up.

```typescript
import { createLLM } from 'react-native-litert-lm';

// Create engine with memory tracking
const llm = createLLM({
  enableMemoryTracking: true,
  maxMemorySnapshots: 100,
});

// Load a model from local path
await llm.loadModel('/path/to/gemma-4-E2B-it.litertlm', {
  backend: 'cpu',
  temperature: 0.7,
});

// Generate text
const response = await llm.sendMessage('Hello, how are you?');
console.log(response);

// Access memory stats
if (llm.memoryTracker) {
  const summary = llm.memoryTracker.getSummary();
  console.log(`Peak memory: ${summary.peakResidentBytes} bytes`);
}

// Clean up
llm.close();
```

--------------------------------

### Build the Library

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Compile TypeScript to the lib/ directory.

```bash
npm run build
```

--------------------------------

### iOS Multimodal Fallback

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/errors.md

Example of checking the platform before attempting to use multimodal features on iOS.

```typescript
if (Platform.OS === 'ios') {
  // Use text-only
  await llm.sendMessage('Describe the image...');
} else {
  // Use multimodal
  await llm.sendMessageWithImage('What is this?', imagePath);
}
```

--------------------------------

### sendMessage(message) Example

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Sends a text message to the LLM and receives the complete response.

```typescript
const response = await llm.sendMessage('What is the capital of France?');
console.log(response); // "The capital of France is Paris."
```

--------------------------------

### Get memory usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/api-reference/core.md

Fetches detailed memory usage information from the native runtime.

```typescript
const usage = llm.getMemoryUsage();

console.log(`Native heap: ${(usage.nativeHeapBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`RSS: ${(usage.residentBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`Available: ${(usage.availableMemoryBytes / 1024 / 1024).toFixed(1)} MB`);
console.log(`Low memory: ${usage.isLowMemory}`);
```

--------------------------------

### Manual Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Manually create an LLM instance, load a model, and interact with it.

```typescript
import { createLLM } from "react-native-litert-lm";

const llm = createLLM();

// Load a model from URL (auto-downloads) or local path
await llm.loadModel("https://example.com/model.litertlm", {
  backend: "gpu",
  systemPrompt: "You are a helpful assistant.",
});

// Generate a response
const response = await llm.sendMessage("What is the capital of France?");
console.log(response);

// Clean up
llm.close();
```

--------------------------------

### useModel React Hook

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/README.md

Example of using the `useModel` hook for React components.

```typescript
import { useModel, GEMMA_4_E2B_IT } from 'react-native-litert-lm';

function App() {
  const { model, isReady, generate } = useModel(GEMMA_4_E2B_IT);
  // ...
}
```

--------------------------------

### Multimodal Usage

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/_autodocs/configuration.md

Specifies whether the model supports image/audio processing. Can be explicitly set or auto-detected from the filename.

```typescript
// Explicitly mark as multimodal
await llm.loadModel(modelPath, { multimodal: true });

// Auto-detect (if filename contains "multimodal" or "vision")
await llm.loadModel(modelPath);
```

--------------------------------

### Android Kotlin Layer Testing

Source: https://github.com/hung-yueh/react-native-litert-lm/blob/main/README.md

Command to run Robolectric tests for the Android Kotlin layer.

```bash
cd example/android
./gradlew :react-native-litert-lm:testDebugUnitTest
```