[BUG] Inconsistent return format for RubyLLM.embed with single vs multiple inputs

[finbarr]

Basic checks

• I searched existing issues - this hasn't been reported
• I can reproduce this consistently
• This is a RubyLLM bug, not my application code

What's broken?

The RubyLLM.embed method returns different data structures depending on the number of inputs, making it difficult to handle dynamic use cases.

Current behavior:

• RubyLLM.embed(["string1", "string2"]) returns an Embedding object with vectors as an array of arrays:
  [[vector1], [vector2]]
• RubyLLM.embed(["string1"]) returns an Embedding object with vectors as a single array: [vector1]

How to reproduce

RubyLLM.embed(["foo", "bar"]) -> [[vector], [vector]]
RubyLLM.embed(["foo"]) -> [vector]

Expected behavior

The return format should be consistent regardless of input count. Single inputs should return [[vector]] to match the multi-input format.

What actually happened

It returns [vector].

Environment

RubyLLM 1.3.1.

[crmne]

This isn't a bug - the return format is perfectly consistent with the input format.

What you're seeing:

• Input: ["string1", "string2"] → Output: [[vector1], [vector2]] (array of vectors)
• Input: ["string1"] → Output: [vector1] (single vector)

This is by design. The embedding endpoint returns one vector per input string. When you provide multiple strings, you get multiple vectors. When you provide one string, you get one vector.

If you need consistent array-of-arrays format, handle it in your application code:

def normalize_embeddings(result)
  result.vectors.first.is_a?(Array) ? result.vectors : [result.vectors]
end

Changing this would be a breaking change for everyone currently using single-input embeddings. The current behavior is intuitive and matches what most users expect.

Not a bug, closing.

[finbarr]

@crmne I agree if what you provide is a single string as an input, but when you provide an array of strings of length N, what I expect to get back is an array of embeddings of length N.

The way the code works right now, every single implementation of this will need to have this check for whether or not they are only passing a single string to embed or multiple. So if you are dynamically fetching N strings from your database for embedding, you need a special case for if there's only one.

RubyLLM.embed(string) -> [vector] 👍
RubyLLM.embed([string, string]) -> [[vector], [vector]] 👍
RubyLLM.embed([string]) -> [vector] 🤦‍♂️

[crmne]

@finbarr that makes much more sense! Happy to review a PR once I'm back from vacation!

[finbarr]

@crmne sounds good. I opened a PR #267