There are! Chroma has Context1, SID has SID-1, and you'd actually be surprised at how easy it is to post-train your own with pretty good pass@ recall@ ndcg@ etc.

There's also Hornet who have shared some interesting talks & blogs lately. I don't know that I'd exclusively use agents for retrieval the way Neon outlines here as well. I think distillation similar to what ZeroEntropy has done for bespoke retrieval & reranking with _some_ agent manipulation on top-k results works better (IME).

By post-train I presume you mean a finetune? Unless that's wrong (please correct me if so).

I haven't looked into model architecture people are working with for this stuff too deeply yet but I presume the core idea is fine-tuning a lightweight reasoning-enabled LLM specifically using search as a metric for training?

That or providing a concrete RL env for $your_search_corpus_etc_here

This looks great, will beta test over the coming weeks.

Thanks! Would love to hear your feedback!! You can email us at hello [at] drawers.computer

Thanks!

Very interesting! Have you considered posting this to HN (again - looks like it was when it first came out & 2 years ago)?

Yes! I'm very close to releasing 1.0 and I'm planning on doing it then.

This is some solid work and a great blog post to go hand-in-hand with. Wow.

Awesome to see the progress made by Alex, highly recommend watching the linked talk for people interested in any of Ruby, (AoT) compilers, and MLIR (which I haven't seen used too much outside of the ML space, personally)

Just-in-time compilation of Ruby allowing you to elide a lot of the overhead of dynamic language features + executing optimized machine code instead of running in the VM / bytecode interpreter.

For example, doing some loop unrolling for a piece of code with a known & small-enough fixed-size iteration. As another example, doing away with some dynamic dispatch / method lookup for a call site, or inlining methods - especially handy given Ruby's first class support for dynamic code generation, execution, redefinition (monkey patching).

From https://railsatscale.com/2023-12-04-ruby-3-3-s-yjit-faster-w...,

> In particular, YJIT is now able to better handle calls with splats as well as optional parameters, it’s able to compile exception handlers, and it can handle megamorphic call sites and instance variable accesses without falling back to the interpreter.

> We’ve also implemented specialized inlined primitives for certain core method calls such as Integer#!=, String#!=, Kernel#block_given?, Kernel#is_a?, Kernel#instance_of?, Module#===, and more. It also inlines trivial Ruby methods that only return a constant value such as #blank? and specialized #present? from Rails. These can now be used without needing to perform expensive method calls in most cases.

I recommend trying out Quiche Browser on iOS, or Orion from Kagi- both will support Kagi as a search option. Spotlight search still goes to Google, but I find that acceptable.

Ditto, this seems to have some parallels to the neurosymbolic ideas being explored by Lab V2 at ASU

Both are written in Crystal, interestingly enough