Despliegue e ingeniería de producción de AI Agent

El despliegue de producción involucra múltiples aspectos como fiabilidad, escalabilidad y control de costos.

Las prácticas de ingeniería aseguran que el sistema funcione de manera estable y sea fácil de mantener.


Arquitectura de despliegue de producción

El entorno de producción impone mayores requisitos al sistema.

Es necesario considerar múltiples aspectos como fiabilidad, escalabilidad y alertas de monitoreo.

Modos de despliegue

Despliegue en un solo nodo

Adecuado para entornos de desarrollo y prueba.

Es simple y fácil de desplegar, pero no puede manejar tráfico de nivel de producción.

Despliegue distribuido

Adecuado para entornos de producción, requiere considerar múltiples aspectos.

Balanceo de carga: distribuye las solicitudes a múltiples instancias.

Descubrimiento de servicios: gestiona dinámicamente la lista de instancias.

Gestión de estado: maneja problemas de consistencia de estado distribuido.

Manejo de tolerancia a fallos: un fallo de un solo punto no afecta al servicio general.

Despliegue en contenedores

Ejemplo de Dockerfile

# Basado en la imagen de Python 3.11
FROM python:3.11-slim

# Establecer el directorio de trabajo
WORKDIR /app

# Instalar dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar el código de la aplicación
COPY . .

# Crear un usuario no root (consideración de seguridad)
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser

# Exponer el puerto
EXPOSE 8000

# Comando de inicio
CMD ["python", "agent.py"]

Despliegue en Kubernetes

Configuración de Deployment de Kubernetes

span style="color: green;">
apiVersion: apps/v1
kind
: Deployment
metadata
:
  name
: ai-agent
  labels
:
    app
: ai-agent
spec
:
 # Número de réplicas
  replicas
: 3
  selector
:
    matchLabels
:
      app
: ai-agent
  template
:
    metadata
:
      labels
:
        app
: ai-agent
    spec
:
      containers
:
      - name
: agent
        image
: your-registry/ai-agent:latest
        ports
:
        - containerPort
: 8000
        # Límites de recursos
        resources
:
          limits
:
            memory
: "2Gi"
            cpu
: "1"
          requests
:
            memory
: "1Gi"
            cpu
: "0.5"
        # Verificación de salud
        livenessProbe
:
          httpGet
:
            path
: /health
            port
: 8000
          initialDelaySeconds
: 10
          periodSeconds
: 30
        readinessProbe
:
          httpGet
:
            path
: /ready
            port
: 8000
          initialDelaySeconds
: 5
          periodSeconds
: 10
---
apiVersion
: v1
kind
: Service
metadata
:
  name
: ai-agent-service
spec
:
  selector
:
    app
: ai-agent
  ports
:
  - port
: 80
    targetPort
: 8000
  type
: LoadBalancer

Control de costos

El costo de un sistema de agentes proviene principalmente de las llamadas a la API de LLM.

Optimizar costos es un tema importante en el despliegue de producción.

Estrategia de optimización de tokens

Compresión de prompts: simplifica los prompts, reduciendo texto innecesario.

Truncamiento de contexto: conserva solo el contenido de contexto clave.

Caché de respuestas: almacena en caché las respuestas para consultas iguales o similares.

Implementación de código

Implementación de agente de optimización de costos

import hashlib
import json
from functools import lru_cache

class CostOptimizedAgent:
    """
Agente de optimización de costos
Reduce el costo de las llamadas a la API mediante caché y compresión.
    """

   
    def __init__(self, base_agent, cache, embedder=None):
        # Agente base
        self.base_agent = base_agent
        # Almacenamiento de caché
        self.cache = cache
        # Embedder (para coincidencia de caché por similitud)
        self.embedder = embedder
   
    def process(self, request):
        """
Procesa la solicitud, incluyendo la lógica de optimización de costos.
        """

        # Generar huella de solicitud
        request_fingerprint = self.generate_fingerprint(request)
       
        # Comprobar caché exacta
        cached_result = self.cache.get(request_fingerprint)
        if cached_result:
            return {
                **cached_result,
                "from_cache": True
            }
       
        # Si hay embedder, comprobar caché de similitud semántica
        if self.embedder:
            similar = self.find_similar_cached(request)
            if similar:
                return {
                    **similar,
                    "from_cache": True,
                    "similar_to": similar.get("request_id")
                }
       
        # Ejecutar la solicitud
        result = self.base_agent.process(request)
       
        # Almacenar en caché el resultado
        self.cache.set(
            request_fingerprint,
            result,
            ttl=3600  # Expira en 1 hora
        )
       
        return {
            **result,
            "from_cache": False
        }
   
    def generate_fingerprint(self, request):
        """
Generación de huella de solicitud
Se utiliza para la coincidencia exacta de caché.
        """

        content = json.dumps(request, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()
   
    def find_similar_cached(self, request, threshold=0.95):
        """
Buscar resultados de caché semánticamente similares.
Utiliza la similitud coseno de los vectores de embedding.
        """

        if not self.embedder:
            return None
       
        # Vectorizar la solicitud
        request_vector = self.embedder.embed([str(request)])[0]
       
        # Buscar solicitudes similares en la caché
        best_match = None
        best_similarity = 0
       
        for cached in self.cache.get_all():
            cached_vector = cached["vector"]
            similarity = cosine_similarity(request_vector, cached_vector)
           
            if similarity > best_similarity and similarity >= threshold:
                best_similarity = similarity
                best_match = cached
       
        return best_match


class ResponseCache:
    """
Caché de respuestas
Implementación simple de caché en memoria
En producción se puede usar Redis
    """

   
    def __init__(self):
        self.cache = {}
        self.timestamps = {}
   
    def get(self, key):
        """Obtener caché"""
        if key in self.cache:
            # Comprobar si ha expirado
            if self.is_expired(key):
                self.delete(key)
                return None
            return self.cache[key]
        return None
   
    def set(self, key, value, ttl=3600):
        """Establecer caché"""
        self.cache[key] = value
        self.timestamps[key] = time.time() + ttl
   
    def delete(self, key):
        """Eliminar caché"""
        if key in self.cache:
            del self.cache[key]
        if key in self.timestamps:
            del self.timestamps[key]
   
    def is_expired(self, key):
        """Comprobar si ha expirado"""
        if key not in self.timestamps:
            return True
        return time.time() > self.timestamps[key]
   
    def get_all(self):
        """Obtener todos los elementos de caché"""
        return list(self.cache.values())


def cosine_similarity(vec1, vec2):
    """Calcular la similitud coseno"""
    dot_product = sum(a * b for a, b in zip(vec1, vec2))
    norm1 = math.sqrt(sum(a * a for a in vec1))
    norm2 = math.sqrt(sum(b * b for b in vec2))
    return dot_product / (norm1 * norm2)

Streaming y asincronía

Respuesta en streaming

La respuesta en streaming reduce el tiempo de espera y mejora la experiencia del usuario.

No es necesario esperar la respuesta completa; el contenido generado se puede mostrar gradualmente.

Implementación de código

Agente de respuesta en streaming

import asyncio

class StreamingAgent:
    """
Agente que admite respuesta en streaming
Devuelve mientras genera, reduciendo el tiempo de espera.
    """

   
    def __init__(self, llm):
        self.llm = llm
   
    async def stream_generate(self, prompt):
        """
Generación de respuesta en streaming
Usa el patrón async generator
:yield: fragmento de texto generado
        """

        # Iniciar tarea de generación asíncrona
        async for chunk in self.llm.stream_generate(prompt):
            yield chunk
   
    async def process_stream(self, request):
        """
Procesar solicitudes de streaming
Retornar un generador asíncrono
        """

        prompt = self.build_prompt(request)
       
        # Retornar el generador
        async def generate():
            async for chunk in self.stream_generate(prompt):
                yield chunk
       
        return generate()


# Ejemplo de uso
async def main():
    agent = StreamingAgent(llm)
   
    # Iniciar generación en streaming
    async for token in agent.stream_generate("Explicar la computación cuántica"):
        # Imprimir mientras genera
        print(token, end="", flush=True)
    print()  # Salto de línea


# Ejecutar
asyncio.run(main())

Cola de tareas asíncronas

Para tareas de larga duración, se utiliza una cola asíncrona para procesarlas.

El usuario recibe una respuesta inmediata tras enviar la tarea, y esta se ejecuta de forma asíncrona en segundo plano.

Implementación de cola de tareas asíncronas

import asyncio
from queue import Queue
from threading import Thread
import uuid

class AsyncAgent:
    """
Agente asíncrono
Utiliza una cola de tareas para procesar tareas de larga duración.
    """

   
    def __init__(self, agent, task_queue):
        # Agente base
        self.agent = agent
        # Cola de tareas
        self.task_queue = task_queue
        # Almacenamiento de resultados
        self.results = {}
        # Iniciar hilo de trabajo en segundo plano
        self.worker_thread = Thread(target=self.process_queue, daemon=True)
        self.worker_thread.start()
   
    async def submit(self, task):
        """
Enviar tarea
Retornar inmediatamente el ID de la tarea
        """

        # Generar un ID de tarea único
        task_id = str(uuid.uuid4())
       
        # Agregar a la cola
        await self.task_queue.enqueue({
            "id": task_id,
            "task": task,
            "status": "pending",
            "created_at": time.time()
        })
       
        return task_id
   
    async def get_result(self, task_id):
        """
Obtener el resultado de la tarea
No bloqueante
        """

        if task_id in self.results:
            return self.results[task_id]
       
        # Comprobar el estado de la tarea
        status = await self.task_queue.get_status(task_id)
       
        if status is None:
            return None  # La tarea no existe
       
        if status == "pending" or status == "processing":
            return {
                "status": status,
                "result": None
            }
       
        return None
   
    def process_queue(self):
        """
Hilo de trabajo en segundo plano
Toma una tarea de la cola y la ejecuta.
        """

        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
       
        while True:
            task = loop.run_until_complete(self.task_queue.dequeue())
           
            if task:
                # Actualizar el estado a 'en proceso'
                loop.run_until_complete(
                    self.task_queue.update_status(task["id"], "processing")
                )
               
                try:
                    # Ejecutar la tarea
                    result = self.agent.process(task["task"])
                   
                    # Guardar el resultado
                    self.results[task["id"]] = {
                        "status": "completed",
                        "result": result,
                        "completed_at": time.time()
                    }
                   
                    loop.run_until_complete(
                        self.task_queue.update_status(task["id"], "completed")
                    )
                except Exception as e:
                    self.results[task["id"]] = {
                        "status": "failed",
                        "error": str(e)
                    }
                   
                    loop.run_until_complete(
                        self.task_queue.update_status(task["id"], "failed")
                    )


class TaskQueue:
    """Implementación simple de cola de tareas"""
   
    def __init__(self):
        self.queue = Queue()
        self.statuses = {}
   
    async def enqueue(self, task):
        """Agregar una tarea a la cola"""
        self.queue.put(task)
        self.statuses[task["id"]] = "pending"
   
    async def dequeue(self):
        """Tomar una tarea de la cola"""
        if not self.queue.empty():
            return self.queue.get()
        return None
   
    async def get_status(self, task_id):
        """Obtener el estado de la tarea"""
        return self.statuses.get(task_id)
   
    async def update_status(self, task_id, status):
        """Actualizar el estado de la tarea"""
        self.statuses[task_id] = status

Diseño de microservicios

Dividir el sistema de agentes en múltiples servicios independientes mejora la mantenibilidad y la escalabilidad.

División de servicios

Servicio Responsabilidad
Puerta de enlace de API Entrada unificada, autenticación y limitación de tasa, enrutamiento y reenvío.
Servicio de agente Lógica central, razonamiento y planificación.
Servicio de herramientas Integración con API externas, invocación de herramientas.
Servicio de almacenamiento Base de conocimiento, gestión de estado, caché.
Servicio de monitoreo Recopilación de registros, monitoreo de métricas, alertas.

Comunicación entre servicios

Comunicación síncrona: HTTP/gRPC, utilizado para solicitudes y respuestas en tiempo real.

Comunicación asíncrona: cola de mensajes, utilizada para operaciones que consumen tiempo y notificaciones de eventos.


Resumen del capítulo

Este capítulo presenta las prácticas clave del despliegue de producción y la ingeniería.

Arquitectura de despliegue de producciónDesde un solo nodo hasta un sistema distribuido, expandiéndose gradualmente.

Despliegue en contenedoresUsa Docker y Kubernetes.

Control de costosReduce costos mediante caché y optimización de tokens.

Streaming y asincroníaMejora la experiencia del usuario y el throughput del sistema.

Diseño de microserviciosMejora la mantenibilidad y escalabilidad del sistema.

El despliegue de producción requiere considerar de manera integral múltiples aspectos como fiabilidad, rendimiento y costos.

Se recomienda comenzar a pequeña escala e ir aumentando la complejidad gradualmente.

Otras extensiones