# `Vllm.Multimodal.MultiModalRegistry`
[🔗](https://github.com/nshkrdotcom/vllm/blob/v0.3.0/lib/snakebridge_generated/vllm/multimodal/multi_modal_registry.ex#L7)

A registry that dispatches data processing according to the model.

# `t`

```elixir
@opaque t()
```

# `_create_processing_ctx`

```elixir
@spec _create_processing_ctx(SnakeBridge.Ref.t(), term(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Python method `MultiModalRegistry._create_processing_ctx`.

## Parameters

- `model_config` (term())
- `observability_config` (term() default: None)
- `tokenizer` (term() default: None)

## Returns

- `term()`

# `_create_processing_info`

```elixir
@spec _create_processing_info(SnakeBridge.Ref.t(), term(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Python method `MultiModalRegistry._create_processing_info`.

## Parameters

- `model_config` (term())
- `observability_config` (term() default: None)
- `tokenizer` (term() keyword-only default: None)

## Returns

- `term()`

# `_extract_mm_options`

```elixir
@spec _extract_mm_options(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Extract multimodal dummy options from model config.

Returns None if no configurable options are found, otherwise returns
a mapping of modality names to their dummy options.

## Parameters

- `model_config` (term())

## Returns

- `term()`

# `_get_model_cls`

```elixir
@spec _get_model_cls(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Python method `MultiModalRegistry._get_model_cls`.

## Parameters

- `model_config` (term())

## Returns

- `term()`

# `create_processor`

```elixir
@spec create_processor(SnakeBridge.Ref.t(), term(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Create a multi-modal processor for a specific model and tokenizer.

## Parameters

- `model_config` (term())
- `observability_config` (term() default: None)
- `tokenizer` (term() keyword-only default: None)
- `cache` (term() keyword-only default: None)

## Returns

- `term()`

# `get_decoder_dummy_data`

```elixir
@spec get_decoder_dummy_data(
  SnakeBridge.Ref.t(),
  term(),
  integer(),
  [term()],
  keyword()
) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Create dummy data for profiling the memory usage of a model.

The model is identified by `model_config`.

## Parameters

- `model_config` (term())
- `seq_len` (integer())
- `mm_counts` (term() default: None)
- `cache` (term() keyword-only default: None)
- `observability_config` (term() keyword-only default: None)

## Returns

- `term()`

# `get_encdec_max_encoder_len`

```elixir
@spec get_encdec_max_encoder_len(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, integer()} | {:error, Snakepit.Error.t()}
```

Get the maximum length of the encoder input for encoder-decoder models.

## Parameters

- `model_config` (term())

## Returns

- `integer()`

# `get_encoder_dummy_data`

```elixir
@spec get_encoder_dummy_data(
  SnakeBridge.Ref.t(),
  term(),
  integer(),
  [term()],
  keyword()
) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Create dummy data for profiling the memory usage of a model.

The model is identified by `model_config`.

## Parameters

- `model_config` (term())
- `seq_len` (integer())
- `mm_counts` (term() default: None)
- `cache` (term() keyword-only default: None)
- `observability_config` (term() keyword-only default: None)

## Returns

- `term()`

# `get_max_tokens_per_item_by_modality`

```elixir
@spec get_max_tokens_per_item_by_modality(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Get the maximum number of tokens per data item from each modality based

on underlying model configuration.

## Parameters

- `model_config` (term())
- `cache` (term() keyword-only default: None)
- `profiler_limits` (term() keyword-only default: None)
- `observability_config` (term() keyword-only default: None)

## Returns

- `term()`

# `get_mm_limits_per_prompt`

```elixir
@spec get_mm_limits_per_prompt(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Get the maximum number of multi-modal input instances for each modality

that are allowed per prompt for a model class.

## Parameters

- `model_config` (term())
- `cache` (term() keyword-only default: None)
- `observability_config` (term() keyword-only default: None)

## Returns

- `term()`

# `new`

```elixir
@spec new(
  [term()],
  keyword()
) :: {:ok, SnakeBridge.Ref.t()} | {:error, Snakepit.Error.t()}
```

Initialize self.  See help(type(self)) for accurate signature.

## Parameters

- `args` (term())
- `kwargs` (term())

# `register_processor`

```elixir
@spec register_processor(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Register a multi-modal processor to a model class. The processor

is constructed lazily, hence a factory method should be passed.

When the model receives multi-modal data, the provided function is
invoked to transform the data into a dictionary of model inputs.

## Parameters

- `processor` (term())
- `info` (term() keyword-only, required)
- `dummy_inputs` (term() keyword-only, required)

## Returns

- `term()`

# `supports_multimodal_inputs`

```elixir
@spec supports_multimodal_inputs(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, boolean()} | {:error, Snakepit.Error.t()}
```

Checks if the model supports multimodal inputs.

Returns True if the model is multimodal with any non-zero supported
modalities, otherwise returns False, effectively running in
text-only mode.

## Parameters

- `model_config` (term())

## Returns

- `boolean()`

---

*Consult [api-reference.md](api-reference.md) for complete listing*