RubyLLM: A Ruby framework for all major AI providers

Congrats Carmine on being featured!

I am using RubyLLM for quite some time and I am in love with the API design. If someone wants to see how this looks in a real project including custom tools, you can have a look at the SerpTrail project on GitHub.

The Chat model still is just:

  class Chat < ApplicationRecord
    acts_as_chat model: :llm_model
  end

I am quite excited for RubyLLM 2.0 and beyond.

As a non-rubyist who nevertheless understands Ruby, and has a keen interest in cross-provider LLM frameworks / abstractions, chat.rb is the most beautiful implementation of the agentic tool-calling loop I've ever seen.

People point at pi-agent (Typescript) as a good one, but I find the Ruby version far more elegant, far more concise, and generally easier to read.

I think it could be simplified further at the cost of making the API a bit uglier — and perhaps an educational fork should be — but it's still really good.

I found Ruby LLM to be surprisingly good - in terms of usability it's close to Vercel's AI framework.

It tries to strike a balance between working out of the box and being flexible... which has its challenges, still nice overall.

One big real-life pain I experienced is that caches don't always work, e.g. for xAI, since it only supports completions API and thought signatures are returned wrong.

I have an open source gem called Raix that builds on top of RubyLLM's abstractions and is quite popular. https://github.com/OlympiaAI/raix

We use and love RubyLLM! A wonderful and easy to use framework.

Agreed with another commenter on the frustration with the responses API not being naively supported; that seems like a huge miss. There is a connector from another dev, but it's buggy and not as high quality as the main gem.

Really looking forward to future development and especially 2.0!

Edit: Just saw that responses API is now native? I will definitely check that out.

We've used RubyLLM for ~6+ months and it's been mostly OK. The API/Dev UX is good but we have seen little success with engaging the maintainer on PRs, and have noticed a lot of vibe coded PRs being merged (including some rewrites of PRs we submitted) - I suspect an minimal API compatible gem with similar heuristics would do well.

RubyLLM is very easy to use. Made extensive use of it for a project last year. Drawbacks are it was difficult to instrument for true trace observability and it has a pattern where retries will delete the underlying models so the history you see is clean but not necessarily great for seeing exactly what the sequence of API calls was.

I'm building something that is only pointed at Claude, and I don't anticipate moving away from the Anthropic ecosystem. Does RubyLLM offer me an advantage over directly using Anthropic's Ruby SDK?

To put it differently, is this more like choosing between Fog and aws-sdk-s3, or choosing between Active Storage and aws-sdk-s3?

We use RubyLLM in production too, the most elegant library in this space I've seen so far.

I also liked how they run the issue tracker. If you select "Feature Request", it makes you explain how you explored workarounds, why you believe it belongs in RubyLLM etc to prevent scope creep.

I spent a lot of time with RubyLLM a few months ago. Very nicely designed and implemented. I have my own LLM clients written in various Lisp languages and I thought about appropriating some of the design of RubyLLM. Imitation is flattery.

thank you for bringing ruby into AI community and your open-source work. Great language must be explored and get more attention :)

RubyLLM is awesome! I use it on side projects. So interesting how questions and comments from last year SF Ruby conf, https://youtu.be/y535u1EWqAg?si=rbyv52T035apKwQk are already features shipped in the ecosystem.

We use this in production for a few apps. Great project.

Laravel has a similar library https://laravel.com/docs/13.x/ai-sdk

I built a similar Ruby based agent development kit that has a different focus and feature set:

https://github.com/tweibley/legate

Does 2.0 expose explicit capability negotiation, or does it infer capabilities from the selected model?

RubyLLM is great! Been a very happy user for awhile now :)

It is quite nice, but not as nice as you'd want. You still have to set platform specifics when running completions when you want to tune things like temperature, effort, max tokens, etc.

I have created an open source chatgpt clone with rubyllm, check it out here: https://www.railschat.org/

Using RubyLLM in production for https://usetix.io It drives our event chat agent that is enhanced with toolcalls etc. Super happy with it.

Thank you

In case you're using PHP or Node.js, we've made a similar toolkit free and open source on github: https://github.com/Qbix/AI/tree/main/classes/AI

Meanwhile Ruby is dropping like crazy on TIOBE. TIOBE has tons of issues, I get it, but the underlying message is that Ruby is struggling immensely, for many reasons (and has been for a while). The language is still great as-is, but if there is no solution to lack of new developers, ruby will just follow perl's path to extinction. AI is not going to save ruby here; quite the opposite. More AI will mean less quality overall. The AI generated documentation is useless gibberish. It's not even an improvement over lacking documentation in the first place, which many ruby projects also have as an issue.

I haven't tried it but it looks promising.

"What is the best language in the world (say ruby)" ;)

The hard part with these unified wrappers is always the leaky bits: prompt caching, tool-use schemas, structured output, and reasoning tokens differ enough across providers that a common interface tends to quietly drop whatever's provider-specific. How does RubyLLM handle that, escape hatches down to the raw provider, or normalize to a shared subset? Prompt caching is the one I'd care about most, since it's modeled pretty differently between OpenAI and Anthropic and it's where most of my cost savings come from.

[flagged]

[dead]

[flagged]

[dead]

[dead]

[dead]

[flagged]

I have been a fan of Ruby for many years, but in this fast paced era the Ruby ecosystem always struggled with the dependency versioning. Gems I relied on were never available or compatible with the rest of the ecosystem.

Why would anyone still build in dynamically typed languages in 2026? Why relinquish the crystal clear signals that static typing is able to provide to the LLM?