# Usar contenedores para el desarrollo de IA generativa


## Requisitos previos

Completa [Contenedorizar una aplicación de IA generativa](/guides/genai-pdf-bot/develop/containerize/).

## Descripción general

En esta sección, aprenderás cómo configurar un entorno de desarrollo para acceder a todos los servicios que necesita tu aplicación de inteligencia artificial generativa (GenAI). Esto incluye:

- Agregar una base de datos local
- Agregar un servicio de LLM local o remoto

> [!NOTE]
>
> Puedes ver más ejemplos de aplicaciones de GenAI contenedorizadas en las aplicaciones de demostración de [GenAI Stack](https://github.com/docker/genai-stack).

## Agregar una base de datos local

Puedes utilizar contenedores para configurar servicios locales, como una base de datos. En esta sección, actualizarás el archivo `compose.yaml` para definir un servicio de base de datos. Además, especificarás un archivo de variables de entorno para cargar la información de conexión de la base de datos en lugar de tener que introducirla manualmente cada vez.

Para ejecutar el servicio de base de datos:

1. En el directorio del repositorio clonado, cambia el nombre del archivo `env.example` a `.env`.
   Este archivo contiene las variables de entorno que utilizarán los contenedores.
2. En el directorio del repositorio clonado, abre el archivo `compose.yaml` en un IDE o editor de texto.
3. En el archivo `compose.yaml`, agrega lo siguiente:
   - Agrega instrucciones para ejecutar una base de datos Neo4j
   - Especifica el archivo de entorno en el servicio del servidor para pasar las variables de entorno para la conexión

   A continuación se muestra el archivo `compose.yaml` actualizado. Se han eliminado todos los comentarios.

   ```yaml{hl_lines=["7-23"]}
   services:
     server:
       build:
         context: .
       ports:
         - 8000:8000
       env_file:
         - .env
       depends_on:
         database:
           condition: service_healthy
     database:
       image: neo4j:5.11
       ports:
         - "7474:7474"
         - "7687:7687"
       environment:
         - NEO4J_AUTH=${NEO4J_USERNAME}/${NEO4J_PASSWORD}
       healthcheck:
         test: ["CMD-SHELL", "wget --no-verbose --tries=1 --spider localhost:7474 || exit 1"]
         interval: 5s
         timeout: 3s
         retries: 5
   ```

   > [!NOTE]
   >
   > Para obtener más información sobre Neo4j, consulta la [imagen oficial de Docker para Neo4j](https://hub.docker.com/_/neo4j).

4. Ejecuta la aplicación. Dentro del directorio `docker-genai-sample`, ejecuta el siguiente comando en una terminal.

   ```console
   $ docker compose up --build
   ```

5. Accede a la aplicación. Abre un navegador y visualiza la aplicación en [http://localhost:8000](http://localhost:8000). Deberías ver una aplicación básica de Streamlit. Ten en cuenta que hacer preguntas a un PDF provocará que la aplicación falle porque el servicio de LLM especificado en el archivo `.env` aún no se está ejecutando.

6. Detén la aplicación. En la terminal, presiona `ctrl`+`c` para detener la aplicación.

## Agregar un servicio de LLM local o remoto

La aplicación de muestra es compatible tanto con [Ollama](https://ollama.ai/) como con [OpenAI](https://openai.com/). Esta guía proporciona instrucciones para los siguientes escenarios:

- Ejecutar Ollama en un contenedor
- Ejecutar Ollama fuera de un contenedor
- Usar OpenAI

Aunque todas las plataformas pueden utilizar cualquiera de los escenarios anteriores, el rendimiento y el soporte de GPU pueden variar. Puedes utilizar las siguientes pautas para ayudarte a elegir la opción adecuada:

- Ejecuta Ollama en un contenedor si estás en Linux (usando una instalación nativa de Docker Engine) o Windows 10/11 (usando Docker Desktop), tienes una GPU compatible con CUDA y tu sistema tiene al menos 8 GB de RAM.
- Ejecuta Ollama fuera de un contenedor si estás en una Mac con arquitectura Apple silicon.
- Utiliza OpenAI si los dos escenarios anteriores no se aplican en tu caso.

Elige una de las siguientes opciones para tu servicio de LLM.

**Ejecutar Ollama en un contenedor**



Al ejecutar Ollama en un contenedor, debes tener una GPU compatible con CUDA. Aunque puedes ejecutar Ollama en un contenedor sin una GPU compatible, es posible que el rendimiento no sea el adecuado. Solo Linux y Windows 11 admiten el acceso de GPU a los contenedores.

Para ejecutar Ollama en un contenedor y proporcionar acceso a la GPU:

1. Instala los requisitos previos.
   - Para Docker Engine en Linux, instala [NVIDIA Container Toolkit](https://github.com/NVIDIA/nvidia-container-toolkit).
   - Para Docker Desktop en Windows 10/11, instala el [controlador de NVIDIA más reciente](https://www.nvidia.com/Download/index.aspx) y asegúrate de estar utilizando el [backend WSL2](/desktop/features/wsl/#turn-on-docker-desktop-wsl-2)
2. Agrega el servicio de Ollama y un volumen en tu `compose.yaml`. A continuación se muestra el `compose.yaml` actualizado:

   ```yaml {hl_lines=["24-38"]}
   services:
     server:
       build:
         context: .
       ports:
         - 8000:8000
       env_file:
         - .env
       depends_on:
         database:
           condition: service_healthy
     database:
       image: neo4j:5.11
       ports:
         - "7474:7474"
         - "7687:7687"
       environment:
         - NEO4J_AUTH=${NEO4J_USERNAME}/${NEO4J_PASSWORD}
       healthcheck:
         test:
           [
             "CMD-SHELL",
             "wget --no-verbose --tries=1 --spider localhost:7474 || exit 1",
           ]
         interval: 5s
         timeout: 3s
         retries: 5
     ollama:
       image: ollama/ollama:latest
       ports:
         - "11434:11434"
       volumes:
         - ollama_volume:/root/.ollama
       deploy:
         resources:
           reservations:
             devices:
               - driver: nvidia
                 count: all
                 capabilities: [gpu]
   volumes:
     ollama_volume:
   ```

   > [!NOTE]
   >
   > Para obtener más detalles sobre las instrucciones de Compose, consulta [Activar el acceso a la GPU con Docker Compose](/compose/how-tos/gpu-support/).

3. Agrega el servicio `ollama-pull` a tu archivo `compose.yaml`. Este servicio utiliza la imagen `docker/genai:ollama-pull`, basada en el archivo [pull_model.Dockerfile](https://github.com/docker/genai-stack/blob/main/pull_model.Dockerfile) de GenAI Stack. El servicio descargará automáticamente el modelo para tu contenedor de Ollama. A continuación se muestra la sección actualizada del archivo `compose.yaml`:

   ```yaml {hl_lines=["12-17"]}
   services:
     server:
       build:
         context: .
       ports:
         - 8000:8000
       env_file:
         - .env
       depends_on:
         database:
           condition: service_healthy
         ollama-pull:
           condition: service_completed_successfully
     ollama-pull:
       image: docker/genai:ollama-pull
       env_file:
         - .env
     # ...
   ```

**Ejecutar Ollama fuera de un contenedor**



Para ejecutar Ollama fuera de un contenedor:

1. [Instala](https://github.com/jmorganca/ollama) y ejecuta Ollama en tu máquina host.
2. Actualiza el valor de `OLLAMA_BASE_URL` en tu archivo `.env` a `http://host.docker.internal:11434`.
3. Descarga el modelo en Ollama usando el siguiente comando:
   ```console
   $ ollama pull llama2
   ```

**Usar OpenAI**



> [!IMPORTANT]
>
> El uso de OpenAI requiere una [cuenta de OpenAI](https://platform.openai.com/login). OpenAI es un servicio alojado por terceros y pueden aplicarse cargos.

1. Actualiza el valor de `LLM` en tu archivo `.env` a `gpt-3.5`.
2. Descomenta y actualiza el valor de `OPENAI_API_KEY` en tu archivo `.env` con tu [clave de API de OpenAI](https://help.openai.com/en/articles/4936850-where-do-i-find-my-api-key).



## Ejecutar tu aplicación de GenAI

En este punto, tienes los siguientes servicios en tu archivo de Compose:

- Servicio `server` para tu aplicación de GenAI principal
- Servicio `database` para almacenar vectores en una base de datos Neo4j
- (opcional) Servicio `ollama` para ejecutar el LLM
- (opcional) Servicio `ollama-pull` para descargar automáticamente el modelo para el servicio de Ollama

Para ejecutar todos los servicios, ejecuta el siguiente comando en tu directorio `docker-genai-sample`:

```console
$ docker compose up --build
```

Si tu archivo de Compose incluye el servicio `ollama-pull`, puede tardar varios minutos en descargar el modelo. El servicio `ollama-pull` actualizará continuamente la consola con su estado. Después de descargar el modelo, el contenedor del servicio `ollama-pull` se detendrá y podrás acceder a la aplicación.

Una vez que la aplicación esté en funcionamiento, abre un navegador y accede a ella en [http://localhost:8000](http://localhost:8000).

Sube un archivo PDF, por ejemplo la [hoja de trucos de la CLI de Docker](https://docs-docker.esdocu.com/get-started/docker_cheatsheet.pdf), y haz una pregunta sobre el PDF.

Dependiendo de tu sistema y del servicio de LLM que hayas elegido, puede tardar varios minutos en responder. Si estás usando Ollama y el rendimiento no es adecuado, intenta usar OpenAI.

## Resumen

En esta sección, aprendiste cómo configurar un entorno de desarrollo para proporcionar acceso a todos los servicios que necesita tu aplicación de GenAI.

Información relacionada:

- [Referencia de Dockerfile](/../reference/dockerfile/)
- [Referencia del archivo de Compose](/reference/compose-file/)
- [Imagen de Docker de Ollama](https://hub.docker.com/r/ollama/ollama)
- [Imagen oficial de Docker para Neo4j](https://hub.docker.com/_/neo4j)
- [Aplicaciones de demostración de GenAI Stack](https://github.com/docker/genai-stack)

## Siguientes pasos

Consulta más ejemplos de aplicaciones de GenAI en las [aplicaciones de demostración de GenAI Stack](https://github.com/docker/genai-stack).

