Blog
Despliegue de un sistema RAG multimodal con vLLM y Milvus

Despliegue de un sistema RAG multimodal con vLLM y Milvus

Nov 13, 20248 min read

Imagina que llevas meses ajustando tu aplicación de IA en torno a un LLM específico a través de un proveedor de API. Entonces, de repente, recibes un correo electrónico: "Estamos dejando obsoleto el modelo que está utilizando en favor de nuestra nueva versión". ¿Le suena familiar? Aunque los proveedores de API en la nube ofrecen la comodidad de capacidades de IA potentes y listas para usar, confiar únicamente en ellos también introduce varios riesgos significativos:

Falta de control: No tiene control sobre las versiones o actualizaciones de los modelos.
Imprevisibilidad**: Puede enfrentarse a cambios repentinos en el comportamiento o las capacidades del modelo.
Conocimiento limitado**: La visibilidad del rendimiento y los patrones de uso suele ser limitada.
Preocupación por la privacidad**: La privacidad de los datos puede ser un tema crítico, especialmente cuando se maneja información sensible.

¿Cuál es la solución? ¿Cómo recuperar el control? ¿Cómo puede mitigar estos riesgos al tiempo que mejora las capacidades de su sistema? La respuesta está en construir un sistema más robusto e independiente utilizando soluciones de código abierto.

Este blog le guiará en la creación de un RAG multimodal con Milvus y vLLM. Aprovechando la potencia de una base de datos vectorial de código abierto combinada con la inferencia LLM de código abierto, puedes diseñar un sistema capaz de procesar y comprender múltiples tipos de datos-texto, imágenes, audio e incluso vídeos. Este enfoque no sólo te permite controlar por completo la tecnología, sino que también garantiza un sistema potente y versátil que supera a las soluciones tradicionales basadas en texto.

Lo que construiremos: un RAG multimodal totalmente bajo su control

Vamos a construir un sistema RAG Multimodal utilizando Milvus y vLLM, ilustrando cómo puede autoalojar su LLM y obtener un control total sobre sus aplicaciones de IA. Nuestro tutorial le guiará a través de la creación de una aplicación Streamlit que demuestra el poder de la integración de múltiples tipos de datos. Esto es lo que cubriremos:

Procesar la entrada de vídeo extrayendo fotogramas y transcribiendo el audio
Almacenar e indexar eficientemente datos multimodales utilizando Milvus.
1. Utilizamos OpenAI CLIP para codificar las imágenes en incrustaciones que luego se pueden buscar con Milvus
2. Utilizamos el modelo Mistral Embedding para codificar el texto en incrustaciones.
1. Recuperar el contexto relevante basado en las consultas del usuario utilizando Milvus.
Generar respuestas utilizando Pixtral con vLLM, aprovechando tanto la comprensión visual como textual.

Al final de este tutorial, habrá desarrollado un sistema flexible y escalable totalmente bajo su control, y ya no tendrá que preocuparse por las obsoletas API o los cambios inesperados.

¿Qué es Milvus?

Milvus](https://milvus.io/docs/overview.md) es una base de datos vectorial de código abierto, de alto rendimiento y altamente escalable que puede almacenar, indexar y buscar datos no estructurados a escala de miles de millones a través de incrustaciones vectoriales de alta dimensión. Es perfecta para crear aplicaciones modernas de IA, como la generación aumentada de recuperación (RAG), la búsqueda semántica, la búsqueda multimodal y los sistemas de recomendación. Milvus se ejecuta eficientemente en diversos entornos, desde ordenadores portátiles hasta sistemas distribuidos a gran escala.

¿Qué es vLLM?

La idea central de vLLM (Virtual Large Language Model) es optimizar el servicio y la ejecución de LLMs utilizando técnicas eficientes de gestión de memoria. Estos son los aspectos clave:

Gestión de memoria optimizada: vLLM implementa técnicas avanzadas de asignación y gestión de memoria para aprovechar al máximo los recursos de hardware disponibles. Esta optimización ayuda a ejecutar eficientemente modelos lingüísticos de gran tamaño, evitando cuellos de botella de memoria que pueden entorpecer el rendimiento.
Procesamiento por lotes dinámico**: vLLM adapta el tamaño de los lotes y las secuencias en función de las capacidades de memoria y cálculo del hardware subyacente. Este ajuste dinámico mejora el rendimiento del procesamiento y minimiza la latencia durante la inferencia del modelo.
Diseño modular**: La arquitectura de vLLM es modular, lo que facilita su integración con diversos aceleradores de hardware. Esta modularidad también permite escalar fácilmente a través de múltiples dispositivos o clusters, haciéndolo altamente adaptable a diferentes escenarios de despliegue.
Utilización eficiente de los recursos**: vLLM optimiza el uso de recursos críticos como CPU, GPU y memoria. Esta eficiencia permite que el sistema admita modelos más grandes y gestione un mayor número de solicitudes simultáneas, lo que resulta esencial en entornos de producción en los que tanto la escalabilidad como el rendimiento son fundamentales.
Integración perfecta**: Diseñado para integrarse sin problemas con los marcos y bibliotecas de aprendizaje automático existentes, vLLM proporciona una interfaz fácil de usar. De este modo, los desarrolladores pueden implantar y gestionar fácilmente modelos lingüísticos de gran tamaño en diversas aplicaciones sin necesidad de realizar grandes reconfiguraciones.

Componentes principales de nuestro GAR multimodal

La aplicación RAG multimodal que estamos construyendo consta de los siguientes componentes clave:

vLLM es la biblioteca de inferencia que utilizaremos para la inferencia y el servicio del modelo multimodal Pixtral.
Koyeb](http://Koyeb.com)** proporciona la capa de infraestructura para nuestro despliegue, ofreciendo una plataforma sin servidor especializada para cargas de trabajo de IA. Con integración nativa de vLLM y gestión automatizada de recursos de GPU, facilita el despliegue de LLM manteniendo un rendimiento y escalabilidad de nivel de producción.
Pixtral](https://mistral.ai/news/pixtral-12b/)** de Mistral AI actúa como nuestro cerebro multimodal, combinando un codificador de visión de 400M parámetros con un decodificador multimodal de 12B parámetros. Esta arquitectura le permite procesar tanto imágenes como texto dentro de la misma ventana contextual.
Milvus](https://github.com/milvus-io/milvus)** proporciona la base de almacenamiento de vectores, gestionando eficazmente incrustaciones de diferentes modalidades. Su capacidad para manejar múltiples tipos de vectores y realizar una rápida búsqueda de similitudes lo hace perfecto para aplicaciones multimodales.

Figura- La arquitectura multimodal RAG.png](https://assets.zilliz.com/Figure_The_multimodal_RAG_architecture_3fd1ccb67e.png)

Figura: La arquitectura RAG multimodal

Primeros pasos

En primer lugar, vamos a instalar nuestras dependencias:

# Core LlamaIndex packages
pip install -U llama-index-vector-stores-milvus llama-index-multi-modal-llms-mistralai llama-index-embeddings-mistralai llama-index-multi-modal-llms-openai llama-index-embeddings-clip llama_index

# Procesamiento de vídeo y audio
pip install moviepy pytube pydub SpeechRecognition openai-whisper ffmpeg-python soundfile

# Procesamiento y visualización de imágenes
pip install torch torchvision matplotlib scikit-image git+https://github.com/openai/CLIP.git

# Utilidades e infraestructura
pip install pymilvus streamlit ftfy regex tqdm

Configuración del entorno

Empezaremos configurando nuestro entorno e importando las librerías necesarias:

import os
import base64
import json
from pathlib import Path
from dotenv import load_dotenv
from llama_index.core import Configuración
from llama_index.embeddings.mistralai import MistralAIEmbedding

# Cargar variables de entorno
load_dotenv()

# Configurar el modelo de incrustación por defecto
Settings.embed_model = MistralAIEmbedding(
    "mistral-embed",
    api_key=os.getenv("MISTRAL_API_KEY")
)

Proceso de vídeo

El corazón de nuestro sistema es la cadena de procesamiento de vídeo, que transforma el contenido de vídeo en bruto en datos que nuestro sistema RAG puede entender y procesar eficientemente.

def procesar_video(ruta_video: cadena, carpeta_salida: cadena, ruta_audio_salida: cadena) -> dict:
    # Crear directorio de salida si no existe
    Path(carpeta_salida).mkdir(parents=True, exist_ok=True)
    
    # Extraer fotogramas del vídeo
    video_to_images(ruta_vídeo, carpeta_salida)
    
    # Extraer y transcribir el audio
    video_to_audio(ruta_vídeo, ruta_audio_salida)
    datos_texto = audio_a_texto(ruta_audio_salida)
    
    # Guardar la transcripción
    with open(os.path.join(carpeta_salida, "salida_texto.txt"), "w") as file:
        file.write(datos_texto)
    
    os.remove(ruta_audio_salida)
    return {"Autor": "Autor de ejemplo", "Título": "Título de ejemplo", "Vistas": "1000000"}

Este pipeline descompone los vídeos en:

Fotogramas de imagen (extraídos a 0,2 FPS)
Transcripción de audio mediante Whisper
Metadatos sobre el vídeo

Construcción del índice vectorial

Utilizamos Milvus para almacenar nuestras incrustaciones multimodales. Así es como creamos nuestro índice:

def crear_índice(carpeta_salida: str):
    # Crear colecciones diferentes para texto e imágenes
    text_store = MilvusVectorStore(
        uri="milvus_local.db",
        nombre_colección="colección_texto",
        overwrite=True,
        dim=1024
    )
    
    image_store = MilvusVectorStore(
        uri="milvus_local.db",
        nombre_colección="colección_imágenes",
        overwrite=Verdadero,
        dim=512
    )
    
    storage_context = StorageContext.from_defaults(
        vector_store=almacén_de_textos,
        almacén_imagen=almacén_imagen
    )
    
    # Cargar e indexar documentos
    documentos = SimpleDirectoryReader(carpeta_salida).load_data()
    return MultiModalVectorStoreIndex.from_documents(
        documentos,
        storage_context=contexto_almacenamiento
    )

Procesamiento de consultas con Pixtral

Cuando un usuario hace una pregunta, necesitamos:

Recuperar el contexto relevante de nuestro almacén de vectores
Procesar la consulta con Pixtral utilizando tanto texto como imágenes.

Aquí está nuestra función de procesamiento de consultas:

def procesar_consulta_con_imagen(cadena_consulta, cadena_contexto, cadena_metadatos, documento_imagen):
    client = OpenAI(
        base_url=os.getenv("KOYEB_ENDPOINT"),
        api_key=os.getenv("KOYEB_TOKEN")
    )
    
    with open(ruta_imagen.documento.imagen, "rb") as archivo_imagen:
        image_base64 = base64.b64encode(image_file.read()).decode("utf-8")
    
    qa_tmpl_str = """
    Dada la información proporcionada, incluidas las imágenes pertinentes y el contexto recuperado
    del vídeo, responde de forma precisa y exacta a la consulta sin ningún conocimiento
    conocimiento previo adicional.
    ---------------------
    Contexto: {context_str}
    Metadatos: {str_metadatos}
    ---------------------
    Consulta: {query_str}
    Respuesta: """
    
    # Preparar mensajes para Pixtral
    mensajes = [
        {
            "rol": "usuario",
            "contenido": [
                {
                    "tipo": "text",
                    "texto": qa_tmpl_str.format(
                        context_str=contexto_str,
                        query_str=query_str,
                        metadata_str=metadata_str
                    )
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f "data:image/jpeg;base64,{image_base64}"
                    }
                },
            ],
        }
    ]
    
    completion = client.chat.completions.create(
        model="mistralai/Pixtral-12B-2409",
        mensajes=mensajes,
        max_tokens=300
    )
    return completion.choices[0].message.content

Creación de la interfaz Streamlit

Por último, creamos una interfaz fácil de usar con Streamlit:

def main():
    st.title("RAG MultiModal con Pixtral & Milvus")
    
    # Inicializar el estado de la sesión
    if 'index' not in st.session_state:
        st.session_state.index = None
        st.session_state.retriever_engine = None
        st.session_state.metadata = None
    
    # Entrada de vídeo
    ruta_vídeo = st.text_input("Introducir ruta de vídeo:")
    
    if video_path and not st.session_state.index:
        with st.spinner("Procesando vídeo..."):
            # Procesar vídeo y crear índice
            [... código de procesamiento ...]
    
    if st.session_state.index:
        st.subheader("Chatear con el vídeo")
        query = st.text_input("Haga una pregunta sobre el vídeo:")
        
        si query:
            with st.spinner("Generando respuesta..."):
                # Generar y mostrar respuesta
                [... código de tratamiento de la consulta ...]

if __name__ == "__main__":
    main()

Ejecutar la aplicación

Antes de iniciar la aplicación, asegúrese de tener:

Configurado sus variables de entorno en .env.
Instalado todas las dependencias necesarias

Luego lanza la aplicación:

streamlit ejecutar app.py

Verás la página de inicio donde puedes:

Subir vídeos para su procesamiento
Hacer preguntas sobre el contenido del vídeo
Leer las respuestas de Pixtral con los fotogramas de vídeo pertinentes

Figura- La interfaz de su aplicación RAG multimodal construida con Milvus y Pixtral.png](https://assets.zilliz.com/Figure_The_interface_of_your_multimodal_RAG_app_built_with_Milvus_and_Pixtral_34db5892ff.png)

Figura: La interfaz de su aplicación RAG multimodal construida con Milvus y Pixtral

A partir de ahora, puedes interactuar con el vídeo y, por ejemplo, aprender más sobre la Distribución Gaussiana.

Figura- Realizando la búsqueda multimodal.png

Figura: Realización de la búsqueda multimodal

Conclusión

En esta entrada de blog, hemos demostrado cómo construir un potente sistema RAG multimodal utilizando Milvus, Pixtral y vLLM. Mediante la combinación de las eficientes capacidades de almacenamiento vectorial de Milvus y la comprensión multimodal avanzada de Pixtral, hemos creado un sistema que puede procesar, comprender y responder a consultas sobre contenido de vídeo. Y este sistema está totalmente bajo su control.

Nos encantaría conocer tu opinión.

Si te gusta esta entrada de blog, por favor considere:

⭐ Darnos una estrella en GitHub
💬 Unirte a nuestra comunidad Milvus Discord para compartir tus experiencias
🔍 Explorando nuestro repositorio Bootcamp para ver más ejemplos de aplicaciones multimodales con Milvus

Actualizado el Mar 19, 2025

Stephen Batifol
Stephen Batifol is a Developer Advocate at Zilliz. He previously worked as a Machine Learning Engineer at Wolt, where he was working on the ML Platform and as a Data Scientist at Brevo. Stephen studied Computer Science and Artificial Intelligence. He enjoys dancing and surfing.

Contenido

Comienza Gratis, Escala Fácilmente

Prueba la base de datos vectorial completamente gestionada construida para tus aplicaciones GenAI.

Prueba Zilliz Cloud Gratis

Comparte este artículo

Sigue leyendo

How to Use Anthropic MCP Server with Milvus

Discover how Model Context Protocol (MCP) pairs with Milvus to eliminate AI integration hassles, enabling smarter agents with seamless data access and flexibility.

Zilliz Cloud BYOC Upgrades: Bring Enterprise-Grade Security, Networking Isolation, and More

Discover how Zilliz Cloud BYOC brings enterprise-grade security, networking isolation, and infrastructure automation to vector database deployments in AWS

Vector Databases vs. NewSQL Databases

Use a vector database for AI-powered similarity search; use a NewSQL database for scalable transactional workloads requiring strong consistency and relational capabilities.