onnx-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 809c3c981b4ec890ed7169969b64f556dffb4a44a0c44e6126ec3f2ba28f2f07
+  data.tar.gz: 91233f1ee8c921c5cf4a2352f98e0f322aac91b27b0db01c55212c0ae8f9a750
+SHA512:
+  metadata.gz: b1ad99c83090be72d099836e84992d1a108b876272fd152fab1de4b43569930b1bdf985ca79e5fc8b27e3a4a8da65b33d823a560b9dd6cd4d7df384c942adb0a
+  data.tar.gz: f9a9c2b4278f7c20dffd890ece27cecf24004127944826b65bcef7a31a383c5f3799cecb01ca29e2ffd984f92698cb1ecf50e3681df2147b104c24839b9021df

data/CLAUDE.md

@@ -0,0 +1,334 @@
+# onnx-ruby
+
+## Project Overview
+
+Ruby bindings for [ONNX Runtime](https://github.com/microsoft/onnxruntime), Microsoft's high-performance inference engine for ONNX models. This gem wraps the ONNX Runtime C++ API using **Rice** (same approach as zvec-ruby) to give Ruby developers fast local model inference.
+
+This unlocks: local embeddings, text classification, named entity recognition, sentiment analysis, reranking, and any other ML model exported to ONNX format — all without Python or API calls.
+
+## Author
+
+- Name: Johannes Dwi Cahyo
+- GitHub: johannesdwicahyo
+- Repo: git@github.com:johannesdwicahyo/onnx-ruby.git
+
+## Technical Approach
+
+### Binding Strategy: Rice 4.x (C++ → Ruby)
+
+ONNX Runtime has a C++ API (`onnxruntime_cxx_api.h`). We wrap it using Rice, exactly like zvec-ruby.
+
+**Important lessons from zvec-ruby to apply here:**
+- Use `require "mkmf-rice"` (not `require "rice/extconf"`) for Rice 4.x
+- Use `define_module_under()` and `define_enum_under()` for Rice 4.x
+- Wrap all raw `VALUE` returns in `Rice::Object()` when pushing to Arrays
+- Use `std::make_shared` when C++ API expects shared_ptr
+- Extract results to Ruby Hashes/Arrays in C++ before returning (avoid dangling pointers)
+- Ship precompiled gems — ONNX Runtime is a large C++ library, nobody wants to build it
+- On macOS use `-force_load` for static archives with static initializers
+- Default to safe options (like mmap=true in zvec-ruby)
+
+### ONNX Runtime Linking
+
+ONNX Runtime provides **prebuilt shared libraries** (`.so`/`.dylib`) for all platforms. Unlike zvec (which required building from source), we can download the official release and link against it. This is much simpler.
+
+Download from: https://github.com/microsoft/onnxruntime/releases
+
+The `extconf.rb` should:
+1. Check for `ONNX_RUNTIME_DIR` env var
+2. Check for system-installed onnxruntime via pkg-config
+3. Auto-download the correct prebuilt release if neither found
+
+### Precompiled Gems
+
+For precompiled gems, statically link or bundle the ONNX Runtime `.dylib`/`.so` inside the gem. The gem will be ~50-80MB but users get zero-install experience.
+
+## Core API Design
+
+```ruby
+require "onnx_ruby"
+
+# --- Session (model loading) ---
+
+# Load a model
+session = OnnxRuby::Session.new("model.onnx")
+
+# With options
+session = OnnxRuby::Session.new("model.onnx",
+  providers: [:cpu],              # :cpu, :cuda, :coreml, :tensorrt
+  inter_threads: 4,
+  intra_threads: 2,
+  log_level: :warning
+)
+
+# Model info
+session.inputs   # => [{ name: "input_ids", type: :int64, shape: [-1, 512] }]
+session.outputs  # => [{ name: "embeddings", type: :float, shape: [-1, 384] }]
+
+# --- Inference ---
+
+# Run inference
+result = session.run(
+  { "input_ids" => [[101, 2023, 2003, 1037, 3231, 102]] },
+)
+result["embeddings"]  # => [[0.0123, -0.0456, ...]]
+
+# With output names
+result = session.run(inputs, output_names: ["embeddings"])
+
+# --- Tensor ---
+
+# Create tensors explicitly
+tensor = OnnxRuby::Tensor.new([1, 2, 3, 4], shape: [2, 2], dtype: :int64)
+tensor.to_a     # => [[1, 2], [3, 4]]
+tensor.shape    # => [2, 2]
+tensor.dtype    # => :int64
+
+# From flat array
+tensor = OnnxRuby::Tensor.float([0.1, 0.2, 0.3], shape: [1, 3])
+
+# --- High-Level Helpers ---
+
+# Embedding model (wraps session with pre/post processing)
+embedder = OnnxRuby::Embedder.new("all-MiniLM-L6-v2.onnx",
+  tokenizer: "sentence-transformers/all-MiniLM-L6-v2"  # requires tokenizer-ruby
+)
+embeddings = embedder.embed("Hello world")         # => [0.0123, ...]
+embeddings = embedder.embed_batch(["Hello", "World"])  # => [[...], [...]]
+
+# Classifier
+classifier = OnnxRuby::Classifier.new("intent_model.onnx",
+  tokenizer: "bert-base-uncased",
+  labels: ["greeting", "farewell", "question", "command"]
+)
+classifier.predict("Hello there!")  # => { label: "greeting", score: 0.95 }
+```
+
+## Features to Implement
+
+### Phase 1 — Core (MVP)
+- [ ] `Session.new(path, options)` — load ONNX model
+- [ ] `session.run(inputs)` — run inference, return outputs
+- [ ] `session.inputs` / `session.outputs` — model metadata
+- [ ] `Tensor` class — create and manipulate tensors
+- [ ] Support dtypes: float32, float64, int32, int64, string, bool
+- [ ] Support shapes: 1D, 2D, 3D, 4D tensors
+- [ ] CPU execution provider
+
+### Phase 2 — Providers & Options
+- [ ] CoreML provider (macOS acceleration)
+- [ ] CUDA provider (NVIDIA GPU)
+- [ ] Session options: threading, memory, optimization level
+- [ ] Model optimization: `OnnxRuby.optimize("model.onnx", "optimized.onnx")`
+- [ ] Dynamic shapes (batching)
+
+### Phase 3 — High-Level API
+- [ ] `Embedder` — embedding model wrapper (tokenize → infer → normalize)
+- [ ] `Classifier` — text classification wrapper
+- [ ] `Reranker` — cross-encoder reranking wrapper
+- [ ] Integration with tokenizer-ruby for text preprocessing
+- [ ] Model hub: `OnnxRuby::Hub.download("sentence-transformers/all-MiniLM-L6-v2")`
+
+### Phase 4 — Rails Integration
+- [ ] `OnnxRuby.configure { |c| c.models_path = "app/models/onnx" }`
+- [ ] Lazy model loading (load on first inference)
+- [ ] Connection pool for thread-safe concurrent inference
+- [ ] ActiveModel integration for embedding generation
+
+## Project Structure
+
+```
+onnx-ruby/
+├── CLAUDE.md
+├── Gemfile
+├── Rakefile
+├── LICENSE                  # MIT
+├── README.md
+├── onnx-ruby.gemspec
+├── lib/
+│   ├── onnx_ruby.rb
+│   └── onnx_ruby/
+│       ├── version.rb
+│       ├── session.rb
+│       ├── tensor.rb
+│       ├── embedder.rb
+│       ├── classifier.rb
+│       └── reranker.rb
+├── ext/
+│   └── onnx_ruby/
+│       ├── extconf.rb
+│       └── onnx_ruby_ext.cpp
+├── test/
+│   ├── test_helper.rb
+│   ├── test_session.rb
+│   ├── test_tensor.rb
+│   ├── test_inference.rb
+│   └── models/           # small test ONNX models
+│       └── .gitkeep
+├── script/
+│   ├── download_onnxruntime.sh
+│   └── package_native_gem.rb
+└── examples/
+    ├── embedding.rb
+    ├── classification.rb
+    └── with_zvec.rb       # full RAG example with zvec-ruby
+```
+
+## Dependencies
+
+### Runtime
+- `rice` (>= 4.0) — C++ to Ruby bindings
+- ONNX Runtime shared library (bundled in precompiled gems)
+
+### Optional
+- `tokenizer-ruby` — for Embedder/Classifier text preprocessing
+
+### Development
+- `rake-compiler` for building native extensions
+- `rake-compiler-dock` for cross-compilation
+- `minitest` for testing
+- `rake` for tasks
+
+## Key C++ Binding Details
+
+### ONNX Runtime C++ API Structure
+
+```cpp
+#include <onnxruntime_cxx_api.h>
+
+// Key classes to wrap:
+Ort::Env           // Runtime environment (singleton)
+Ort::Session       // Model session
+Ort::SessionOptions
+Ort::Value         // Tensor (input/output)
+Ort::MemoryInfo    // Memory allocation info
+Ort::TypeInfo      // Model input/output type info
+Ort::TensorTypeAndShapeInfo
+```
+
+### extconf.rb approach
+
+```ruby
+require "mkmf-rice"
+
+# Try to find ONNX Runtime
+ort_dir = ENV["ONNX_RUNTIME_DIR"]
+
+unless ort_dir
+  # Auto-download prebuilt ONNX Runtime for the current platform
+  # from https://github.com/microsoft/onnxruntime/releases
+  ort_dir = download_onnxruntime()  # helper function
+end
+
+dir_config("onnxruntime", "#{ort_dir}/include", "#{ort_dir}/lib")
+$INCFLAGS << " -I#{ort_dir}/include"
+$LDFLAGS << " -L#{ort_dir}/lib"
+$libs << " -lonnxruntime"
+
+have_header("onnxruntime_cxx_api.h") or
+  abort "Cannot find ONNX Runtime headers"
+
+create_makefile("onnx_ruby/onnx_ruby_ext")
+```
+
+### C++ Extension Skeleton
+
+```cpp
+#include <rice/rice.hpp>
+#include <onnxruntime_cxx_api.h>
+
+using namespace Rice;
+
+// Global ORT environment (initialized once)
+static Ort::Env& get_env() {
+  static Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "onnx_ruby");
+  return env;
+}
+
+// Wrap Ort::Session
+// Wrap Ort::Value (Tensor)
+// Handle type conversion: Ruby Array ↔ ORT Tensor
+// Map ORT errors to Ruby exceptions
+
+void Init_onnx_ruby_ext() {
+  Module rb_mOnnxRuby = define_module("OnnxRuby");
+  Module rb_mExt = define_module_under(rb_mOnnxRuby, "Ext");
+
+  // Define Session, Tensor, etc.
+}
+```
+
+### Critical: Tensor ↔ Ruby Array Conversion
+
+The most complex part. Need to handle:
+- Ruby Array of floats → ORT float32 tensor (most common for embeddings)
+- Ruby Array of integers → ORT int64 tensor (for token IDs)
+- Nested Ruby Arrays → multi-dimensional tensors
+- ORT output tensors → Ruby Arrays (with proper Float wrapping via `Rice::Object(rb_float_new())`)
+
+```cpp
+// Ruby Array → ORT Tensor
+Ort::Value array_to_tensor(Rice::Array arr, const std::vector<int64_t>& shape) {
+  // Flatten nested arrays
+  // Detect dtype from Ruby values
+  // Create ORT tensor with proper memory allocation
+}
+
+// ORT Tensor → Ruby Array
+Rice::Object tensor_to_array(const Ort::Value& tensor) {
+  // Read shape
+  // Read dtype
+  // Copy data to Ruby Array (with Rice::Object wrapping!)
+}
+```
+
+## Testing Strategy
+
+- Test with small ONNX models (generate test models with Python: `torch.onnx.export`)
+- Test model loading and metadata inspection
+- Test inference with known inputs/outputs
+- Test all supported dtypes
+- Test batch inference
+- Test error handling (invalid model, wrong input shape, etc.)
+- Benchmark against Python's onnxruntime for correctness
+
+### Create test models (Python script to include):
+```python
+# script/create_test_models.py
+import torch
+import torch.nn as nn
+
+# Simple linear model for testing
+class SimpleModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(4, 3)
+    def forward(self, x):
+        return self.linear(x)
+
+model = SimpleModel()
+dummy = torch.randn(1, 4)
+torch.onnx.export(model, dummy, "test/models/simple.onnx",
+                  input_names=["input"], output_names=["output"])
+```
+
+## Publishing
+
+- RubyGems.org: `gem push onnx-ruby-*.gem`
+- gem.coop: `GEM_HOST_API_KEY=hjncPswY8PbGDfLPw4RMj928 gem push onnx-ruby-*.gem --host https://beta.gem.coop/@johannesdwicahyo`
+
+## Notes from zvec-ruby Experience
+
+- **Rice 4.x API**: `define_module_under()`, `define_enum_under()`, not the 3.x syntax
+- **Rice::Object wrapping**: ALWAYS wrap `rb_float_new()`, `Qtrue`, `Qnil` in `Rice::Object()` when pushing to Arrays
+- **shared_ptr**: Use `make_shared` when C++ expects `shared_ptr`, accept by `const T&` in bindings
+- **Extract results in C++**: Don't try to push C++ objects directly into Ruby arrays. Extract to Hashes/Arrays first.
+- **Precompiled gems**: Essential. Use `script/package_native_gem.rb` for macOS, `rake-compiler-dock` for Linux.
+- **ONNX Runtime ships prebuilt binaries**: Much easier than zvec. Download from GitHub releases, link against `.dylib`/`.so`.
+- **Static initializers**: May need `-force_load` if ONNX Runtime uses static registration patterns.
+- **mmap/memory**: ONNX Runtime manages its own memory via allocators. Let it handle memory, don't fight it.
+
+## Existing Ruby ONNX Solutions
+
+- `onnxruntime` gem by ankane — exists but is FFI-based and limited. We can provide better performance and API with Rice + additional high-level features (Embedder, Classifier, Reranker).
+- Differentiate by: better API, precompiled gems, high-level wrappers, tokenizer-ruby integration

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johannes Dwi Cahyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,301 @@
+# onnx-ruby
+
+High-performance [ONNX Runtime](https://onnxruntime.ai/) bindings for Ruby. Run ONNX models locally for embeddings, classification, reranking, and any other ML inference — without Python or API calls.
+
+Built with [Rice](https://github.com/ruby-rice/rice) (C++ to Ruby bindings) wrapping the ONNX Runtime C++ API directly.
+
+## Features
+
+- **Fast inference** — native C++ bindings, not FFI
+- **Auto-download** — ONNX Runtime is downloaded automatically during gem install
+- **Multiple providers** — CPU, CoreML (macOS), CUDA, TensorRT
+- **High-level wrappers** — `Embedder`, `Classifier`, `Reranker` for common ML tasks
+- **Thread-safe** — `SessionPool` for concurrent inference in multi-threaded apps
+- **Lazy loading** — `LazySession` loads models on first use
+- **Rails-ready** — `OnnxRuby::Model` mixin, global configuration, connection pooling
+- **Model hub** — download models from HuggingFace with local caching
+
+## Installation
+
+```ruby
+# Gemfile
+gem "onnx-ruby"
+```
+
+```sh
+bundle install
+```
+
+ONNX Runtime (v1.24.3) is automatically downloaded during native extension compilation.
+
+To use a custom ONNX Runtime installation:
+
+```sh
+ONNX_RUNTIME_DIR=/path/to/onnxruntime bundle install
+```
+
+## Quick Start
+
+### Basic Inference
+
+```ruby
+require "onnx_ruby"
+
+# Load a model
+session = OnnxRuby::Session.new("model.onnx")
+
+# Inspect model
+session.inputs   # => [{ name: "input", type: :float32, shape: [-1, 4] }]
+session.outputs  # => [{ name: "output", type: :float32, shape: [-1, 3] }]
+
+# Run inference
+result = session.run({ "input" => [[1.0, 2.0, 3.0, 4.0]] })
+result["output"]  # => [[0.123, -0.456, 0.789]]
+
+# Batch inference
+result = session.run({ "input" => [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] })
+result["output"]  # => [[...], [...]]
+```
+
+### Embeddings
+
+```ruby
+require "onnx_ruby"
+require "tokenizers"
+
+# With a HuggingFace tokenizer
+tokenizer = Tokenizers::Tokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+embedder = OnnxRuby::Embedder.new("all-MiniLM-L6-v2.onnx",
+  tokenizer: tokenizer,
+  normalize: true
+)
+
+# Single embedding
+embedding = embedder.embed("Hello world")  # => [0.0123, -0.0456, ...] (384 dims)
+
+# Batch embedding
+embeddings = embedder.embed_batch(["Hello", "World"])  # => [[...], [...]]
+
+# Without tokenizer (pre-tokenized input)
+embedder = OnnxRuby::Embedder.new("model.onnx")
+embedding = embedder.embed({
+  "input_ids" => [101, 2023, 2003, 102],
+  "attention_mask" => [1, 1, 1, 1]
+})
+```
+
+### Classification
+
+```ruby
+classifier = OnnxRuby::Classifier.new("classifier.onnx",
+  labels: ["greeting", "farewell", "question", "command"]
+)
+
+# With feature vectors
+result = classifier.predict([0.1, 0.2, 0.3, 0.4])
+# => { label: "greeting", score: 0.95, scores: [0.95, 0.02, 0.02, 0.01] }
+
+# Batch
+results = classifier.predict_batch([features1, features2])
+
+# With tokenizer for text input
+classifier = OnnxRuby::Classifier.new("bert-classifier.onnx",
+  tokenizer: "bert-base-uncased",
+  labels: ["positive", "negative"]
+)
+classifier.predict("This is great!")
+```
+
+### Reranking
+
+```ruby
+reranker = OnnxRuby::Reranker.new("reranker.onnx", tokenizer: tokenizer)
+
+# Rerank documents by relevance to a query
+results = reranker.rerank("What is Ruby?", [
+  "Ruby is a programming language",
+  "The weather is nice today",
+  "Rails is built with Ruby"
+])
+# => [
+#   { document: "Ruby is a programming language", score: 0.98, index: 0 },
+#   { document: "Rails is built with Ruby", score: 0.85, index: 2 },
+#   { document: "The weather is nice today", score: 0.01, index: 1 }
+# ]
+
+# Raw scoring with pre-tokenized inputs
+scores = reranker.score(
+  input_ids: [[101, 2023, 102], [101, 7592, 102]],
+  attention_mask: [[1, 1, 1], [1, 1, 1]]
+)
+```
+
+## Session Options
+
+```ruby
+session = OnnxRuby::Session.new("model.onnx",
+  providers: [:coreml, :cpu],       # execution providers (fallback order)
+  optimization_level: :all,          # :none, :basic, :extended, :all
+  intra_threads: 4,                  # threads within an operator
+  inter_threads: 2,                  # threads between operators
+  execution_mode: :parallel,         # :sequential or :parallel
+  memory_pattern: true,              # pre-allocate memory
+  cpu_mem_arena: true,               # use memory arena
+  log_level: :warning                # :verbose, :info, :warning, :error, :fatal
+)
+```
+
+### Execution Providers
+
+```ruby
+# List available providers
+OnnxRuby.available_providers
+# => ["CoreMLExecutionProvider", "CPUExecutionProvider"]
+
+# CoreML (macOS — uses Apple Neural Engine)
+session = OnnxRuby::Session.new("model.onnx", providers: [:coreml])
+
+# CUDA (NVIDIA GPU — requires CUDA build of ONNX Runtime)
+session = OnnxRuby::Session.new("model.onnx", providers: [:cuda, :cpu])
+```
+
+## Model Optimization
+
+```ruby
+# Optimize and save a model
+OnnxRuby.optimize("model.onnx", "model_optimized.onnx", level: :all)
+
+# Use the optimized model
+session = OnnxRuby::Session.new("model_optimized.onnx")
+```
+
+## Tensors
+
+```ruby
+# Create typed tensors
+tensor = OnnxRuby::Tensor.new([1, 2, 3, 4], shape: [2, 2], dtype: :int64)
+tensor.to_a     # => [[1, 2], [3, 4]]
+tensor.shape    # => [2, 2]
+tensor.dtype    # => :int64
+
+# Convenience constructors
+OnnxRuby::Tensor.float([0.1, 0.2, 0.3], shape: [1, 3])
+OnnxRuby::Tensor.int64([1, 2, 3], shape: [3])
+OnnxRuby::Tensor.double([1.0, 2.0], shape: [2])
+OnnxRuby::Tensor.int32([1, 2], shape: [2])
+
+# Use tensors as session input
+tensor = OnnxRuby::Tensor.float([1.0, 2.0, 3.0, 4.0], shape: [1, 4])
+session.run({ "input" => tensor })
+```
+
+Supported dtypes: `float32`, `float64`, `int32`, `int64`, `bool`, `string`
+
+## Thread Safety
+
+### Session Pool
+
+```ruby
+# Create a pool of sessions for concurrent inference
+pool = OnnxRuby::SessionPool.new("model.onnx", size: 5, timeout: 10)
+
+# Auto checkout/checkin
+result = pool.run({ "input" => data })
+
+# Or manual block form
+pool.with_session do |session|
+  session.run({ "input" => data })
+end
+
+# Pool stats
+pool.size       # => number of created sessions
+pool.available  # => number of idle sessions
+```
+
+### Lazy Loading
+
+```ruby
+# Model loads on first use, thread-safe
+lazy = OnnxRuby::LazySession.new("model.onnx")
+lazy.loaded?  # => false
+lazy.run(inputs)
+lazy.loaded?  # => true
+```
+
+## Rails Integration
+
+### Configuration
+
+```ruby
+# config/initializers/onnx_ruby.rb
+OnnxRuby.configure do |c|
+  c.models_path = "app/models/onnx"
+  c.default_providers = [:coreml, :cpu]
+  c.default_log_level = :warning
+  c.pool_size = 5
+  c.pool_timeout = 5
+end
+```
+
+### ActiveModel Mixin
+
+```ruby
+class Document < ApplicationRecord
+  include OnnxRuby::Model
+
+  onnx_model "embeddings.onnx"
+  onnx_input ->(doc) {
+    # tokenize doc.content and return input hash
+    { "input_ids" => ids, "attention_mask" => mask }
+  }
+  onnx_output "embeddings"
+
+  def generate_embedding
+    self.embedding = onnx_predict.first
+  end
+end
+
+doc = Document.find(1)
+doc.generate_embedding  # runs ONNX inference
+```
+
+The model is loaded lazily on first inference and shared across all instances.
+
+## Model Hub
+
+```ruby
+# Download from HuggingFace
+path = OnnxRuby::Hub.download("sentence-transformers/all-MiniLM-L6-v2",
+  filename: "model.onnx"
+)
+session = OnnxRuby::Session.new(path)
+
+# Cache management
+OnnxRuby::Hub.cached_models  # => ["/home/user/.cache/onnx_ruby/models/..."]
+OnnxRuby::Hub.clear_cache
+```
+
+## Requirements
+
+- Ruby >= 3.1
+- C++ compiler with C++17 support
+- ONNX Runtime (auto-downloaded during install)
+
+### Optional
+
+- [tokenizers](https://github.com/ankane/tokenizers-ruby) gem — for text tokenization in Embedder/Classifier/Reranker
+
+## Development
+
+```sh
+git clone https://github.com/johannesdwicahyo/onnx-ruby.git
+cd onnx-ruby
+bundle install
+bundle exec rake compile
+python3 script/create_test_models.py  # requires torch, onnx, onnxscript
+bundle exec rake test
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE).

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rake/extensiontask"
+require "rake/testtask"
+
+Rake::ExtensionTask.new("onnx_ruby_ext") do |ext|
+  ext.lib_dir = "lib/onnx_ruby"
+  ext.ext_dir = "ext/onnx_ruby"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: %i[compile test]