RAG

final session = await RunAnywhere.rag.open(
  embeddingModel: const ModelRef('all-minilm-l6-v2'),
  llmModel: const ModelRef('smollm2-360m-q8_0'),
);

await session.ingest(const RagDocument('The sky is blue because of Rayleigh scattering.'));

final answer = await session.query('Why is the sky blue?');
print(answer.answer);
for (final source in answer.sources) {
  print('${source.score}: ${source.text}');
}

await session.close();

Future<RagSession> open({
  required ModelRef embeddingModel,
  ModelRef? llmModel,
  RagConfig? config,
});

final session = await RunAnywhere.rag.open(
  embeddingModel: const ModelRef('all-minilm-l6-v2'),
  llmModel: const ModelRef('smollm2-360m-q8_0'),
  config: RagConfig(
    topK: 5,
    chunkSize: 512,
    chunkOverlap: 64,
    similarityThreshold: 0.3,
    persistPath: '/path/to/index',
  ),
);

final bool generates;                                        // true when an LLM was supplied
Future<void> ingest(RagDocument document);
Future<void> ingestAll(List<RagDocument> documents);
Future<List<Match>> search(String query, {int? topK});
Future<RagResult> query(String question, {LlmOptions? options});
Stream<RagEvent> queryStream(String question, {LlmOptions? options});
Future<RagStats> stats();
Future<void> clear();
Future<void> close();

// In-memory text
await session.ingest(const RagDocument('Some text to index.'));

// With metadata echoed back on every match
await session.ingest(RagDocument(
  chapterText,
  metadata: const {'chapter': '3', 'source': 'handbook'},
));

// From disk
await session.ingest(await RagDocument.file('/path/to/notes.txt'));

// Several at once
await session.ingestAll([doc1, doc2, doc3]);

final matches = await session.search('Rayleigh scattering', topK: 3);

for (final match in matches) {
  print('${match.score.toStringAsFixed(3)}  ${match.text}');
  print(match.metadata);
}

final result = await session.query(
  'Why is the sky blue?',
  options: LlmOptions(maxOutputTokens: 200, temperature: 0.3),
);

print(result.answer);
print('${result.metrics.outputTokens} tokens');

await for (final event in session.queryStream('Why is the sky blue?')) {
  switch (event) {
    case RagRetrieved(:final matches):
      setState(() => _sources = matches);
    case RagToken(:final text, :final kind):
      if (kind == TokenKind.text) setState(() => _answer += text);
    case RagCompleted(:final result):
      setState(() => _answer = result.answer);
  }
}

final stats = await session.stats();
print('${stats.documentCount} documents');
print('${stats.chunkCount} chunks');
print('${stats.indexSizeBytes} bytes');

await RunAnywhere.models.register(
  ModelRegistration.multiFile(
    id: 'all-minilm-l6-v2',
    name: 'All MiniLM L6 v2 (Embedding)',
    files: [
      ModelFileDescriptor(
        filename: 'model.onnx',
        url: 'https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx',
        isRequired: true,
      ),
      ModelFileDescriptor(
        filename: 'vocab.txt',
        url: 'https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/vocab.txt',
        isRequired: true,
      ),
    ],
    framework: InferenceFramework.INFERENCE_FRAMEWORK_ONNX,
    category: ModelCategory.MODEL_CATEGORY_EMBEDDING,
    memoryRequirementBytes: 90000000,
  ),
);

class RagViewModel extends ChangeNotifier {
  RagSession? _session;
  String answer = '';
  List<Match> sources = const [];

  Future<void> load(String documentText) async {
    await _session?.close();
    final session = await RunAnywhere.rag.open(
      embeddingModel: const ModelRef('all-minilm-l6-v2'),
      llmModel: const ModelRef('smollm2-360m-q8_0'),
    );
    _session = session;
    await session.ingest(RagDocument(documentText));
    notifyListeners();
  }

  Future<void> ask(String question) async {
    final session = _session;
    if (session == null) return;

    answer = '';
    sources = const [];
    notifyListeners();

    await for (final event in session.queryStream(question)) {
      switch (event) {
        case RagRetrieved(:final matches):
          sources = matches;
        case RagToken(:final text, :final kind):
          if (kind == TokenKind.text) answer += text;
        case RagCompleted(:final result):
          answer = result.answer;
          sources = result.sources;
      }
      notifyListeners();
    }
  }

  @override
  void dispose() {
    _session?.close();
    super.dispose();
  }
}