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
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
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 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
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
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