Los chatbots de IA se han convertido en una herramienta esencial para empresas y organizaciones. Pero la mayoría de las soluciones de chatbot dependen de modelos basados en la nube que introducen latencia, limitaciones de API y, quizás lo más importante, problemas de privacidad. Qué pasaría si pudieras ejecutar un chatbot de IA completamente en tu máquina y seguir conservando el historial de conversaciones con una plataforma de datos con todas las funciones?
En este post, vamos a caminar a través de la creación de un chatbot AI auto-alojado utilizando Docker Model Runner, una nueva característica de Docker que le permite ejecutar modelos en contenedores a nivel local para la inferencia y más, y Couchbase Capella para almacenar, recuperar y buscar a través de las conversaciones. El resultado es un chatbot rápido, privado y flexible que tú controlas.
¿Listo para empezar? ¡Pongámonos en marcha!
Configuración de Docker Model Runner
En primer lugar, vamos a asegurarnos de que tu versión de Docker Desktop y CLI está actualizada para que tengas disponible la función Model Runner. Para ello, ejecute estado del modelo docker desde su terminal. Si tiene éxito, verá un mensaje de éxito emitido que Docker Model Runner se está ejecutando. Si no lo tienes, entonces necesitas primero obtener la última versión de Docker e instalarla. Después de actualizar Docker, puede ejecutar ese comando de nuevo y debería funcionar.
Una vez que lo hayas hecho, utilizarás Docker Model Runner para extraer la imagen del contenedor con el modelo Llama 3.2 y hacerla disponible localmente:
docker model pull ai/llama3.3
Puede comprobar que ha descargado correctamente el modelo Llama 3.2 ejecutando lista de modelos docker y verá el modelo disponible para su uso:
{"object":"list","data":[{"id":"ai/llama3.3","object":"model","created":1741794281,"owned_by":"docker"}]}
¿Quieres probarlo? Abrir el modelo en modo interactivo es muy fácil. Sólo tienes que ejecutar docker model run ai/llama3.3 desde la línea de comandos y entrará en modo interactivo:
Modo de chat interactivo iniciado. Escribe '/bye' para salir.
>
Ahora que ya tienes Llama 3.2 descargado y listo para usar, es hora de crear una aplicación backend sencilla que aproveche el modelo para un chatbot de IA autoalojado.
Creación del chatbot
La aplicación que creará realizará las siguientes tareas:
-
- Ejecute Llama 3.2 localmente a través de la aplicación
docker model runComando CLI - Enviar mensajes de usuario como avisos al modelo
- Almacenar el historial de chat en Couchbase Capella
- Recuperar chats anteriores
- Ejecute Llama 3.2 localmente a través de la aplicación
Su aplicación tendrá todas las características y estará lista para usar inmediatamente desde su consola como un robusto chatbot impulsado por IA. El código que construimos juntos aquí le proporcionará la base para refactorizarlo de acuerdo a cualquier necesidad que tenga. Tal vez, usted desea convertirlo en un backend para una aplicación web. Unas pocas modificaciones será todo lo que se requiere para hacer eso posible.
La aplicación requiere un par de dependencias así que desde el directorio del proyecto ejecute npm install couchbase readline-sync. Usamos el SDK de Couchbase Node.js para interactuar con nuestro almacén de datos Couchbase Capella, y usamos readline-sync para que la aplicación interactúe con el usuario desde el terminal.
Asegúrese de haber configurado un bucket en Capella para almacenar los datos del chat, y de tener a mano sus credenciales de Capella. Como siempre, no guarde sus credenciales en ningún control de versiones. Utilice variables de entorno para el desarrollo local para mantener sus credenciales seguras y no en manos públicas.
Estamos construyendo cuatro funciones en nuestra aplicación:
-
askAIpara encapsular el proceso de alimentación del mensaje a nuestro modelo de IA ejecutado localmentestoreChatpara enviar el historial de chat a CapellafetchChatHistorypara recuperar los chatsprincipalpara actuar como interfaz principal de la aplicación
Empecemos por el principal que envolverá todo lo demás. Esta función creará un bucle del que el usuario podrá salir en cualquier momento ofreciendo una experiencia de chat continua:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
async función principal() { const { grupo, colección } = await connectToCouchbase(); consola.registro("Chatbot de IA autoalojado (Llama 3.2 + Capella)"); consola.registro("Escribe tu mensaje a continuación. Escribe 'historial' para ver chats anteriores o 'salir' para salir.\n"); mientras que (verdadero) { const userMessage = readlineSync.pregunta("> "); si (userMessage.toLowerCase() === "salida") { consola.registro("¡Adiós!"); romper; } si (userMessage.toLowerCase() === "historia") { const historia = await fetchChatHistory(grupo); consola.registro("\n📜 Historial de Chat:"); historia.paraCada((chat) => { consola.registro(`🧑 ${chat.usuario}\n🤖 ${chat.respuesta}\n`); }); continuar; } consola.registro("🤖 Pensando..."); const aiResponse = await askAI(userMessage); consola.registro(`🤖 ${aiResponse}\n`); await storeChat(colección, userMessage, aiResponse); } } |
Como puede ver, hemos introducido una funcionalidad construida sobre el almacén de datos de Capella, a saber, la capacidad de recuperar dentro del propio chat el historial de chat anterior. Esto podría ser útil para que un usuario recupere su contexto de chat cada vez que inicie una nueva sesión.
Ahora que tenemos el principal vamos a crear las funciones de apoyo que invoca, empezando por la función askAI función:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
async función askAI(consulte) { devolver nuevo Promesa((resolver, rechace) => { exec( `docker modelo ejecute ai/llama3.3 "${prompt}"`, (error, stdout, stderr) => { si (error) { consola.error(`Error corriendo modelo: ${error.mensaje}`); rechace(error); } si (stderr) { consola.error(`Docker stderr: ${stderr}`); } resolver(stdout.recortar()); // Devolver respuesta AI } ); }); } |
A continuación, el storeChat función:
|
1 2 3 4 5 6 7 8 9 |
async función storeChat(colección, userMessage, aiResponse) { const chatDoc = { usuario: userMessage, respuesta: aiResponse, marca de tiempo: nuevo Fecha().toISOString(), }; await colección.upsert(`chat_${Fecha.ahora()}`, chatDoc); } |
Por último, el fetchChatHistory función:
|
1 2 3 4 5 6 7 8 9 |
async función fetchChatHistory(grupo, límite = 5) { const consulta = ` SELECCIONE usuario, respuesta, marca de tiempo DESDE `chatbot` PEDIR POR marca de tiempo DESC LÍMITE ${límite}; `; const resultado = await grupo.consulta(consulta); devolver resultado.filas; } |
Una vez que haya terminado con las funciones, asegúrese de añadir requiere al principio del archivo, y para crear una conexión con el clúster Couchbase Capella:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
const { exec } = requiere("proceso_niño"); const readlineSync = requiere("readline-sync"); const couchbase = requiere("couchbase"); requiere("dotenv").config(); async función connectToCouchbase() { pruebe { const grupo = await couchbase.conecte(COUCHBASE_URL, { nombre de usuario: COUCHBASE_USERNAME, contraseña: COUCHBASE_PASSWORD, }); const cubo = grupo.cubo("chatbot"); const colección = cubo.defaultCollection(); consola.registro("Conectado a Couchbase Capella"); devolver { grupo, colección }; } captura (err) { consola.error("Error al conectar con Couchbase:", err); proceso.salida(1); } } |
Por último, no olvide añadir una línea al final del script que llame a la función principal insertando main(); en la última línea.
Una vez finalizado, dispondrá de un chatbot de IA totalmente listo alojado en su propia máquina, conservando su privacidad y aprovechando simultáneamente Capella para el almacenamiento y la recuperación.
Uso de su chatbot de IA autoalojado
¡Tu propio chatbot está listo para usar! Cada consulta que le envíes será procesada únicamente de forma local en tu máquina utilizando el modelo Llama 3.2. No se enviará nada a ningún proveedor de IA de forma remota.
Si estás listo para darle una vuelta, hazlo ejecutando lo siguiente:
node index.js # o como haya llamado a su archivo
Una vez que lo ejecutes, verás lo siguiente:
Conectado a Couchbase Capella
Chatbot AI autoalojado (Llama 3.2 + Capella)
Escribe tu mensaje a continuación. Escribe 'historial' para ver chats anteriores o 'salir' para salir.
>
Adelante, empieza a hacer preguntas y a interactuar con él. Aquí tienes un breve ejemplo de lo que puedes esperar ver:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Conectado a Couchbase Capella 🚀 Auto-Alojado en AI Chatbot (Llama 3.2 + Capella) Tipo su mensaje debajo de. Tipo Historia a ver pasado chats o salida a abandone. > Debería I envase a impermeable para Barcelona para a viaje allí en el fin de Marzo? Respuesta sólo con "sí" o "no". 🤖 Pensar... 🤖 Sí. > Envía un mensaje a me por qué I debe envase a impermeable para Barcelona en el fin de Marzo. Límite su responder a 15 palabras o menos. 🤖 Pensar... 🤖 Usted mayo necesita a impermeable como Marzo tiempo en Barcelona puede sea impredecible y lluvioso, arriba a 10C. > salida 👋 Adiós! |
Al usar la escalabilidad y seguridad de Couchbase Capella junto con el enfoque de privacidad de Docker Model Runner para ejecutar modelos de IA localmente, puedes crear aplicaciones de IA dinámicas que prioricen la privacidad del usuario. Ejecutar modelos en tu propia máquina también te ofrece una inferencia más rápida, control total sobre la personalización de las solicitudes, la capacidad de almacenar metadatos adicionales y la flexibilidad para ajustar el comportamiento de tu chatbot, todo dentro de tu propio entorno.
Esta combinación de Capella y Docker Model Runner le ofrece la velocidad, el control y la privacidad necesarios para crear aplicaciones de IA sin depender de API externas. Tanto si está creando un chatbot, analizando datos o ejecutando flujos de trabajo basados en IA, esta configuración garantiza que todo lo que cree será eficiente, escalable y estará totalmente bajo su control.
La única pregunta es: ¿qué va a construir?
-
- Conéctese con nuestra comunidad de desarrolladores ¡y muéstranos lo que estás construyendo!
