Repository: run-llama/llama_index
Pull request: LlamaIndex Multi_Modal_Llms Integration: Huggingface
# Description

This project integrates Hugging Face's multimodal language models into the LlamaIndex framework, enabling advanced multimodal capabilities for various AI applications.

Fixes #16056

## Features

- Seamless integration of Hugging Face multimodal models with LlamaIndex
- Support for multiple state-of-the-art vision-language models and their **finetunes**:
  - [Qwen2 Vision](https://huggingface.co/collections/Qwen/qwen2-vl-66cee7455501d7126940800d)
  - [Florence2](https://huggingface.co/collections/microsoft/florence-6669f44df0d87d9c3bfb76de)
  - [Phi-3.5 Vision](https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3)
  - [PaLI-Gemma](https://huggingface.co/collections/google/paligemma-release-6643a9ffbf57de2ae0448dda)
- Easy-to-use interface for multimodal tasks like image captioning and visual question answering
- Configurable model parameters for fine-tuned performance

## New Package?

Did I fill in the `tool.llamahub` section in the `pyproject.toml` and provide a detailed README.md for my new integration or package?

- [x] Yes
- [ ] No

## Version Bump?

Did I bump the version in the `pyproject.toml` file of the package I am updating? (Except for the `llama-index-core` package)

- [ ] Yes
- [x] No

## Type of Change

Please delete options that are not relevant.

- [x] New feature (non-breaking change which adds functionality)

## How Has This Been Tested?

Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration

- [x] Added new unit/integration tests
- [x] Added new notebook (that tests end-to-end)
- [ ] I stared at the code and made sure it makes sense

## Suggested Checklist:

- [x] I have performed a self-review of my own code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] I have added Google Colab support for the newly added notebooks.
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I ran `make format; make lint` to appease the lint gods


Problem statement:
[Question]: How to use VLMs from HuggingFace for Multimodal rag?
### Question Validation

- [X] I have searched both the documentation and discord for an answer.

### Question

I want to use "Qwen/Qwen2-VL-2B-Instruct" on my multimodal rag app. I tried OllamaMultiModal from llama_index.multi_modal_llms.ollama and it works fine. I want to use huggingface models as well

Hints from issue discussion:
<!-- Answer -->
To use HuggingFace models for multimodal retrieval-augmented generation (RAG) in your application, you can leverage the existing support for HuggingFace models in the `llama_index.multi_modal_llms` module. Here’s a general guide on how to integrate a HuggingFace model like "Qwen/Qwen2-VL-2B-Instruct":

1. **Install Dependencies**:
   Ensure you have the `huggingface-hub` package installed:
   ```bash
   pip install huggingface-hub
   ```

2. **Define Your HuggingFace Model Class**:
   You can create a class similar to `OllamaMultiModal` but for HuggingFace models. Here’s a simplified example:

   ```python
   from llama_index.multi_modal_llms.base import MultiModalLLM, MultiModalLLMMetadata
   from llama_index.llms.huggingface import HuggingFaceLLM
   from pydantic import Field
   from typing import Any, Dict, Sequence

   class HuggingFaceMultiModal(MultiModalLLM):
       model_name: str = Field(description="The HuggingFace model to use.")
       temperature: float = Field(
           default=0.75,
           description="The temperature to use for sampling.",
           ge=0.0,
           le=1.0,
       )
       context_window: int = Field(
           default=DEFAULT_CONTEXT_WINDOW,
           description="The maximum number of context tokens for the model.",
           gt=0,
       )
       additional_kwargs: Dict[str, Any] = Field(
           default_factory=dict,
           description="Additional model parameters for the HuggingFace model.",
       )

       def __init__(self, **kwargs: Any) -> None:
           super().__init__(**kwargs)
           self.model = HuggingFaceLLM(model_name=self.model_name)

       @classmethod
       def class_name(cls) -> str:
           return "HuggingFace_multi_modal_llm"

       @property
       def metadata(self) -> MultiModalLLMMetadata:
           return MultiModalLLMMetadata(
               context_window=self.context_window,
               num_output=DEFAULT_NUM_OUTPUTS,
               model_name=self.model_name,
               is_chat_model=True,
           )

       def complete(self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any) -> CompletionResponse:
           # Implement the completion logic using HuggingFace model
           pass

       def stream_complete(self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any) -> CompletionResponseGen:
           # Implement the streaming completion logic using HuggingFace model
           pass

       def chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
           # Implement the chat logic using HuggingFace model
           pass

       def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponseGen:
           # Implement the streaming chat logic using HuggingFace model
           pass

       async def acomplete(self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any) -> CompletionResponse:
           # Implement the async completion logic using HuggingFace model
           pass

       async def astream_complete(self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any) -> CompletionResponseAsyncGen:
           # Implement the async streaming completion logic using HuggingFace model
           pass

       async def achat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
           # Implement the async chat logic using HuggingFace model
           pass

       async def astream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponseAsyncGen:
           # Implement the async streaming chat logic using HuggingFace model
           pass
   ```

3. **Use the HuggingFace Model**:
   Instantiate and use your `HuggingFaceMultiModal` class in your application:

   ```python
   model = HuggingFaceMultiModal(
       model_name="Qwen/Qwen2-VL-2B-Instruct",
       temperature=0.7,
       context_window=2048,
       additional_kwargs={"some_param": "value"}
   )

   # Example usage
   response = model.complete(prompt="Your prompt here", image_documents=[])
   print(response.text)
   ```

This setup allows you to use HuggingFace models in a similar manner to how you used `OllamaMultiModal`. Make sure to implement the specific logic for completion, streaming completion, chat, and streaming chat methods as per your requirements.

For more details, you can refer to the existing implementations of HuggingFace models in the `llama_index.multi_modal_llms` module <sup>[[1]](https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/llms/huggingface.py)</sup>.


<!-- Dosu Comment Footer -->
*To continue talking to [Dosu](https://dosu.dev), mention @dosu.*

```python
from llama_index.core.indices import MultiModalVectorStoreIndex
from llama_index.core import SimpleDirectoryReader
from llama_index.vector_stores.qdrant import QdrantVectorStore
from llama_index.core import SimpleDirectoryReader, StorageContext
import qdrant_client
client = qdrant_client.QdrantClient(path="qdrant_mm_db")

text_store = QdrantVectorStore(
    client=client, collection_name="text_collection"
)
image_store = QdrantVectorStore(
    client=client, collection_name="image_collection"
)
storage_context = StorageContext.from_defaults(
    vector_store=text_store, image_store=image_store
)

documents = SimpleDirectoryReader("imgs").load_data(show_progress=True)
index = MultiModalVectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    image_embed_model="local:openai/clip-vit-large-patch14"
)
```

Error log:
```bash
No sentence-transformers model found with name openai/clip-vit-large-patch14. Creating a new one with MEAN pooling.
{
	"name": "AttributeError",
	"message": "'CLIPConfig' object has no attribute 'hidden_size'",
	"stack": "---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[4], line 1
----> 1 index = MultiModalVectorStoreIndex.from_documents(
      2     documents,
      3     storage_context=storage_context,
      4     image_embed_model=\"local:openai/clip-vit-large-patch14\"
      5 )

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\llama_index\\core\\indices\\base.py:145, in BaseIndex.from_documents(cls, documents, storage_context, show_progress, callback_manager, transformations, service_context, **kwargs)
    136     docstore.set_document_hash(doc.get_doc_id(), doc.hash)
    138 nodes = run_transformations(
    139     documents,  # type: ignore
    140     transformations,
    141     show_progress=show_progress,
    142     **kwargs,
    143 )
--> 145 return cls(
    146     nodes=nodes,
    147     storage_context=storage_context,
    148     callback_manager=callback_manager,
    149     show_progress=show_progress,
    150     transformations=transformations,
    151     service_context=service_context,
    152     **kwargs,
    153 )

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\llama_index\\core\\indices\\multi_modal\\base.py:80, in MultiModalVectorStoreIndex.__init__(self, nodes, index_struct, embed_model, storage_context, use_async, store_nodes_override, show_progress, image_vector_store, image_embed_model, is_image_to_text, is_image_vector_store_empty, is_text_vector_store_empty, service_context, **kwargs)
     56 def __init__(
     57     self,
     58     nodes: Optional[Sequence[BaseNode]] = None,
   (...)
     77     **kwargs: Any,
     78 ) -> None:
     79     \"\"\"Initialize params.\"\"\"
---> 80     image_embed_model = resolve_embed_model(
     81         image_embed_model, callback_manager=kwargs.get(\"callback_manager\", None)
     82     )
     83     assert isinstance(image_embed_model, MultiModalEmbedding)
     84     self._image_embed_model = image_embed_model

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\llama_index\\core\\embeddings\\utils.py:110, in resolve_embed_model(embed_model, callback_manager)
    107     cache_folder = os.path.join(get_cache_dir(), \"models\")
    108     os.makedirs(cache_folder, exist_ok=True)
--> 110     embed_model = HuggingFaceEmbedding(
    111         model_name=model_name, cache_folder=cache_folder
    112     )
    113 except ImportError:
    114     raise ImportError(
    115         \"`llama-index-embeddings-huggingface` package not found, \"
    116         \"please run `pip install llama-index-embeddings-huggingface`\"
    117     )

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\llama_index\\embeddings\\huggingface\\base.py:150, in HuggingFaceEmbedding.__init__(self, model_name, tokenizer_name, pooling, max_length, query_instruction, text_instruction, normalize, model, tokenizer, embed_batch_size, cache_folder, trust_remote_code, device, callback_manager, parallel_process, target_devices, **model_kwargs)
    147 if model_name is None:
    148     raise ValueError(\"The `model_name` argument must be provided.\")
--> 150 model = SentenceTransformer(
    151     model_name,
    152     device=device,
    153     cache_folder=cache_folder,
    154     trust_remote_code=trust_remote_code,
    155     prompts={
    156         \"query\": query_instruction
    157         or get_query_instruct_for_model_name(model_name),
    158         \"text\": text_instruction
    159         or get_text_instruct_for_model_name(model_name),
    160     },
    161     **model_kwargs,
    162 )
    163 if max_length:
    164     model.max_seq_length = max_length

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\sentence_transformers\\SentenceTransformer.py:205, in SentenceTransformer.__init__(self, model_name_or_path, modules, device, prompts, default_prompt_name, cache_folder, trust_remote_code, revision, token, use_auth_token, truncate_dim)
    197         modules = self._load_sbert_model(
    198             model_name_or_path,
    199             token=token,
   (...)
    202             trust_remote_code=trust_remote_code,
    203         )
    204     else:
--> 205         modules = self._load_auto_model(
    206             model_name_or_path,
    207             token=token,
    208             cache_folder=cache_folder,
    209             revision=revision,
    210             trust_remote_code=trust_remote_code,
    211         )
    213 if modules is not None and not isinstance(modules, OrderedDict):
    214     modules = OrderedDict([(str(idx), module) for idx, module in enumerate(modules)])

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\sentence_transformers\\SentenceTransformer.py:1203, in SentenceTransformer._load_auto_model(self, model_name_or_path, token, cache_folder, revision, trust_remote_code)
   1192 logger.warning(
   1193     \"No sentence-transformers model found with name {}. Creating a new one with MEAN pooling.\".format(
   1194         model_name_or_path
   1195     )
   1196 )
   1197 transformer_model = Transformer(
   1198     model_name_or_path,
   1199     cache_dir=cache_folder,
   1200     model_args={\"token\": token, \"trust_remote_code\": trust_remote_code, \"revision\": revision},
   1201     tokenizer_args={\"token\": token, \"trust_remote_code\": trust_remote_code, \"revision\": revision},
   1202 )
-> 1203 pooling_model = Pooling(transformer_model.get_word_embedding_dimension(), \"mean\")
   1204 return [transformer_model, pooling_model]

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\sentence_transformers\\models\\Transformer.py:114, in Transformer.get_word_embedding_dimension(self)
    113 def get_word_embedding_dimension(self) -> int:
--> 114     return self.auto_model.config.hidden_size

File c:\\Users\\Cihan\\Desktop\\llamaindex\\lindex\\Lib\\site-packages\\transformers\\configuration_utils.py:202, in PretrainedConfig.__getattribute__(self, key)
    200 if key != \"attribute_map\" and key in super().__getattribute__(\"attribute_map\"):
    201     key = super().__getattribute__(\"attribute_map\")[key]
--> 202 return super().__getattribute__(key)

AttributeError: 'CLIPConfig' object has no attribute 'hidden_size'"
}
```


<!-- Answer -->
To resolve the `AttributeError: 'CLIPConfig' object has no attribute 'hidden_size'` when using the `MultiModalVectorStoreIndex` with the `image_embed_model` set to `"local:openai/clip-vit-large-patch14"`, you need to ensure that the `image_embed_model` is correctly resolved to an instance of `MultiModalEmbedding`. The error suggests that the `image_embed_model` is not being correctly instantiated or configured.

In the provided code, the `image_embed_model` is resolved using the `resolve_embed_model` function. Ensure that this function correctly handles the model path `"local:openai/clip-vit-large-patch14"` and returns an appropriate `MultiModalEmbedding` instance.

Here is the relevant part of the `MultiModalVectorStoreIndex` class constructor:

```python
def __init__(
    self,
    nodes: Optional[Sequence[BaseNode]] = None,
    index_struct: Optional[MultiModelIndexDict] = None,
    embed_model: Optional[BaseEmbedding] = None,
    storage_context: Optional[StorageContext] = None,
    use_async: bool = False,
    store_nodes_override: bool = False,
    show_progress: bool = False,
    # Image-related kwargs
    image_vector_store: Optional[BasePydanticVectorStore] = None,
    image_embed_model: EmbedType = "clip:ViT-B/32",
    is_image_to_text: bool = False,
    is_image_vector_store_empty: bool = False,
    is_text_vector_store_empty: bool = False,
    **kwargs: Any,
) -> None:
    """Initialize params."""
    image_embed_model = resolve_embed_model(
        image_embed_model, callback_manager=kwargs.get("callback_manager", None)
    )
    assert isinstance(image_embed_model, MultiModalEmbedding)
    self._image_embed_model = image_embed_model
    self._is_image_to_text = is_image_to_text
    self._is_image_vector_store_empty = is_image_vector_store_empty
    self._is_text_vector_store_empty = is_text_vector_store_empty
    storage_context = storage_context or StorageContext.from_defaults()

    if image_vector_store is not None:
        if self.image_namespace not in storage_context.vector_stores:
            storage_context.add_vector_store(
                image_vector_store, self.image_namespace
            )
        else:
            # overwrite image_store from storage_context
            storage_context.vector_stores[self.image_namespace] = image_vector_store

    if self.image_namespace not in storage_context.vector_stores:
        storage_context.add_vector_store(SimpleVectorStore(), self.image_namespace)

    self._image_vector_store = storage_context.vector_stores[self.image_namespace]

    super().__init__(
        nodes=nodes,
        index_struct=index_struct,
        embed_model=embed_model,
        storage_context=storage_context,
        show_progress=show_progress,
        use_async=use_async,
        store_nodes_override=store_nodes_override,
        **kwargs,
    )
```

Ensure that the `resolve_embed_model` function correctly handles the model path and returns an instance of `MultiModalEmbedding` that has the necessary attributes. If the `CLIPConfig` object does not have a `hidden_size` attribute, you may need to check the configuration of the model or modify the `resolve_embed_model` function to correctly set up the model.

The `ClipEmbedding` class from the `llama_index` library provides an example of how to correctly initialize and use a CLIP model for embedding:

```python
class ClipEmbedding(MultiModalEmbedding):
    """CLIP embedding models for encoding text and image for Multi-Modal purpose."""

    embed_batch_size: int = Field(default=DEFAULT_EMBED_BATCH_SIZE, gt=0)

    _clip: Any = PrivateAttr()
    _model: Any = PrivateAttr()
    _preprocess: Any = PrivateAttr()
    _device: Any = PrivateAttr()

    def __init__(
        self,
        *,
        embed_batch_size: int = DEFAULT_EMBED_BATCH_SIZE,
        model_name: str = DEFAULT_CLIP_MODEL,
        **kwargs: Any,
    ):
        """Initializes the ClipEmbedding class."""
        if embed_batch_size <= 0:
            raise ValueError(f"Embed batch size {embed_batch_size}  must be > 0.")

        try:
            import clip
            import torch
        except ImportError:
            raise ImportError(
                "ClipEmbedding requires `pip install git+https://github.com/openai/CLIP.git` and torch."
            )

        super().__init__(
            embed_batch_size=embed_batch_size, model_name=model_name, **kwargs
        )
        self._device = "cuda" if torch.cuda.is_available() else "cpu"
        if self.model_name not in AVAILABLE_CLIP_MODELS:
            raise ValueError(
                f"Model name {self.model_name} is not available in CLIP."
            )
        self._model, self._preprocess = clip.load(
            self.model_name, device=self._device
        )
```

Ensure that your `resolve_embed_model` function or equivalent correctly initializes the `ClipEmbedding` class and sets up the model with the necessary attributes. This should resolve the `AttributeError` by ensuring the `image_embed_model` is properly configured <sup>[[1]](https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/indices/multi_modal/base.py)</sup><sup>[[2]](https://github.com/run-llama/llama_index/blob/main/llama-index-core/llama_index/core/indices/multi_modal/base.py)</sup><sup>[[3]](https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/embeddings/clip.py)</sup>.


<!-- Dosu Comment Footer -->
*To continue talking to [Dosu](https://dosu.dev), mention @dosu.*

@g-hano Hmm, we actually don't have a multi-modal huggingface llm class yet.

If you want to use open-source VLMs, you could look into using Ollama

Contributions also welcome for a multi modal huggingface class!
I coded my own HuggingFaceMultiModal class that supports 4 different architectures and sent a [PR](https://github.com/run-llama/llama_index/pull/16133)

Commit message: Create BUILD

Patch to review:
diff --git a/docs/docs/examples/multi_modal/huggingface_multimodal.ipynb b/docs/docs/examples/multi_modal/huggingface_multimodal.ipynb
new file mode 100644
index 0000000000..6b3aef0713
--- /dev/null
+++ b/docs/docs/examples/multi_modal/huggingface_multimodal.ipynb
@@ -0,0 +1,1264 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mttrFJinETxm"
+      },
+      "source": [
+        "![](8.jpg)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install git+https://github.com/huggingface/transformers -q"
+      ],
+      "metadata": {
+        "id": "feyFyjbEAVFB",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "530b430d-9efa-46a6-ec7e-c5033e76f6f8"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip show transformers"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gXloX4X3Y9TO",
+        "outputId": "2c6c1366-b419-4338-c8e1-fd53bbf458f8"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Name: transformers\n",
+            "Version: 4.45.0.dev0\n",
+            "Summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow\n",
+            "Home-page: https://github.com/huggingface/transformers\n",
+            "Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)\n",
+            "Author-email: transformers@huggingface.co\n",
+            "License: Apache 2.0 License\n",
+            "Location: /usr/local/lib/python3.10/dist-packages\n",
+            "Requires: filelock, huggingface-hub, numpy, packaging, pyyaml, regex, requests, safetensors, tokenizers, tqdm\n",
+            "Required-by: \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install llama-index -q"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "S0-eja6oYP9O",
+        "outputId": "ca49f35a-3c87-49ff-c955-9fadb1a6a96d"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m46.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m46.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m187.4/187.4 kB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m375.6/375.6 kB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m295.8/295.8 kB\u001b[0m \u001b[31m11.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m40.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m318.9/318.9 kB\u001b[0m \u001b[31m12.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.3/49.3 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install flash-attn --no-build-isolation"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OiLOsVSfeRhq",
+        "outputId": "947027aa-fd55-4ed4-bde7-14e301cbf75e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting flash-attn\n",
+            "  Downloading flash_attn-2.6.3.tar.gz (2.6 MB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.6 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m126.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m66.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from flash-attn) (2.4.1+cu121)\n",
+            "Requirement already satisfied: einops in /usr/local/lib/python3.10/dist-packages (from flash-attn) (0.8.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.16.0)\n",
+            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (4.12.2)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (1.13.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.1.4)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (2024.6.1)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->flash-attn) (2.1.5)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->flash-attn) (1.3.0)\n",
+            "Building wheels for collected packages: flash-attn\n",
+            "  Building wheel for flash-attn (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for flash-attn: filename=flash_attn-2.6.3-cp310-cp310-linux_x86_64.whl size=187309225 sha256=237ef9c6157db394e1ddde4ba609a21ebb98382377a27041edc09318801a6f24\n",
+            "  Stored in directory: /root/.cache/pip/wheels/7e/e3/c3/89c7a2f3c4adc07cd1c675f8bb7b9ad4d18f64a72bccdfe826\n",
+            "Successfully built flash-attn\n",
+            "Installing collected packages: flash-attn\n",
+            "Successfully installed flash-attn-2.6.3\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install timm"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gshgoOR2aG5C",
+        "outputId": "78fddd71-db54-463b-9d57-345a50dce2b0"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting timm\n",
+            "  Downloading timm-1.0.9-py3-none-any.whl.metadata (42 kB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/42.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.4/42.4 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from timm) (2.4.1+cu121)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (from timm) (0.19.1+cu121)\n",
+            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from timm) (6.0.2)\n",
+            "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.10/dist-packages (from timm) (0.24.7)\n",
+            "Requirement already satisfied: safetensors in /usr/local/lib/python3.10/dist-packages (from timm) (0.4.5)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (3.16.1)\n",
+            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (2024.6.1)\n",
+            "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (24.1)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (2.32.3)\n",
+            "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (4.66.5)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (4.12.2)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->timm) (1.13.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->timm) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->timm) (3.1.4)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision->timm) (1.26.4)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision->timm) (10.4.0)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->timm) (2.1.5)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (2024.8.30)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->timm) (1.3.0)\n",
+            "Downloading timm-1.0.9-py3-none-any.whl (2.3 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.3/2.3 MB\u001b[0m \u001b[31m45.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: timm\n",
+            "Successfully installed timm-1.0.9\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install qwen-vl-utils"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mipSjIeUCqCj",
+        "outputId": "5ce771cc-9924-49f1-83d6-4970cd2bb84a"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting qwen-vl-utils\n",
+            "  Downloading qwen_vl_utils-0.0.5-py3-none-any.whl.metadata (3.5 kB)\n",
+            "Collecting av (from qwen-vl-utils)\n",
+            "  Downloading av-13.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.4 kB)\n",
+            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (from qwen-vl-utils) (10.4.0)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from qwen-vl-utils) (2.32.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (2024.8.30)\n",
+            "Downloading qwen_vl_utils-0.0.5-py3-none-any.whl (4.8 kB)\n",
+            "Downloading av-13.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (33.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m33.0/33.0 MB\u001b[0m \u001b[31m53.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: av, qwen-vl-utils\n",
+            "Successfully installed av-13.0.0 qwen-vl-utils-0.0.5\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Contact Me\n",
+        "\n",
+        "[![Email](https://img.shields.io/badge/Email-mcihan.yalcin%40outlook.com-blue?style=flat&logo=microsoft-outlook&logoColor=white)](mailto:mcihan.yalcin@outlook.com)\n",
+        "[![LinkedIn](https://img.shields.io/badge/LinkedIn-ChanYalcin-blue?style=flat&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/chanyalcin)\n",
+        "<p align=\"center\">\n",
+        "  <img src=\"https://media.giphy.com/media/13FBIII8M4IDDi/giphy.gif\" alt=\"Dancing Adventure Time GIF\" width=\"500\" />\n",
+        "</p>"
+      ],
+      "metadata": {
+        "id": "Rg7E6blT5ifO"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from huggingface_hub import notebook_login\n",
+        "notebook_login()"
+      ],
+      "metadata": {
+        "id": "I0nQtlCoElTa"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\", category=UserWarning)"
+      ],
+      "metadata": {
+        "id": "h8HxgD69D2pK"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Any, Dict, Sequence\n",
+        "from typing_extensions import override\n",
+        "from llama_index.core.base.llms.types import (\n",
+        "    ChatMessage,\n",
+        "    ChatResponse,\n",
+        "    ChatResponseAsyncGen,\n",
+        "    CompletionResponse,\n",
+        "    CompletionResponseAsyncGen,\n",
+        ")\n",
+        "from llama_index.core.bridge.pydantic import Field, PrivateAttr\n",
+        "from llama_index.core.constants import DEFAULT_CONTEXT_WINDOW, DEFAULT_NUM_OUTPUTS\n",
+        "from llama_index.core.multi_modal_llms import MultiModalLLM, MultiModalLLMMetadata\n",
+        "from llama_index.core.schema import ImageDocument, ImageNode\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "from transformers import (AutoProcessor,\n",
+        "                        AutoModelForCausalLM,\n",
+        "                        AutoConfig,\n",
+        "                        Qwen2VLForConditionalGeneration,\n",
+        "                        PaliGemmaForConditionalGeneration)\n",
+        "from qwen_vl_utils import process_vision_info # We will need that in order to work with different image shapes\n",
+        "\n",
+        "DEFAULT_MULTIMODAL_MODEL = \"Qwen/Qwen2-VL-2B-Instruct\"\n",
+        "DEFAULT_REQUEST_TIMEOUT = 120.0\n",
+        "SUPPORTED_VLMS = [\n",
+        "    \"Phi3VForCausalLM\",\n",
+        "    \"Florence2ForConditionalGeneration\",\n",
+        "    \"Qwen2VLForConditionalGeneration\",\n",
+        "    \"PaliGemmaForConditionalGeneration\"\n",
+        "]\n",
+        "\n",
+        "class HuggingFaceMultiModal(MultiModalLLM):\n",
+        "    \"\"\"\n",
+        "    This class provides a base implementation for interacting with HuggingFace multi-modal models.\n",
+        "    It handles model initialization, input preparation, and text/image-based interaction.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    model_name: str = Field(description=\"The name of the Hugging Face multi-modal model to use.\")\n",
+        "    device: str = Field(default=\"cuda\" if torch.cuda.is_available() else \"cpu\", description=\"The device to run the model on.\")\n",
+        "    torch_dtype: Any = Field(default=torch.float16 if torch.cuda.is_available() else torch.float32, description=\"The torch dtype to use.\")\n",
+        "    trust_remote_code: bool = Field(default=True, description=\"Whether to trust remote code when loading the model.\")\n",
+        "    context_window: int = Field(default=DEFAULT_CONTEXT_WINDOW, description=\"The maximum number of context tokens for the model.\")\n",
+        "    max_new_tokens: int = Field(default=DEFAULT_NUM_OUTPUTS, description=\"The maximum number of new tokens to generate.\")\n",
+        "    temperature: float = Field(default=0.0, description=\"The temperature to use for sampling.\")\n",
+        "    additional_kwargs: Dict[str, Any] = Field(default_factory=dict, description=\"Additional kwargs for model initialization and generation.\")\n",
+        "\n",
+        "    _model: Any = PrivateAttr()\n",
+        "    _processor: Any = PrivateAttr()\n",
+        "    _config: Any = PrivateAttr()\n",
+        "\n",
+        "    def __init__(self, **kwargs: Any) -> None:\n",
+        "        \"\"\"\n",
+        "        Initializes the HuggingFace multi-modal model and processor based on the provided configuration.\n",
+        "        \"\"\"\n",
+        "        super().__init__(**kwargs)\n",
+        "        try:\n",
+        "            # Load model configuration\n",
+        "            self._config = AutoConfig.from_pretrained(self.model_name, trust_remote_code=True)\n",
+        "            architecture = self._config.architectures[0]\n",
+        "            AutoModelClass = AutoModelForCausalLM # Default model class\n",
+        "\n",
+        "            # Special cases for specific model architectures\n",
+        "            if \"Qwen2VLForConditionalGeneration\" in architecture:\n",
+        "                AutoModelClass = Qwen2VLForConditionalGeneration\n",
+        "            if \"PaliGemmaForConditionalGeneration\" in architecture:\n",
+        "                AutoModelClass = PaliGemmaForConditionalGeneration\n",
+        "\n",
+        "            # Load the model based on the architecture\n",
+        "            self._model = AutoModelClass.from_pretrained(\n",
+        "                self.model_name,\n",
+        "                device_map=self.device,\n",
+        "                torch_dtype=self.torch_dtype,\n",
+        "                trust_remote_code=self.trust_remote_code,\n",
+        "                **self.additional_kwargs\n",
+        "            )\n",
+        "            # Load the processor (for handling text and image inputs)\n",
+        "            self._processor = AutoProcessor.from_pretrained(\n",
+        "                self.model_name,\n",
+        "                trust_remote_code=self.trust_remote_code\n",
+        "            )\n",
+        "        except Exception as e:\n",
+        "            raise ValueError(f\"Failed to initialize the model and processor: {str(e)}\")\n",
+        "\n",
+        "\n",
+        "    @classmethod\n",
+        "    def class_name(cls) -> str:\n",
+        "        \"\"\"Returns the class name for the model.\"\"\"\n",
+        "        return \"HuggingFace_multi_modal_llm\"\n",
+        "\n",
+        "    @property\n",
+        "    def metadata(self) -> MultiModalLLMMetadata:\n",
+        "        \"\"\"Multi Modal LLM metadata.\"\"\"\n",
+        "        return MultiModalLLMMetadata(\n",
+        "            context_window=self.context_window,\n",
+        "            num_output=self.max_new_tokens,\n",
+        "            model_name=self.model_name,\n",
+        "        )\n",
+        "\n",
+        "    # each unique model will override it\n",
+        "    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Abstract method: Prepares input messages and image documents for the model.\n",
+        "        This must be overridden by subclasses.\n",
+        "        \"\"\"\n",
+        "        raise NotImplementedError\n",
+        "    # each unique model will override it\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Abstract method: Generates text based on the prepared inputs.\n",
+        "        This must be overridden by subclasses.\n",
+        "        \"\"\"\n",
+        "        raise NotImplementedError\n",
+        "\n",
+        "    # some models will override it, some won't\n",
+        "    def complete(self, prompt: str, image_documents: Sequence[ImageDocument], **kwargs: Any) -> CompletionResponse:\n",
+        "        \"\"\"\n",
+        "        Completes a task based on a text prompt and optional images.\n",
+        "        The method prepares inputs and generates the corresponding text.\n",
+        "        \"\"\"\n",
+        "        prepared_inputs = self._prepare_messages([ChatMessage(role=\"user\", content=prompt)], image_documents)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "    # some models will override it, some won't\n",
+        "    def chat(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument], **kwargs: Any) -> ChatResponse:\n",
+        "        \"\"\"\n",
+        "        Engages in a chat-style interaction by processing a sequence of messages and optional images.\n",
+        "        \"\"\"\n",
+        "        prepared_inputs = self._prepare_messages(messages, image_documents)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    async def astream_chat(\n",
+        "        self, messages: Sequence[ChatMessage], **kwargs: Any\n",
+        "    ) -> ChatResponseAsyncGen:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "    async def astream_complete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponseAsyncGen:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async streaming completion yet.\")\n",
+        "\n",
+        "    async def acomplete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async completion yet.\")\n",
+        "\n",
+        "    async def achat(\n",
+        "        self, messages: Sequence[ChatMessage], **kwargs: Any\n",
+        "    ) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async chat yet.\")\n",
+        "\n",
+        "    async def stream_complete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async completion yet.\")\n",
+        "\n",
+        "    # we check the model architecture here\n",
+        "    @classmethod\n",
+        "    def from_model_name(cls, model_name: str, **kwargs: Any) -> 'HuggingFaceMultiModal':\n",
+        "        \"\"\"Checks the model architecture and initializes the model.\"\"\"\n",
+        "        config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)\n",
+        "        # we check the architecture because users would want to use their own finetuned versions of VLMs\n",
+        "        architecture = config.architectures[0]\n",
+        "\n",
+        "        if \"Phi3VForCausalLM\" in architecture:\n",
+        "            return Phi35VisionMultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"Florence2ForConditionalGeneration\" in architecture:\n",
+        "            return Florence2MultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"Qwen2VLForConditionalGeneration\" in architecture:\n",
+        "            return Qwen2VisionMultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"PaliGemmaForConditionalGeneration\" in architecture:\n",
+        "            return PaliGemmaMultiModal(model_name=model_name, **kwargs)\n",
+        "        else:\n",
+        "            raise ValueError(\n",
+        "                f\"Unsupported model architecture: {architecture}. \"\n",
+        "                f\"We currently support: {', '.join(SUPPORTED_VLMS)}\"\n",
+        "            )\n",
+        "\n",
+        "class Qwen2VisionMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Qwen2 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        conversation = []\n",
+        "        for img_doc in image_documents:\n",
+        "            conversation.append({\"type\":\"image\", \"image\":img_doc.image_path}) # Append images to conversation\n",
+        "        conversation.append({\"type\": \"text\", \"text\": messages[0].content}) # Add user text message\n",
+        "\n",
+        "        messages = [{\"role\":\"user\", \"content\": conversation}] # Wrap conversation in a user role\n",
+        "\n",
+        "        # Apply a chat template to format the message with the processor\n",
+        "        text_prompt = self._processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "        image_inputs, _ = process_vision_info(messages)\n",
+        "\n",
+        "        # Prepare the model inputs (text + images) and convert to tensor\n",
+        "        inputs = self._processor(text=[text_prompt], images=image_inputs, padding=True, return_tensors=\"pt\")\n",
+        "        return inputs.to(self.device)\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        output_ids = self._model.generate(**prepared_inputs, max_new_tokens=self.max_new_tokens)\n",
+        "        generated_ids = [\n",
+        "            output_ids[len(input_ids):] for input_ids, output_ids in zip(prepared_inputs[\"input_ids\"], output_ids)\n",
+        "        ]\n",
+        "        output_text = self._processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)\n",
+        "        return output_text[0]\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Qwen2VisionMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "class Florence2MultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Florence2 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "    @override\n",
+        "    def complete(self, task: str, image_document: ImageDocument, **kwargs: Any) -> CompletionResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "\n",
+        "    @override\n",
+        "    def chat(self, task: str, image_document: ImageDocument, **kwargs: Any) -> ChatResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    # TODO: Florence2 works with task_prompts, not user prompts\n",
+        "    # Task prompts are: '<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'\n",
+        "    def _prepare_messages(self, task: str, image_document: ImageDocument) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        prompt =  task.upper() if task.upper() in ['<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'] else '<DETAILED_CAPTION>'\n",
+        "        images = Image.open(image_document.image_path)\n",
+        "        inputs = self._processor(text=prompt, images=images, return_tensors=\"pt\").to(self.device, self.torch_dtype)\n",
+        "        return {\"prompt\": prompt,\n",
+        "                \"inputs\": inputs,\n",
+        "                \"image_size\": (images.width, images.height)}\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        inputs = prepared_inputs[\"inputs\"]\n",
+        "        image_size = prepared_inputs[\"image_size\"]\n",
+        "        task = prepared_inputs[\"prompt\"]\n",
+        "\n",
+        "        generated_ids = self._model.generate(\n",
+        "            input_ids=inputs[\"input_ids\"],\n",
+        "            pixel_values=inputs[\"pixel_values\"],\n",
+        "            max_new_tokens=self.max_new_tokens,\n",
+        "            num_beams=3,\n",
+        "            do_sample=False\n",
+        "        )\n",
+        "\n",
+        "        generated_text = self._processor.batch_decode(generated_ids, skip_special_tokens=False)[0]\n",
+        "\n",
+        "        # Use image_size from prepared_inputs to avoid storing self.image\n",
+        "        parsed_answer = self._processor.post_process_generation(generated_text, task=task, image_size=image_size)\n",
+        "        return parsed_answer[task]\n",
+        "\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Florence2MultiModal do not support async streaming chat yet.\")\n",
+        "\n",
+        "class Phi35VisionMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Phi3.5 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def _prepare_messages(self, message: ChatMessage, image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Phi3.5 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        images = [Image.open(img_doc.image_path) for img_doc in image_documents]\n",
+        "        placeholder = \"\".join(f\"<|image_{i+1}|>\\n\" for i in range(len(images)))\n",
+        "\n",
+        "        chat_messages = [{\"role\": message.role, \"content\": message.content}]\n",
+        "        if images:\n",
+        "            chat_messages[-1][\"content\"] = placeholder + chat_messages[-1][\"content\"]\n",
+        "\n",
+        "        prompt = self._processor.tokenizer.apply_chat_template(\n",
+        "            chat_messages,\n",
+        "            tokenize=False,\n",
+        "            add_generation_prompt=True\n",
+        "        )\n",
+        "        inputs = self._processor(prompt, images, return_tensors=\"pt\").to(self.device)\n",
+        "        return inputs\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        generate_ids = self._model.generate(\n",
+        "            **prepared_inputs,\n",
+        "            eos_token_id=self._processor.tokenizer.eos_token_id,\n",
+        "            max_new_tokens=self.max_new_tokens,\n",
+        "            temperature=self.temperature,\n",
+        "            do_sample=False\n",
+        "        )\n",
+        "        generate_ids = generate_ids[:, prepared_inputs['input_ids'].shape[1]:]\n",
+        "        response = self._processor.batch_decode(\n",
+        "            generate_ids,\n",
+        "            skip_special_tokens=True,\n",
+        "            clean_up_tokenization_spaces=False\n",
+        "        )[0]\n",
+        "        return response\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Phi35VisionMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "class PaliGemmaMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the PaliGemma multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    @override\n",
+        "    def complete(self, task: str, image_document: ImageDocument, **kwargs: Any) -> CompletionResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "\n",
+        "    @override\n",
+        "    def chat(self, task: str, image_document: ImageDocument, **kwargs: Any) -> ChatResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    def _prepare_messages(self, messages: ChatMessage, image_document: ImageDocument) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for PaliGemma models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        images = Image.open(image_document.image_path)\n",
+        "        inputs = self._processor(text=messages, images=images, return_tensors=\"pt\").to(self.device)\n",
+        "        input_len = inputs[\"input_ids\"].shape[-1]\n",
+        "        return {\"inputs\": inputs,\n",
+        "                \"input_len\": input_len}\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        input_len = prepared_inputs[\"input_len\"]\n",
+        "        inputs = prepared_inputs[\"inputs\"]\n",
+        "        generation = self._model.generate(**inputs, max_new_tokens=100, do_sample=False)\n",
+        "        generation = generation[0][input_len:]\n",
+        "        decoded = self._processor.decode(generation, skip_special_tokens=True)\n",
+        "        return decoded\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"PaliGemmaMultiModal does not support async streaming chat yet.\")"
+      ],
+      "metadata": {
+        "collapsed": true,
+        "id": "8WH6bFaaYOU8"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "os.makedirs(\"./input_images\", exist_ok=True)\n",
+        "\n",
+        "!wget \"https://docs.google.com/uc?export=download&id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF\" -O ./input_images/performance_spec.png\n",
+        "!wget \"https://docs.google.com/uc?export=download&id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i\" -O ./input_images/price.png"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5j39owvsCF_s",
+        "outputId": "88ada8de-56c5-41a3-a810-7c8a8345fbbf"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "--2024-09-20 20:11:50--  https://docs.google.com/uc?export=download&id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF\n",
+            "Resolving docs.google.com (docs.google.com)... 74.125.68.101, 74.125.68.138, 74.125.68.139, ...\n",
+            "Connecting to docs.google.com (docs.google.com)|74.125.68.101|:443... connected.\n",
+            "HTTP request sent, awaiting response... 303 See Other\n",
+            "Location: https://drive.usercontent.google.com/download?id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF&export=download [following]\n",
+            "--2024-09-20 20:11:51--  https://drive.usercontent.google.com/download?id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF&export=download\n",
+            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 172.253.118.132, 2404:6800:4003:c00::84\n",
+            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|172.253.118.132|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 62818 (61K) [image/png]\n",
+            "Saving to: ‘./input_images/performance_spec.png’\n",
+            "\n",
+            "./input_images/perf 100%[===================>]  61.35K  --.-KB/s    in 0.008s  \n",
+            "\n",
+            "2024-09-20 20:11:54 (7.56 MB/s) - ‘./input_images/performance_spec.png’ saved [62818/62818]\n",
+            "\n",
+            "--2024-09-20 20:11:54--  https://docs.google.com/uc?export=download&id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i\n",
+            "Resolving docs.google.com (docs.google.com)... 74.125.68.101, 74.125.68.138, 74.125.68.139, ...\n",
+            "Connecting to docs.google.com (docs.google.com)|74.125.68.101|:443... connected.\n",
+            "HTTP request sent, awaiting response... 303 See Other\n",
+            "Location: https://drive.usercontent.google.com/download?id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i&export=download [following]\n",
+            "--2024-09-20 20:11:54--  https://drive.usercontent.google.com/download?id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i&export=download\n",
+            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 172.253.118.132, 2404:6800:4003:c00::84\n",
+            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|172.253.118.132|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 128556 (126K) [image/png]\n",
+            "Saving to: ‘./input_images/price.png’\n",
+            "\n",
+            "./input_images/pric 100%[===================>] 125.54K  --.-KB/s    in 0.001s  \n",
+            "\n",
+            "2024-09-20 20:11:56 (111 MB/s) - ‘./input_images/price.png’ saved [128556/128556]\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open(\"./input_images/performance_spec.png\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 728
+        },
+        "id": "kMImHrlGEO1F",
+        "outputId": "e66978b2-abc7-43a4-ff9b-5a6ffa1dee3b"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=508x711>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 4
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open(\"./input_images/price.png\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 920
+        },
+        "id": "aTptl-PSET9a",
+        "outputId": "76982a1c-8c15-4b4b-b391-e3921d2900b6"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=367x903>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "llm = HuggingFaceMultiModal.from_model_name(\"Qwen/Qwen2-VL-2B-Instruct\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 136,
+          "referenced_widgets": [
+            "0e328b4568714752bfc62915d10ada39",
+            "f833cc85185d4c6d8381de9ee7b2a85a",
+            "5c91eadae84b40daa38ae5a7663471a5",
+            "d638bbd48e644e72be8d368215df57d6",
+            "e7a4a5dd6adb4b7eac04132144d539dc",
+            "8fe4f8e7d6674f42ab80a63478628b10",
+            "e0ed5ff76c434a1888eb3d3e00727be4",
+            "48325e08f3724dc487ff203a0c4da719",
+            "acbba68dd98042ad8fa4b4aa7ee1b134",
+            "1a052dbd7b2849a6b17ba74cf750fc82",
+            "645b2582638f44e6b81425e70dcce44f"
+          ]
+        },
+        "id": "WasNzvF3ZNNe",
+        "outputId": "42ee7107-968e-438f-cc3a-a78f4523f859"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "The argument `trust_remote_code` is to be used with Auto classes. It has no effect here and is ignored.\n",
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "`Qwen2VLRotaryEmbedding` can now be fully parameterized by passing the model config through the `config` argument. All other arguments will be removed in v4.46\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "0e328b4568714752bfc62915d10ada39"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from llama_index.core.readers import SimpleDirectoryReader\n",
+        "image_documents = SimpleDirectoryReader(\"./input_images\").load_data(show_progress=True)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7-LkUODLlMzy",
+        "outputId": "a08b8f6d-3e8b-4eec-fd99-cd1e8593db6a",
+        "collapsed": true
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Loading files: 100%|██████████| 2/2 [00:00<00:00, 52.58file/s]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "llm_response = llm.complete(\"Describe the images\", image_documents=image_documents)\n",
+        "print(llm_response.text)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IDOWoB7ZDHQd",
+        "outputId": "05f519f7-0b75-4e55-d271-35fa295c7470"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "The image is a screenshot of a webpage detailing the specifications of the Tesla Model Y. The page is divided into several sections, each providing information about the vehicle's performance, range, and other features. The main sections are:\n",
+            "\n",
+            "1. **Model Y Specifications**:\n",
+            "   - **Performance**:\n",
+            "     - **Battery**: Long Range\n",
+            "     - **Acceleration**: 3.7 s 0-100 km/h with rollout subtracted\n",
+            "     - **Range**: 459 km (EPA est.)\n",
+            "     - **Drive**: Dual Motor All-Wheel Drive\n",
+            "     - **Seating**: Up to 5\n",
+            "     - **Wheels**: 21\"\n",
+            "\n",
+            "2. **Performance**:\n",
+            "   - **Battery**: Long Range\n",
+            "   - **Weight**: 1,979 kg\n",
+            "   - **Max Cargo Volume**: 2,158 liters\n",
+            "   - **Top Speed**: 250 km/h\n",
+            "   - **Displays**: 15\" Center Touchscreen\n",
+            "   - **Supercharging Max/Payment Type**: 250 kW Max; Pay Per Use\n",
+            "   - **Warranty**: Basic Vehicle - 4 years or 80,000 km, whichever comes first; Battery &\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.11.3"
+    },
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "0e328b4568714752bfc62915d10ada39": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_f833cc85185d4c6d8381de9ee7b2a85a",
+              "IPY_MODEL_5c91eadae84b40daa38ae5a7663471a5",
+              "IPY_MODEL_d638bbd48e644e72be8d368215df57d6"
+            ],
+            "layout": "IPY_MODEL_e7a4a5dd6adb4b7eac04132144d539dc"
+          }
+        },
+        "f833cc85185d4c6d8381de9ee7b2a85a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8fe4f8e7d6674f42ab80a63478628b10",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e0ed5ff76c434a1888eb3d3e00727be4",
+            "value": "Loading checkpoint shards: 100%"
+          }
+        },
+        "5c91eadae84b40daa38ae5a7663471a5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_48325e08f3724dc487ff203a0c4da719",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_acbba68dd98042ad8fa4b4aa7ee1b134",
+            "value": 2
+          }
+        },
+        "d638bbd48e644e72be8d368215df57d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1a052dbd7b2849a6b17ba74cf750fc82",
+            "placeholder": "​",
+            "style": "IPY_MODEL_645b2582638f44e6b81425e70dcce44f",
+            "value": " 2/2 [00:13&lt;00:00,  6.10s/it]"
+          }
+        },
+        "e7a4a5dd6adb4b7eac04132144d539dc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8fe4f8e7d6674f42ab80a63478628b10": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e0ed5ff76c434a1888eb3d3e00727be4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "48325e08f3724dc487ff203a0c4da719": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "acbba68dd98042ad8fa4b4aa7ee1b134": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "1a052dbd7b2849a6b17ba74cf750fc82": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "645b2582638f44e6b81425e70dcce44f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/BUILD b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/BUILD
new file mode 100644
index 0000000000..db46e8d6c9
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/BUILD
@@ -0,0 +1 @@
+python_sources()
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/Makefile b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/Makefile
new file mode 100644
index 0000000000..b9eab05aa3
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/Makefile
@@ -0,0 +1,17 @@
+GIT_ROOT ?= $(shell git rev-parse --show-toplevel)
+
+help:	## Show all Makefile targets.
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[33m%-30s\033[0m %s\n", $$1, $$2}'
+
+format:	## Run code autoformatters (black).
+	pre-commit install
+	git ls-files | xargs pre-commit run black --files
+
+lint:	## Run linters: pre-commit (black, ruff, codespell) and mypy
+	pre-commit install && git ls-files | xargs pre-commit run --show-diff-on-failure --files
+
+test:	## Run tests via pytest.
+	pytest tests
+
+watch-docs:	## Build and watch documentation.
+	sphinx-autobuild docs/ docs/_build/html --open-browser --watch $(GIT_ROOT)/llama_index/
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/README.md b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/README.md
new file mode 100644
index 0000000000..b21c279ced
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/README.md
@@ -0,0 +1,84 @@
+# LlamaIndex Multi_Modal_Llms Integration: Huggingface
+
+This project integrates Hugging Face's multimodal language models into the LlamaIndex framework, enabling advanced multimodal capabilities for various AI applications.
+
+## Features
+
+- Seamless integration of Hugging Face multimodal models with LlamaIndex
+- Support for multiple state-of-the-art vision-language models and their **finetunes**:
+  - [Qwen2 Vision](https://huggingface.co/collections/Qwen/qwen2-vl-66cee7455501d7126940800d)
+  - [Florence2](https://huggingface.co/collections/microsoft/florence-6669f44df0d87d9c3bfb76de)
+  - [Phi-3.5 Vision](https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3)
+  - [PaLI-Gemma](https://huggingface.co/collections/google/paligemma-release-6643a9ffbf57de2ae0448dda)
+- Easy-to-use interface for multimodal tasks like image captioning and visual question answering
+- Configurable model parameters for fine-tuned performance
+
+---
+Author of that Integration [GitHub](https://github.com/g-hano) | [LinkedIn](https://www.linkedin.com/in/chanyalcin/) | [Email](mcihan.yalcin@outlook.com)
+---
+
+## Installation
+
+```bash
+pip install llama-index transformers torch pillow
+```
+
+Make sure to set your Hugging Face API token as an environment variable:
+
+```bash
+export HF_TOKEN=your_huggingface_token_here
+```
+
+## Usage
+
+Here's a basic example of how to use the Hugging Face multimodal integration:
+
+```python
+from llama_index.multi_modal_llms import HuggingFaceMultiModal
+from llama_index.schema import ImageDocument
+
+# Initialize the model
+model = HuggingFaceMultiModal.from_model_name("Qwen/Qwen2-VL-2B-Instruct")
+
+# Prepare your image and prompt
+image_document = ImageDocument(image_path="path/to/your/image.jpg")
+prompt = "Describe this image in detail."
+
+# Generate a response
+response = model.complete(prompt, image_documents=[image_document])
+
+print(response.text)
+```
+You can also refer to this [Colab notebook](examples\huggingface_multimodal.ipynb)
+
+## Supported Models
+
+1. Qwen2VisionMultiModal
+2. Florence2MultiModal
+3. Phi35VisionMultiModal
+4. PaliGemmaMultiModal
+
+Each model has its unique capabilities and can be selected based on your specific use case.
+
+## Configuration
+
+You can configure various parameters when initializing a model:
+
+```python
+model = HuggingFaceMultiModal(
+    model_name="Qwen/Qwen2-VL-2B-Instruct",
+    device="cuda",  # or "cpu"
+    torch_dtype=torch.float16,
+    max_new_tokens=100,
+    temperature=0.7
+)
+```
+
+## Limitations
+
+- Async streaming is not supported for any of the models.
+- Some models have specific requirements or limitations. Please refer to the individual model classes for details.
+
+---
+Author of that Integration [GitHub](https://github.com/g-hano) | [LinkedIn](https://www.linkedin.com/in/chanyalcin/) | [Email](mcihan.yalcin@outlook.com)
+---
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/examples/huggingface_multimodal.ipynb b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/examples/huggingface_multimodal.ipynb
new file mode 100644
index 0000000000..6b3aef0713
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/examples/huggingface_multimodal.ipynb
@@ -0,0 +1,1264 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mttrFJinETxm"
+      },
+      "source": [
+        "![](8.jpg)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install git+https://github.com/huggingface/transformers -q"
+      ],
+      "metadata": {
+        "id": "feyFyjbEAVFB",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "530b430d-9efa-46a6-ec7e-c5033e76f6f8"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip show transformers"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gXloX4X3Y9TO",
+        "outputId": "2c6c1366-b419-4338-c8e1-fd53bbf458f8"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Name: transformers\n",
+            "Version: 4.45.0.dev0\n",
+            "Summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow\n",
+            "Home-page: https://github.com/huggingface/transformers\n",
+            "Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)\n",
+            "Author-email: transformers@huggingface.co\n",
+            "License: Apache 2.0 License\n",
+            "Location: /usr/local/lib/python3.10/dist-packages\n",
+            "Requires: filelock, huggingface-hub, numpy, packaging, pyyaml, regex, requests, safetensors, tokenizers, tqdm\n",
+            "Required-by: \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install llama-index -q"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "S0-eja6oYP9O",
+        "outputId": "ca49f35a-3c87-49ff-c955-9fadb1a6a96d"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m46.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m46.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m187.4/187.4 kB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m375.6/375.6 kB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m295.8/295.8 kB\u001b[0m \u001b[31m11.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m40.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m318.9/318.9 kB\u001b[0m \u001b[31m12.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.3/49.3 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install flash-attn --no-build-isolation"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OiLOsVSfeRhq",
+        "outputId": "947027aa-fd55-4ed4-bde7-14e301cbf75e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting flash-attn\n",
+            "  Downloading flash_attn-2.6.3.tar.gz (2.6 MB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.6 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m126.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m66.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from flash-attn) (2.4.1+cu121)\n",
+            "Requirement already satisfied: einops in /usr/local/lib/python3.10/dist-packages (from flash-attn) (0.8.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.16.0)\n",
+            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (4.12.2)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (1.13.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (3.1.4)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch->flash-attn) (2024.6.1)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->flash-attn) (2.1.5)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->flash-attn) (1.3.0)\n",
+            "Building wheels for collected packages: flash-attn\n",
+            "  Building wheel for flash-attn (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for flash-attn: filename=flash_attn-2.6.3-cp310-cp310-linux_x86_64.whl size=187309225 sha256=237ef9c6157db394e1ddde4ba609a21ebb98382377a27041edc09318801a6f24\n",
+            "  Stored in directory: /root/.cache/pip/wheels/7e/e3/c3/89c7a2f3c4adc07cd1c675f8bb7b9ad4d18f64a72bccdfe826\n",
+            "Successfully built flash-attn\n",
+            "Installing collected packages: flash-attn\n",
+            "Successfully installed flash-attn-2.6.3\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install timm"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gshgoOR2aG5C",
+        "outputId": "78fddd71-db54-463b-9d57-345a50dce2b0"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting timm\n",
+            "  Downloading timm-1.0.9-py3-none-any.whl.metadata (42 kB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/42.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.4/42.4 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from timm) (2.4.1+cu121)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (from timm) (0.19.1+cu121)\n",
+            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from timm) (6.0.2)\n",
+            "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.10/dist-packages (from timm) (0.24.7)\n",
+            "Requirement already satisfied: safetensors in /usr/local/lib/python3.10/dist-packages (from timm) (0.4.5)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (3.16.1)\n",
+            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (2024.6.1)\n",
+            "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (24.1)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (2.32.3)\n",
+            "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (4.66.5)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub->timm) (4.12.2)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->timm) (1.13.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->timm) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->timm) (3.1.4)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision->timm) (1.26.4)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision->timm) (10.4.0)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->timm) (2.1.5)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub->timm) (2024.8.30)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->timm) (1.3.0)\n",
+            "Downloading timm-1.0.9-py3-none-any.whl (2.3 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.3/2.3 MB\u001b[0m \u001b[31m45.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: timm\n",
+            "Successfully installed timm-1.0.9\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install qwen-vl-utils"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mipSjIeUCqCj",
+        "outputId": "5ce771cc-9924-49f1-83d6-4970cd2bb84a"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting qwen-vl-utils\n",
+            "  Downloading qwen_vl_utils-0.0.5-py3-none-any.whl.metadata (3.5 kB)\n",
+            "Collecting av (from qwen-vl-utils)\n",
+            "  Downloading av-13.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.4 kB)\n",
+            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (from qwen-vl-utils) (10.4.0)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from qwen-vl-utils) (2.32.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->qwen-vl-utils) (2024.8.30)\n",
+            "Downloading qwen_vl_utils-0.0.5-py3-none-any.whl (4.8 kB)\n",
+            "Downloading av-13.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (33.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m33.0/33.0 MB\u001b[0m \u001b[31m53.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: av, qwen-vl-utils\n",
+            "Successfully installed av-13.0.0 qwen-vl-utils-0.0.5\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Contact Me\n",
+        "\n",
+        "[![Email](https://img.shields.io/badge/Email-mcihan.yalcin%40outlook.com-blue?style=flat&logo=microsoft-outlook&logoColor=white)](mailto:mcihan.yalcin@outlook.com)\n",
+        "[![LinkedIn](https://img.shields.io/badge/LinkedIn-ChanYalcin-blue?style=flat&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/chanyalcin)\n",
+        "<p align=\"center\">\n",
+        "  <img src=\"https://media.giphy.com/media/13FBIII8M4IDDi/giphy.gif\" alt=\"Dancing Adventure Time GIF\" width=\"500\" />\n",
+        "</p>"
+      ],
+      "metadata": {
+        "id": "Rg7E6blT5ifO"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from huggingface_hub import notebook_login\n",
+        "notebook_login()"
+      ],
+      "metadata": {
+        "id": "I0nQtlCoElTa"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\", category=UserWarning)"
+      ],
+      "metadata": {
+        "id": "h8HxgD69D2pK"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Any, Dict, Sequence\n",
+        "from typing_extensions import override\n",
+        "from llama_index.core.base.llms.types import (\n",
+        "    ChatMessage,\n",
+        "    ChatResponse,\n",
+        "    ChatResponseAsyncGen,\n",
+        "    CompletionResponse,\n",
+        "    CompletionResponseAsyncGen,\n",
+        ")\n",
+        "from llama_index.core.bridge.pydantic import Field, PrivateAttr\n",
+        "from llama_index.core.constants import DEFAULT_CONTEXT_WINDOW, DEFAULT_NUM_OUTPUTS\n",
+        "from llama_index.core.multi_modal_llms import MultiModalLLM, MultiModalLLMMetadata\n",
+        "from llama_index.core.schema import ImageDocument, ImageNode\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "from transformers import (AutoProcessor,\n",
+        "                        AutoModelForCausalLM,\n",
+        "                        AutoConfig,\n",
+        "                        Qwen2VLForConditionalGeneration,\n",
+        "                        PaliGemmaForConditionalGeneration)\n",
+        "from qwen_vl_utils import process_vision_info # We will need that in order to work with different image shapes\n",
+        "\n",
+        "DEFAULT_MULTIMODAL_MODEL = \"Qwen/Qwen2-VL-2B-Instruct\"\n",
+        "DEFAULT_REQUEST_TIMEOUT = 120.0\n",
+        "SUPPORTED_VLMS = [\n",
+        "    \"Phi3VForCausalLM\",\n",
+        "    \"Florence2ForConditionalGeneration\",\n",
+        "    \"Qwen2VLForConditionalGeneration\",\n",
+        "    \"PaliGemmaForConditionalGeneration\"\n",
+        "]\n",
+        "\n",
+        "class HuggingFaceMultiModal(MultiModalLLM):\n",
+        "    \"\"\"\n",
+        "    This class provides a base implementation for interacting with HuggingFace multi-modal models.\n",
+        "    It handles model initialization, input preparation, and text/image-based interaction.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    model_name: str = Field(description=\"The name of the Hugging Face multi-modal model to use.\")\n",
+        "    device: str = Field(default=\"cuda\" if torch.cuda.is_available() else \"cpu\", description=\"The device to run the model on.\")\n",
+        "    torch_dtype: Any = Field(default=torch.float16 if torch.cuda.is_available() else torch.float32, description=\"The torch dtype to use.\")\n",
+        "    trust_remote_code: bool = Field(default=True, description=\"Whether to trust remote code when loading the model.\")\n",
+        "    context_window: int = Field(default=DEFAULT_CONTEXT_WINDOW, description=\"The maximum number of context tokens for the model.\")\n",
+        "    max_new_tokens: int = Field(default=DEFAULT_NUM_OUTPUTS, description=\"The maximum number of new tokens to generate.\")\n",
+        "    temperature: float = Field(default=0.0, description=\"The temperature to use for sampling.\")\n",
+        "    additional_kwargs: Dict[str, Any] = Field(default_factory=dict, description=\"Additional kwargs for model initialization and generation.\")\n",
+        "\n",
+        "    _model: Any = PrivateAttr()\n",
+        "    _processor: Any = PrivateAttr()\n",
+        "    _config: Any = PrivateAttr()\n",
+        "\n",
+        "    def __init__(self, **kwargs: Any) -> None:\n",
+        "        \"\"\"\n",
+        "        Initializes the HuggingFace multi-modal model and processor based on the provided configuration.\n",
+        "        \"\"\"\n",
+        "        super().__init__(**kwargs)\n",
+        "        try:\n",
+        "            # Load model configuration\n",
+        "            self._config = AutoConfig.from_pretrained(self.model_name, trust_remote_code=True)\n",
+        "            architecture = self._config.architectures[0]\n",
+        "            AutoModelClass = AutoModelForCausalLM # Default model class\n",
+        "\n",
+        "            # Special cases for specific model architectures\n",
+        "            if \"Qwen2VLForConditionalGeneration\" in architecture:\n",
+        "                AutoModelClass = Qwen2VLForConditionalGeneration\n",
+        "            if \"PaliGemmaForConditionalGeneration\" in architecture:\n",
+        "                AutoModelClass = PaliGemmaForConditionalGeneration\n",
+        "\n",
+        "            # Load the model based on the architecture\n",
+        "            self._model = AutoModelClass.from_pretrained(\n",
+        "                self.model_name,\n",
+        "                device_map=self.device,\n",
+        "                torch_dtype=self.torch_dtype,\n",
+        "                trust_remote_code=self.trust_remote_code,\n",
+        "                **self.additional_kwargs\n",
+        "            )\n",
+        "            # Load the processor (for handling text and image inputs)\n",
+        "            self._processor = AutoProcessor.from_pretrained(\n",
+        "                self.model_name,\n",
+        "                trust_remote_code=self.trust_remote_code\n",
+        "            )\n",
+        "        except Exception as e:\n",
+        "            raise ValueError(f\"Failed to initialize the model and processor: {str(e)}\")\n",
+        "\n",
+        "\n",
+        "    @classmethod\n",
+        "    def class_name(cls) -> str:\n",
+        "        \"\"\"Returns the class name for the model.\"\"\"\n",
+        "        return \"HuggingFace_multi_modal_llm\"\n",
+        "\n",
+        "    @property\n",
+        "    def metadata(self) -> MultiModalLLMMetadata:\n",
+        "        \"\"\"Multi Modal LLM metadata.\"\"\"\n",
+        "        return MultiModalLLMMetadata(\n",
+        "            context_window=self.context_window,\n",
+        "            num_output=self.max_new_tokens,\n",
+        "            model_name=self.model_name,\n",
+        "        )\n",
+        "\n",
+        "    # each unique model will override it\n",
+        "    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Abstract method: Prepares input messages and image documents for the model.\n",
+        "        This must be overridden by subclasses.\n",
+        "        \"\"\"\n",
+        "        raise NotImplementedError\n",
+        "    # each unique model will override it\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Abstract method: Generates text based on the prepared inputs.\n",
+        "        This must be overridden by subclasses.\n",
+        "        \"\"\"\n",
+        "        raise NotImplementedError\n",
+        "\n",
+        "    # some models will override it, some won't\n",
+        "    def complete(self, prompt: str, image_documents: Sequence[ImageDocument], **kwargs: Any) -> CompletionResponse:\n",
+        "        \"\"\"\n",
+        "        Completes a task based on a text prompt and optional images.\n",
+        "        The method prepares inputs and generates the corresponding text.\n",
+        "        \"\"\"\n",
+        "        prepared_inputs = self._prepare_messages([ChatMessage(role=\"user\", content=prompt)], image_documents)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "    # some models will override it, some won't\n",
+        "    def chat(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument], **kwargs: Any) -> ChatResponse:\n",
+        "        \"\"\"\n",
+        "        Engages in a chat-style interaction by processing a sequence of messages and optional images.\n",
+        "        \"\"\"\n",
+        "        prepared_inputs = self._prepare_messages(messages, image_documents)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    async def astream_chat(\n",
+        "        self, messages: Sequence[ChatMessage], **kwargs: Any\n",
+        "    ) -> ChatResponseAsyncGen:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "    async def astream_complete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponseAsyncGen:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async streaming completion yet.\")\n",
+        "\n",
+        "    async def acomplete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async completion yet.\")\n",
+        "\n",
+        "    async def achat(\n",
+        "        self, messages: Sequence[ChatMessage], **kwargs: Any\n",
+        "    ) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async chat yet.\")\n",
+        "\n",
+        "    async def stream_complete(\n",
+        "        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any\n",
+        "    ) -> CompletionResponse:\n",
+        "        raise NotImplementedError(\"HuggingFaceMultiModal does not support async completion yet.\")\n",
+        "\n",
+        "    # we check the model architecture here\n",
+        "    @classmethod\n",
+        "    def from_model_name(cls, model_name: str, **kwargs: Any) -> 'HuggingFaceMultiModal':\n",
+        "        \"\"\"Checks the model architecture and initializes the model.\"\"\"\n",
+        "        config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)\n",
+        "        # we check the architecture because users would want to use their own finetuned versions of VLMs\n",
+        "        architecture = config.architectures[0]\n",
+        "\n",
+        "        if \"Phi3VForCausalLM\" in architecture:\n",
+        "            return Phi35VisionMultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"Florence2ForConditionalGeneration\" in architecture:\n",
+        "            return Florence2MultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"Qwen2VLForConditionalGeneration\" in architecture:\n",
+        "            return Qwen2VisionMultiModal(model_name=model_name, **kwargs)\n",
+        "        elif \"PaliGemmaForConditionalGeneration\" in architecture:\n",
+        "            return PaliGemmaMultiModal(model_name=model_name, **kwargs)\n",
+        "        else:\n",
+        "            raise ValueError(\n",
+        "                f\"Unsupported model architecture: {architecture}. \"\n",
+        "                f\"We currently support: {', '.join(SUPPORTED_VLMS)}\"\n",
+        "            )\n",
+        "\n",
+        "class Qwen2VisionMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Qwen2 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        conversation = []\n",
+        "        for img_doc in image_documents:\n",
+        "            conversation.append({\"type\":\"image\", \"image\":img_doc.image_path}) # Append images to conversation\n",
+        "        conversation.append({\"type\": \"text\", \"text\": messages[0].content}) # Add user text message\n",
+        "\n",
+        "        messages = [{\"role\":\"user\", \"content\": conversation}] # Wrap conversation in a user role\n",
+        "\n",
+        "        # Apply a chat template to format the message with the processor\n",
+        "        text_prompt = self._processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "        image_inputs, _ = process_vision_info(messages)\n",
+        "\n",
+        "        # Prepare the model inputs (text + images) and convert to tensor\n",
+        "        inputs = self._processor(text=[text_prompt], images=image_inputs, padding=True, return_tensors=\"pt\")\n",
+        "        return inputs.to(self.device)\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        output_ids = self._model.generate(**prepared_inputs, max_new_tokens=self.max_new_tokens)\n",
+        "        generated_ids = [\n",
+        "            output_ids[len(input_ids):] for input_ids, output_ids in zip(prepared_inputs[\"input_ids\"], output_ids)\n",
+        "        ]\n",
+        "        output_text = self._processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)\n",
+        "        return output_text[0]\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Qwen2VisionMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "class Florence2MultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Florence2 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "    @override\n",
+        "    def complete(self, task: str, image_document: ImageDocument, **kwargs: Any) -> CompletionResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "\n",
+        "    @override\n",
+        "    def chat(self, task: str, image_document: ImageDocument, **kwargs: Any) -> ChatResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    # TODO: Florence2 works with task_prompts, not user prompts\n",
+        "    # Task prompts are: '<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'\n",
+        "    def _prepare_messages(self, task: str, image_document: ImageDocument) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        prompt =  task.upper() if task.upper() in ['<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'] else '<DETAILED_CAPTION>'\n",
+        "        images = Image.open(image_document.image_path)\n",
+        "        inputs = self._processor(text=prompt, images=images, return_tensors=\"pt\").to(self.device, self.torch_dtype)\n",
+        "        return {\"prompt\": prompt,\n",
+        "                \"inputs\": inputs,\n",
+        "                \"image_size\": (images.width, images.height)}\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        inputs = prepared_inputs[\"inputs\"]\n",
+        "        image_size = prepared_inputs[\"image_size\"]\n",
+        "        task = prepared_inputs[\"prompt\"]\n",
+        "\n",
+        "        generated_ids = self._model.generate(\n",
+        "            input_ids=inputs[\"input_ids\"],\n",
+        "            pixel_values=inputs[\"pixel_values\"],\n",
+        "            max_new_tokens=self.max_new_tokens,\n",
+        "            num_beams=3,\n",
+        "            do_sample=False\n",
+        "        )\n",
+        "\n",
+        "        generated_text = self._processor.batch_decode(generated_ids, skip_special_tokens=False)[0]\n",
+        "\n",
+        "        # Use image_size from prepared_inputs to avoid storing self.image\n",
+        "        parsed_answer = self._processor.post_process_generation(generated_text, task=task, image_size=image_size)\n",
+        "        return parsed_answer[task]\n",
+        "\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Florence2MultiModal do not support async streaming chat yet.\")\n",
+        "\n",
+        "class Phi35VisionMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the Phi3.5 multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def _prepare_messages(self, message: ChatMessage, image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for Phi3.5 models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        images = [Image.open(img_doc.image_path) for img_doc in image_documents]\n",
+        "        placeholder = \"\".join(f\"<|image_{i+1}|>\\n\" for i in range(len(images)))\n",
+        "\n",
+        "        chat_messages = [{\"role\": message.role, \"content\": message.content}]\n",
+        "        if images:\n",
+        "            chat_messages[-1][\"content\"] = placeholder + chat_messages[-1][\"content\"]\n",
+        "\n",
+        "        prompt = self._processor.tokenizer.apply_chat_template(\n",
+        "            chat_messages,\n",
+        "            tokenize=False,\n",
+        "            add_generation_prompt=True\n",
+        "        )\n",
+        "        inputs = self._processor(prompt, images, return_tensors=\"pt\").to(self.device)\n",
+        "        return inputs\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        generate_ids = self._model.generate(\n",
+        "            **prepared_inputs,\n",
+        "            eos_token_id=self._processor.tokenizer.eos_token_id,\n",
+        "            max_new_tokens=self.max_new_tokens,\n",
+        "            temperature=self.temperature,\n",
+        "            do_sample=False\n",
+        "        )\n",
+        "        generate_ids = generate_ids[:, prepared_inputs['input_ids'].shape[1]:]\n",
+        "        response = self._processor.batch_decode(\n",
+        "            generate_ids,\n",
+        "            skip_special_tokens=True,\n",
+        "            clean_up_tokenization_spaces=False\n",
+        "        )[0]\n",
+        "        return response\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"Phi35VisionMultiModal does not support async streaming chat yet.\")\n",
+        "\n",
+        "class PaliGemmaMultiModal(HuggingFaceMultiModal):\n",
+        "    \"\"\"\n",
+        "    A specific implementation for the PaliGemma multi-modal model.\n",
+        "    Handles chat-style interactions that involve both text and images.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    @override\n",
+        "    def complete(self, task: str, image_document: ImageDocument, **kwargs: Any) -> CompletionResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return CompletionResponse(text=generated_text)\n",
+        "\n",
+        "    @override\n",
+        "    def chat(self, task: str, image_document: ImageDocument, **kwargs: Any) -> ChatResponse:\n",
+        "        if type(image_document) is list:\n",
+        "            print(f\"{self.model_name} can handle only one image. Will continue with the first image.\")\n",
+        "            image_document = image_document[0]\n",
+        "\n",
+        "        prepared_inputs = self._prepare_messages(task, image_document)\n",
+        "        generated_text = self._generate(prepared_inputs)\n",
+        "        return ChatResponse(message=ChatMessage(role=\"assistant\", content=generated_text), raw={\"model_output\": generated_text})\n",
+        "\n",
+        "    def _prepare_messages(self, messages: ChatMessage, image_document: ImageDocument) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Prepares the input messages and images for PaliGemma models. Images are appended in a custom format.\n",
+        "        \"\"\"\n",
+        "        images = Image.open(image_document.image_path)\n",
+        "        inputs = self._processor(text=messages, images=images, return_tensors=\"pt\").to(self.device)\n",
+        "        input_len = inputs[\"input_ids\"].shape[-1]\n",
+        "        return {\"inputs\": inputs,\n",
+        "                \"input_len\": input_len}\n",
+        "\n",
+        "    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:\n",
+        "        \"\"\"\n",
+        "        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.\n",
+        "        \"\"\"\n",
+        "        input_len = prepared_inputs[\"input_len\"]\n",
+        "        inputs = prepared_inputs[\"inputs\"]\n",
+        "        generation = self._model.generate(**inputs, max_new_tokens=100, do_sample=False)\n",
+        "        generation = generation[0][input_len:]\n",
+        "        decoded = self._processor.decode(generation, skip_special_tokens=True)\n",
+        "        return decoded\n",
+        "\n",
+        "    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:\n",
+        "        raise NotImplementedError(\"PaliGemmaMultiModal does not support async streaming chat yet.\")"
+      ],
+      "metadata": {
+        "collapsed": true,
+        "id": "8WH6bFaaYOU8"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "os.makedirs(\"./input_images\", exist_ok=True)\n",
+        "\n",
+        "!wget \"https://docs.google.com/uc?export=download&id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF\" -O ./input_images/performance_spec.png\n",
+        "!wget \"https://docs.google.com/uc?export=download&id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i\" -O ./input_images/price.png"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5j39owvsCF_s",
+        "outputId": "88ada8de-56c5-41a3-a810-7c8a8345fbbf"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "--2024-09-20 20:11:50--  https://docs.google.com/uc?export=download&id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF\n",
+            "Resolving docs.google.com (docs.google.com)... 74.125.68.101, 74.125.68.138, 74.125.68.139, ...\n",
+            "Connecting to docs.google.com (docs.google.com)|74.125.68.101|:443... connected.\n",
+            "HTTP request sent, awaiting response... 303 See Other\n",
+            "Location: https://drive.usercontent.google.com/download?id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF&export=download [following]\n",
+            "--2024-09-20 20:11:51--  https://drive.usercontent.google.com/download?id=1utu3iD9XEgR5Sb7PrbtMf1qw8T1WdNmF&export=download\n",
+            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 172.253.118.132, 2404:6800:4003:c00::84\n",
+            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|172.253.118.132|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 62818 (61K) [image/png]\n",
+            "Saving to: ‘./input_images/performance_spec.png’\n",
+            "\n",
+            "./input_images/perf 100%[===================>]  61.35K  --.-KB/s    in 0.008s  \n",
+            "\n",
+            "2024-09-20 20:11:54 (7.56 MB/s) - ‘./input_images/performance_spec.png’ saved [62818/62818]\n",
+            "\n",
+            "--2024-09-20 20:11:54--  https://docs.google.com/uc?export=download&id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i\n",
+            "Resolving docs.google.com (docs.google.com)... 74.125.68.101, 74.125.68.138, 74.125.68.139, ...\n",
+            "Connecting to docs.google.com (docs.google.com)|74.125.68.101|:443... connected.\n",
+            "HTTP request sent, awaiting response... 303 See Other\n",
+            "Location: https://drive.usercontent.google.com/download?id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i&export=download [following]\n",
+            "--2024-09-20 20:11:54--  https://drive.usercontent.google.com/download?id=1dpUakWMqaXR4Jjn1kHuZfB0pAXvjn2-i&export=download\n",
+            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 172.253.118.132, 2404:6800:4003:c00::84\n",
+            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|172.253.118.132|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 128556 (126K) [image/png]\n",
+            "Saving to: ‘./input_images/price.png’\n",
+            "\n",
+            "./input_images/pric 100%[===================>] 125.54K  --.-KB/s    in 0.001s  \n",
+            "\n",
+            "2024-09-20 20:11:56 (111 MB/s) - ‘./input_images/price.png’ saved [128556/128556]\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open(\"./input_images/performance_spec.png\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 728
+        },
+        "id": "kMImHrlGEO1F",
+        "outputId": "e66978b2-abc7-43a4-ff9b-5a6ffa1dee3b"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=508x711>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 4
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open(\"./input_images/price.png\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 920
+        },
+        "id": "aTptl-PSET9a",
+        "outputId": "76982a1c-8c15-4b4b-b391-e3921d2900b6"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=367x903>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "llm = HuggingFaceMultiModal.from_model_name(\"Qwen/Qwen2-VL-2B-Instruct\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 136,
+          "referenced_widgets": [
+            "0e328b4568714752bfc62915d10ada39",
+            "f833cc85185d4c6d8381de9ee7b2a85a",
+            "5c91eadae84b40daa38ae5a7663471a5",
+            "d638bbd48e644e72be8d368215df57d6",
+            "e7a4a5dd6adb4b7eac04132144d539dc",
+            "8fe4f8e7d6674f42ab80a63478628b10",
+            "e0ed5ff76c434a1888eb3d3e00727be4",
+            "48325e08f3724dc487ff203a0c4da719",
+            "acbba68dd98042ad8fa4b4aa7ee1b134",
+            "1a052dbd7b2849a6b17ba74cf750fc82",
+            "645b2582638f44e6b81425e70dcce44f"
+          ]
+        },
+        "id": "WasNzvF3ZNNe",
+        "outputId": "42ee7107-968e-438f-cc3a-a78f4523f859"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "The argument `trust_remote_code` is to be used with Auto classes. It has no effect here and is ignored.\n",
+            "Unrecognized keys in `rope_scaling` for 'rope_type'='default': {'mrope_section'}\n",
+            "`Qwen2VLRotaryEmbedding` can now be fully parameterized by passing the model config through the `config` argument. All other arguments will be removed in v4.46\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "0e328b4568714752bfc62915d10ada39"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from llama_index.core.readers import SimpleDirectoryReader\n",
+        "image_documents = SimpleDirectoryReader(\"./input_images\").load_data(show_progress=True)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7-LkUODLlMzy",
+        "outputId": "a08b8f6d-3e8b-4eec-fd99-cd1e8593db6a",
+        "collapsed": true
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Loading files: 100%|██████████| 2/2 [00:00<00:00, 52.58file/s]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "llm_response = llm.complete(\"Describe the images\", image_documents=image_documents)\n",
+        "print(llm_response.text)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IDOWoB7ZDHQd",
+        "outputId": "05f519f7-0b75-4e55-d271-35fa295c7470"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "The image is a screenshot of a webpage detailing the specifications of the Tesla Model Y. The page is divided into several sections, each providing information about the vehicle's performance, range, and other features. The main sections are:\n",
+            "\n",
+            "1. **Model Y Specifications**:\n",
+            "   - **Performance**:\n",
+            "     - **Battery**: Long Range\n",
+            "     - **Acceleration**: 3.7 s 0-100 km/h with rollout subtracted\n",
+            "     - **Range**: 459 km (EPA est.)\n",
+            "     - **Drive**: Dual Motor All-Wheel Drive\n",
+            "     - **Seating**: Up to 5\n",
+            "     - **Wheels**: 21\"\n",
+            "\n",
+            "2. **Performance**:\n",
+            "   - **Battery**: Long Range\n",
+            "   - **Weight**: 1,979 kg\n",
+            "   - **Max Cargo Volume**: 2,158 liters\n",
+            "   - **Top Speed**: 250 km/h\n",
+            "   - **Displays**: 15\" Center Touchscreen\n",
+            "   - **Supercharging Max/Payment Type**: 250 kW Max; Pay Per Use\n",
+            "   - **Warranty**: Basic Vehicle - 4 years or 80,000 km, whichever comes first; Battery &\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.11.3"
+    },
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "0e328b4568714752bfc62915d10ada39": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_f833cc85185d4c6d8381de9ee7b2a85a",
+              "IPY_MODEL_5c91eadae84b40daa38ae5a7663471a5",
+              "IPY_MODEL_d638bbd48e644e72be8d368215df57d6"
+            ],
+            "layout": "IPY_MODEL_e7a4a5dd6adb4b7eac04132144d539dc"
+          }
+        },
+        "f833cc85185d4c6d8381de9ee7b2a85a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8fe4f8e7d6674f42ab80a63478628b10",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e0ed5ff76c434a1888eb3d3e00727be4",
+            "value": "Loading checkpoint shards: 100%"
+          }
+        },
+        "5c91eadae84b40daa38ae5a7663471a5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_48325e08f3724dc487ff203a0c4da719",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_acbba68dd98042ad8fa4b4aa7ee1b134",
+            "value": 2
+          }
+        },
+        "d638bbd48e644e72be8d368215df57d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1a052dbd7b2849a6b17ba74cf750fc82",
+            "placeholder": "​",
+            "style": "IPY_MODEL_645b2582638f44e6b81425e70dcce44f",
+            "value": " 2/2 [00:13&lt;00:00,  6.10s/it]"
+          }
+        },
+        "e7a4a5dd6adb4b7eac04132144d539dc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8fe4f8e7d6674f42ab80a63478628b10": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e0ed5ff76c434a1888eb3d3e00727be4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "48325e08f3724dc487ff203a0c4da719": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "acbba68dd98042ad8fa4b4aa7ee1b134": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "1a052dbd7b2849a6b17ba74cf750fc82": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "645b2582638f44e6b81425e70dcce44f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/BUILD b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/BUILD
new file mode 100644
index 0000000000..db46e8d6c9
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/BUILD
@@ -0,0 +1 @@
+python_sources()
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__init__.py b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__init__.py
new file mode 100644
index 0000000000..12ceb0f64c
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__init__.py
@@ -0,0 +1,5 @@
+from llama_index.multi_modal_llms.huggingface.base import HuggingFaceMultiModal
+                    
+__all__ = [
+    "HuggingFaceMultiModal"
+]
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/__init__.cpython-312.pyc b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000..cca658fe9a
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/__init__.cpython-312.pyc differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/base.cpython-312.pyc b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/base.cpython-312.pyc
new file mode 100644
index 0000000000..09d077a519
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/__pycache__/base.cpython-312.pyc differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/base.py b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/base.py
new file mode 100644
index 0000000000..b1acc7c47e
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/llama_index/multi_modal_llms/huggingface/base.py
@@ -0,0 +1,383 @@
+from typing import Any, Dict, Sequence
+from typing_extensions import override
+from llama_index.core.base.llms.types import (
+    ChatMessage,
+    ChatResponse,
+    ChatResponseAsyncGen,
+    CompletionResponse,
+    CompletionResponseAsyncGen,
+)
+from llama_index.core.bridge.pydantic import Field, PrivateAttr
+from llama_index.core.constants import DEFAULT_CONTEXT_WINDOW, DEFAULT_NUM_OUTPUTS
+from llama_index.core.multi_modal_llms import MultiModalLLM, MultiModalLLMMetadata
+from llama_index.core.schema import ImageDocument, ImageNode
+import torch
+from PIL import Image
+from transformers import (AutoProcessor, 
+                        AutoModelForCausalLM,
+                        AutoConfig, 
+                        Qwen2VLForConditionalGeneration,
+                        PaliGemmaForConditionalGeneration)
+from qwen_vl_utils import process_vision_info # We will need that in order to work with different image shapes
+
+DEFAULT_MULTIMODAL_MODEL = "Qwen/Qwen2-VL-2B-Instruct"
+DEFAULT_REQUEST_TIMEOUT = 120.0
+SUPPORTED_VLMS = [
+    "Phi3VForCausalLM",
+    "Florence2ForConditionalGeneration",
+    "Qwen2VLForConditionalGeneration",
+    "PaliGemmaForConditionalGeneration"
+]
+
+class HuggingFaceMultiModal(MultiModalLLM):
+    """
+    This class provides a base implementation for interacting with HuggingFace multi-modal models.
+    It handles model initialization, input preparation, and text/image-based interaction.
+    """
+
+    model_name: str = Field(description="The name of the Hugging Face multi-modal model to use.")
+    device: str = Field(default="cuda" if torch.cuda.is_available() else "cpu", description="The device to run the model on.")
+    torch_dtype: Any = Field(default=torch.float16 if torch.cuda.is_available() else torch.float32, description="The torch dtype to use.")
+    trust_remote_code: bool = Field(default=True, description="Whether to trust remote code when loading the model.")
+    context_window: int = Field(default=DEFAULT_CONTEXT_WINDOW, description="The maximum number of context tokens for the model.")
+    max_new_tokens: int = Field(default=DEFAULT_NUM_OUTPUTS, description="The maximum number of new tokens to generate.")
+    temperature: float = Field(default=0.0, description="The temperature to use for sampling.")
+    additional_kwargs: Dict[str, Any] = Field(default_factory=dict, description="Additional kwargs for model initialization and generation.")
+
+    _model: Any = PrivateAttr()
+    _processor: Any = PrivateAttr()
+    _config: Any = PrivateAttr()
+
+    def __init__(self, **kwargs: Any) -> None:
+        """
+        Initializes the HuggingFace multi-modal model and processor based on the provided configuration.
+        """
+        super().__init__(**kwargs)        
+        try:
+            # Load model configuration
+            self._config = AutoConfig.from_pretrained(self.model_name, trust_remote_code=True)
+            architecture = self._config.architectures[0]
+            AutoModelClass = AutoModelForCausalLM # Default model class
+            
+            # Special cases for specific model architectures
+            if "Qwen2VLForConditionalGeneration" in architecture:
+                AutoModelClass = Qwen2VLForConditionalGeneration
+            if "PaliGemmaForConditionalGeneration" in architecture:
+                AutoModelClass = PaliGemmaForConditionalGeneration
+
+            # Load the model based on the architecture
+            self._model = AutoModelClass.from_pretrained(
+                self.model_name,
+                device_map=self.device,
+                torch_dtype=self.torch_dtype,
+                trust_remote_code=self.trust_remote_code,
+                **self.additional_kwargs
+            )
+            # Load the processor (for handling text and image inputs)
+            self._processor = AutoProcessor.from_pretrained(
+                self.model_name,
+                trust_remote_code=self.trust_remote_code
+            )
+        except Exception as e:
+            raise ValueError(f"Failed to initialize the model and processor: {str(e)}")
+
+    
+    @classmethod
+    def class_name(cls) -> str:
+        """Returns the class name for the model."""
+        return "HuggingFace_multi_modal_llm"
+    
+    @property
+    def metadata(self) -> MultiModalLLMMetadata:
+        """Multi Modal LLM metadata."""
+        return MultiModalLLMMetadata(
+            context_window=self.context_window,
+            num_output=self.max_new_tokens,
+            model_name=self.model_name,
+        )
+    
+    # each unique model will override it
+    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:
+        """
+        Abstract method: Prepares input messages and image documents for the model.
+        This must be overridden by subclasses.
+        """
+        raise NotImplementedError
+    # each unique model will override it
+    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:
+        """
+        Abstract method: Generates text based on the prepared inputs.
+        This must be overridden by subclasses.
+        """
+        raise NotImplementedError
+    
+    # some models will override it, some won't
+    def complete(self, prompt: str, image_documents: Sequence[ImageDocument], **kwargs: Any) -> CompletionResponse:
+        """
+        Completes a task based on a text prompt and optional images.
+        The method prepares inputs and generates the corresponding text.
+        """
+        prepared_inputs = self._prepare_messages([ChatMessage(role="user", content=prompt)], image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return CompletionResponse(text=generated_text)
+    # some models will override it, some won't
+    def chat(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument], **kwargs: Any) -> ChatResponse:
+        """
+        Engages in a chat-style interaction by processing a sequence of messages and optional images.
+        """
+        prepared_inputs = self._prepare_messages(messages, image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return ChatResponse(message=ChatMessage(role="assistant", content=generated_text), raw={"model_output": generated_text})
+    
+    async def astream_chat(
+        self, messages: Sequence[ChatMessage], **kwargs: Any
+    ) -> ChatResponseAsyncGen:
+        raise NotImplementedError("HuggingFaceMultiModal does not support async streaming chat yet.")
+
+    async def astream_complete(
+        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any
+    ) -> CompletionResponseAsyncGen:
+        raise NotImplementedError("HuggingFaceMultiModal does not support async streaming completion yet.")
+    
+    async def acomplete(
+        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any
+    ) -> CompletionResponse:
+        raise NotImplementedError("HuggingFaceMultiModal does not support async completion yet.")
+
+    async def achat(
+        self, messages: Sequence[ChatMessage], **kwargs: Any
+    ) -> ChatResponse:
+        raise NotImplementedError("HuggingFaceMultiModal does not support async chat yet.")
+    
+    async def stream_complete(
+        self, prompt: str, image_documents: Sequence[ImageNode], **kwargs: Any
+    ) -> CompletionResponse:
+        raise NotImplementedError("HuggingFaceMultiModal does not support async completion yet.")
+
+    # we check the model architecture here
+    @classmethod
+    def from_model_name(cls, model_name: str, **kwargs: Any) -> 'HuggingFaceMultiModal':
+        """Checks the model architecture and initializes the model."""
+        config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
+        # we check the architecture because users would want to use their own finetuned versions of VLMs
+        architecture = config.architectures[0] 
+        
+        if "Phi3VForCausalLM" in architecture:
+            return Phi35VisionMultiModal(model_name=model_name, **kwargs)
+        elif "Florence2ForConditionalGeneration" in architecture:
+            return Florence2MultiModal(model_name=model_name, **kwargs)
+        elif "Qwen2VLForConditionalGeneration" in architecture:
+            return Qwen2VisionMultiModal(model_name=model_name, **kwargs)
+        elif "PaliGemmaForConditionalGeneration" in architecture:
+            return PaliGemmaMultiModal(model_name=model_name, **kwargs)
+        else:
+            raise ValueError(
+                f"Unsupported model architecture: {architecture}. "
+                f"We currently support: {', '.join(SUPPORTED_VLMS)}"
+            )
+        
+class Qwen2VisionMultiModal(HuggingFaceMultiModal):
+    """
+    A specific implementation for the Qwen2 multi-modal model. 
+    Handles chat-style interactions that involve both text and images.
+    """
+
+    def _prepare_messages(self, messages: Sequence[ChatMessage], image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:     
+        """
+        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.
+        """
+        conversation = []
+        for img_doc in image_documents:
+            conversation.append({"type":"image", "image":img_doc.image_path}) # Append images to conversation
+        conversation.append({"type": "text", "text": messages[0].content}) # Add user text message
+        
+        messages = [{"role":"user", "content": conversation}] # Wrap conversation in a user role
+
+        # Apply a chat template to format the message with the processor
+        text_prompt = self._processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        image_inputs, _ = process_vision_info(messages)
+
+        # Prepare the model inputs (text + images) and convert to tensor
+        inputs = self._processor(text=[text_prompt], images=image_inputs, padding=True, return_tensors="pt")
+        return inputs.to(self.device)
+
+    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:
+        """
+        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.
+        """
+        output_ids = self._model.generate(**prepared_inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [
+            output_ids[len(input_ids):] for input_ids, output_ids in zip(prepared_inputs["input_ids"], output_ids)
+        ]
+        output_text = self._processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        return output_text[0]
+    
+    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
+        raise NotImplementedError("Qwen2VisionMultiModal does not support async streaming chat yet.")
+    
+class Florence2MultiModal(HuggingFaceMultiModal):   
+    """
+    A specific implementation for the Florence2 multi-modal model. 
+    Handles chat-style interactions that involve both text and images.
+    """
+    @override
+    def complete(self, task: str, image_documents: ImageDocument, **kwargs: Any) -> CompletionResponse:
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handle only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+
+        prepared_inputs = self._prepare_messages(task, image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return CompletionResponse(text=generated_text)
+    
+    @override
+    def chat(self, task: str, image_documents: ImageDocument, **kwargs: Any) -> ChatResponse:
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handleo only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+        
+        prepared_inputs = self._prepare_messages(task, image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return ChatResponse(message=ChatMessage(role="assistant", content=generated_text), raw={"model_output": generated_text})
+    
+    # TODO: Florence2 works with task_prompts, not user prompts
+    # Task prompts are: '<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'
+    def _prepare_messages(self, task: str, image_documents: ImageDocument) -> Dict[str, Any]:
+        """
+        Prepares the input messages and images for Qwen2 models. Images are appended in a custom format.
+        """
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handleo only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+        prompt =  task.upper() if task.upper() in ['<CAPTION>', '<DETAILED_CAPTION>', '<MORE_DETAILED_CAPTION>'] else '<DETAILED_CAPTION>'
+        images = Image.open(image_documents.image_path)
+        inputs = self._processor(text=prompt, images=images, return_tensors="pt").to(self.device, self.torch_dtype)
+        return {"prompt": prompt,
+                "inputs": inputs,
+                "image_size": (images.width, images.height)}
+
+    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:
+        """
+        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.
+        """
+        inputs = prepared_inputs["inputs"]
+        image_size = prepared_inputs["image_size"]
+        task = prepared_inputs["prompt"]
+
+        generated_ids = self._model.generate(
+            input_ids=inputs["input_ids"],
+            pixel_values=inputs["pixel_values"],
+            max_new_tokens=self.max_new_tokens,
+            num_beams=3,
+            do_sample=False
+        )
+        
+        generated_text = self._processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+        
+        # Use image_size from prepared_inputs to avoid storing self.image
+        parsed_answer = self._processor.post_process_generation(generated_text, task=task, image_size=image_size)
+        return parsed_answer[task]
+    
+
+    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
+        raise NotImplementedError("Florence2MultiModal do not support async streaming chat yet.")
+    
+class Phi35VisionMultiModal(HuggingFaceMultiModal):
+    """
+    A specific implementation for the Phi3.5 multi-modal model. 
+    Handles chat-style interactions that involve both text and images.
+    """
+    
+    def _prepare_messages(self, message: ChatMessage, image_documents: Sequence[ImageDocument]) -> Dict[str, Any]:
+        """
+        Prepares the input messages and images for Phi3.5 models. Images are appended in a custom format.
+        """
+        images = [Image.open(img_doc.image_path) for img_doc in image_documents]
+        placeholder = "".join(f"<|image_{i+1}|>\n" for i in range(len(images)))
+        
+        chat_messages = [{"role": message.role, "content": message.content}]
+        if images:
+            chat_messages[-1]["content"] = placeholder + chat_messages[-1]["content"]
+        
+        prompt = self._processor.tokenizer.apply_chat_template(
+            chat_messages, 
+            tokenize=False, 
+            add_generation_prompt=True
+        )
+        inputs = self._processor(prompt, images, return_tensors="pt").to(self.device)
+        return inputs
+
+    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:
+        """
+        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.
+        """
+        generate_ids = self._model.generate(
+            **prepared_inputs, 
+            eos_token_id=self._processor.tokenizer.eos_token_id, 
+            max_new_tokens=self.max_new_tokens,
+            temperature=self.temperature,
+            do_sample=False
+        )
+        generate_ids = generate_ids[:, prepared_inputs['input_ids'].shape[1]:]
+        response = self._processor.batch_decode(
+            generate_ids, 
+            skip_special_tokens=True, 
+            clean_up_tokenization_spaces=False
+        )[0]
+        return response
+    
+    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
+        raise NotImplementedError("Phi35VisionMultiModal does not support async streaming chat yet.")
+    
+class PaliGemmaMultiModal(HuggingFaceMultiModal):
+    """
+    A specific implementation for the PaliGemma multi-modal model. 
+    Handles chat-style interactions that involve both text and images.
+    """
+
+    @override
+    def complete(self, task: str, image_documents: ImageDocument, **kwargs: Any) -> CompletionResponse:
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handle only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+
+        prepared_inputs = self._prepare_messages(task, image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return CompletionResponse(text=generated_text)
+    
+    @override
+    def chat(self, task: str, image_documents: ImageDocument, **kwargs: Any) -> ChatResponse:
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handle only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+        
+        prepared_inputs = self._prepare_messages(task, image_documents)
+        generated_text = self._generate(prepared_inputs)
+        return ChatResponse(message=ChatMessage(role="assistant", content=generated_text), raw={"model_output": generated_text})
+    
+    def _prepare_messages(self, messages: ChatMessage, image_documents: ImageDocument) -> Dict[str, Any]:
+        """
+        Prepares the input messages and images for PaliGemma models. Images are appended in a custom format.
+        """
+        if type(image_documents) is list:
+            print(f"{self.model_name} can handleo only one image. Will continue with the first image.")
+            image_documents = image_documents[0]
+        images = Image.open(image_documents.image_path)
+        inputs = self._processor(text=messages, images=images, return_tensors="pt").to(self.device)
+        input_len = inputs["input_ids"].shape[-1]
+        return {"inputs": inputs,
+                "input_len": input_len}
+
+    def _generate(self, prepared_inputs: Dict[str, Any]) -> str:
+        """
+        Generates text based on prepared inputs. The text is decoded from token IDs generated by the model.
+        """
+        input_len = prepared_inputs["input_len"]
+        inputs = prepared_inputs["inputs"]
+        generation = self._model.generate(**inputs, max_new_tokens=100, do_sample=False)
+        generation = generation[0][input_len:]
+        decoded = self._processor.decode(generation, skip_special_tokens=True)
+        return decoded
+
+    async def stream_chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
+        raise NotImplementedError("PaliGemmaMultiModal does not support async streaming chat yet.")
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/pyproject.toml b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/pyproject.toml
new file mode 100644
index 0000000000..5c3c11e3d4
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/pyproject.toml
@@ -0,0 +1,56 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.codespell]
+check-filenames = true
+check-hidden = true
+# Feel free to un-skip examples, and experimental, you will just need to
+# work through many typos (--write-changes and --interactive will help)
+skip = "*.csv,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb"
+
+# [tool.llamahub]
+# contains_example = false
+# import_path = "llama_index.multi_modal_llms.huggingface"
+
+# [tool.llamahub.class_authors]
+# CLASS = "g-hano"
+
+[tool.mypy]
+disallow_untyped_defs = true
+# Remove venv skip when integrated with pre-commit
+exclude = ["_static", "build", "examples", "notebooks", "venv"]
+ignore_missing_imports = true
+python_version = "3.8"
+
+[tool.poetry]
+name = "llama-index-multi-modal-llms-huggingface"
+version = "0.1.0"
+description = "llama-index multi_modal_llms HuggingFace integration by [Cihan Yalçın](https://www.linkedin.com/in/chanyalcin/)"
+authors = ["M.Cihan Yalçın mcihan.yalcin@outlook.com"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "llama_index/"}]
+
+[tool.poetry.dependencies]
+python = ">=3.8.1,<4.0"
+llama-index-core = "^0.10.0"
+
+[tool.poetry.group.dev.dependencies]
+black = {extras = ["jupyter"], version = "<=23.9.1,>=23.7.0"}
+codespell = {extras = ["toml"], version = ">=v2.2.6"}
+ipython = "8.10.0"
+jupyter = "^1.0.0"
+mypy = "0.991"
+pre-commit = "3.2.0"
+pylint = "2.15.10"
+pytest = "7.2.1"
+pytest-mock = "3.11.1"
+ruff = "0.0.292"
+tree-sitter-languages = "^1.8.0"
+types-Deprecated = ">=0.1.0"
+types-PyYAML = "^6.0.12.12"
+types-protobuf = "^4.24.0.4"
+types-redis = "4.5.5.0"
+types-requests = "2.28.11.8" # TODO: unpin when mypy>0.991
+types-setuptools = "67.1.0.0"
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__init__.py b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/__init__.cpython-312.pyc b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000..f7ea4b320e
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/test_multi_modal_llms_huggingface.cpython-312-pytest-8.3.3.pyc b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/test_multi_modal_llms_huggingface.cpython-312-pytest-8.3.3.pyc
new file mode 100644
index 0000000000..a16440aa7e
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/__pycache__/test_multi_modal_llms_huggingface.cpython-312-pytest-8.3.3.pyc differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/2dogs.jpg b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/2dogs.jpg
new file mode 100644
index 0000000000..53767beb15
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/2dogs.jpg differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/5cats.jpg b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/5cats.jpg
new file mode 100644
index 0000000000..c3bd4d4b88
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/5cats.jpg differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/girl_rabbit.jpg b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/girl_rabbit.jpg
new file mode 100644
index 0000000000..8d1c2c2745
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/girl_rabbit.jpg differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/man_read.jpg b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/man_read.jpg
new file mode 100644
index 0000000000..55993bfa93
Binary files /dev/null and b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_images/man_read.jpg differ
diff --git a/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_multi_modal_llms_huggingface.py b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_multi_modal_llms_huggingface.py
new file mode 100644
index 0000000000..5daa43e0b1
--- /dev/null
+++ b/llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/tests/test_multi_modal_llms_huggingface.py
@@ -0,0 +1,72 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from llama_index.multi_modal_llms.huggingface import HuggingFaceMultiModal
+from llama_index.core.schema import ImageDocument
+
+# Mock the model and processor initialization for all test cases
+@pytest.fixture(autouse=True)
+def mock_huggingface_model_init():
+    with patch("transformers.AutoConfig.from_pretrained") as mock_config, \
+         patch("transformers.AutoProcessor.from_pretrained") as mock_processor, \
+         patch("transformers.AutoModelForCausalLM.from_pretrained") as mock_model, \
+         patch("transformers.Qwen2VLForConditionalGeneration.from_pretrained") as mock_qwen, \
+         patch("transformers.PaliGemmaForConditionalGeneration.from_pretrained") as mock_pali:
+
+        # Mocking return values for each model and processor
+        mock_config.return_value = MagicMock(architectures=["Qwen2VLForConditionalGeneration"])
+        mock_processor.return_value = MagicMock()
+        mock_model.return_value = MagicMock()
+        mock_qwen.return_value = MagicMock()
+        mock_pali.return_value = MagicMock()
+
+        yield
+
+# Test for PaliGemma model
+def test_pali_gemma_model():
+    llm = HuggingFaceMultiModal.from_model_name("google/paligemma-3b-pt-224")
+    image = ImageDocument(image_path="test_images/man_read.jpg")
+    
+    with patch.object(llm, '_prepare_messages', return_value={'mock': 'inputs'}), \
+         patch.object(llm, '_generate', return_value="This is a test description"):
+
+        result = llm.complete("Describe the image", image_documents=[image])
+        assert result.text is not None and result.text != ""
+        assert True  # Return True if we receive any response
+
+# Test for Phi model
+def test_phi_model():
+    llm = HuggingFaceMultiModal.from_model_name("microsoft/Phi-3.5-vision-instruct")
+    image = ImageDocument(image_path="test_images/5cats.jpg")
+    
+    with patch.object(llm, '_prepare_messages', return_value={'mock': 'inputs'}), \
+         patch.object(llm, '_generate', return_value="This is a Phi model description"):
+        
+        result = llm.complete("Describe the image", image_documents=[image])
+        assert result.text is not None and result.text != ""
+        assert True  # Return True if we receive any response
+
+# Test for Florence with multiple images
+def test_florence_model_multiple_images():
+    llm = HuggingFaceMultiModal.from_model_name("microsoft/Florence-2-base")
+    image1 = ImageDocument(image_path="test_images/5cats.jpg")
+    image2 = ImageDocument(image_path="test_images/girl_rabbit.jpg")
+
+    with patch.object(llm, '_prepare_messages', return_value={'mock': 'inputs'}), \
+         patch.object(llm, '_generate', return_value="Florence caption with details"):
+
+        result = llm.complete("<DETAILED_CAPTION>", image_documents=[image1, image2])
+        assert result.text is not None and result.text != ""
+        assert True  # Return True if we receive any response
+
+# Test for Qwen with multiple images
+def test_qwen_model_multiple_images():
+    llm = HuggingFaceMultiModal.from_model_name("Qwen/Qwen2-VL-2B-Instruct")
+    image1 = ImageDocument(image_path="test_images/2dogs.jpg")
+    image2 = ImageDocument(image_path="test_images/man_read.jpg")
+
+    with patch.object(llm, '_prepare_messages', return_value={'mock': 'inputs'}), \
+         patch.object(llm, '_generate', return_value="Qwen model response for images"):
+
+        result = llm.complete("Describe the images", image_documents=[image1, image2])
+        assert result.text is not None and result.text != ""
+        assert True  # Return True if we receive any response


Code review comments:
diff_hunk: @@ -0,0 +1,84 @@
+# LlamaIndex Multi_Modal_Llms Integration: Huggingface
+
+This project integrates Hugging Face's multimodal language models into the LlamaIndex framework, enabling advanced multimodal capabilities for various AI applications.
+
+## Features
+
+- Seamless integration of Hugging Face multimodal models with LlamaIndex
+- Support for multiple state-of-the-art vision-language models and their **finetunes**:
+  - [Qwen2 Vision](https://huggingface.co/collections/Qwen/qwen2-vl-66cee7455501d7126940800d)
+  - [Florence2](https://huggingface.co/collections/microsoft/florence-6669f44df0d87d9c3bfb76de)
+  - [Phi-3.5 Vision](https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3)
+  - [PaLI-Gemma](https://huggingface.co/collections/google/paligemma-release-6643a9ffbf57de2ae0448dda)
+- Easy-to-use interface for multimodal tasks like image captioning and visual question answering
+- Configurable model parameters for fine-tuned performance
+
+---
+Author of that Integration [GitHub](https://github.com/g-hano) | [LinkedIn](https://www.linkedin.com/in/chanyalcin/) | [Email](mcihan.yalcin@outlook.com)
+---
+
+## Installation
+
+```bash
+pip install llama-index transformers torch pillow
path: llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/README.md
text: @user1:
shouldn't be just need `pip install llama-index-multi-modal-llms-huggingface` ?

diff_hunk: @@ -0,0 +1,84 @@
+# LlamaIndex Multi_Modal_Llms Integration: Huggingface
+
+This project integrates Hugging Face's multimodal language models into the LlamaIndex framework, enabling advanced multimodal capabilities for various AI applications.
+
+## Features
+
+- Seamless integration of Hugging Face multimodal models with LlamaIndex
+- Support for multiple state-of-the-art vision-language models and their **finetunes**:
+  - [Qwen2 Vision](https://huggingface.co/collections/Qwen/qwen2-vl-66cee7455501d7126940800d)
+  - [Florence2](https://huggingface.co/collections/microsoft/florence-6669f44df0d87d9c3bfb76de)
+  - [Phi-3.5 Vision](https://huggingface.co/collections/microsoft/phi-3-6626e15e9585a200d2d761e3)
+  - [PaLI-Gemma](https://huggingface.co/collections/google/paligemma-release-6643a9ffbf57de2ae0448dda)
+- Easy-to-use interface for multimodal tasks like image captioning and visual question answering
+- Configurable model parameters for fine-tuned performance
+
+---
+Author of that Integration [GitHub](https://github.com/g-hano) | [LinkedIn](https://www.linkedin.com/in/chanyalcin/) | [Email](mcihan.yalcin@outlook.com)
+---
+
+## Installation
+
+```bash
+pip install llama-index transformers torch pillow
+```
+
+Make sure to set your Hugging Face API token as an environment variable:
+
+```bash
+export HF_TOKEN=your_huggingface_token_here
+```
+
+## Usage
+
+Here's a basic example of how to use the Hugging Face multimodal integration:
+
+```python
+from llama_index.multi_modal_llms import HuggingFaceMultiModal
path: llama-index-integrations/multi_modal_llms/llama-index-multi-modal-llms-huggingface/README.md
text: @user1:
I think the real import is `from llama_index.multi_modal_llms.huggingface import HuggingFaceMultiModal`

@author:
ye you are right, I fixed the issue. sorry its my very first time contributing.