Los agentes de IA representan la siguiente evolución de la inteligencia artificial y van más allá de las capacidades de los chatbots de IA tradicionales. Mientras que los chatbots destacan en la gestión de conversaciones sencillas, los agentes de IA van más allá al aprovechar múltiples modelos lingüísticos de gran tamaño (LLM) para realizar tareas complejas de varios pasos. Estos agentes pueden mantener el contexto a lo largo de las interacciones, adaptarse dinámicamente a la nueva información y tomar decisiones en tiempo real, ofreciendo soluciones más sofisticadas e inteligentes. LangGraph, una extensión de la biblioteca LangChain, permite el desarrollo de estos agentes avanzados mediante la introducción de flujos de trabajo cíclicos, lo que permite al agente ajustar continuamente sus acciones en función del estado evolutivo de una conversación o proceso.
En este tutorial, te guiaré en la creación e implementación de un agente de IA con LangGraph, LangServe y AWS Copilot. Crearemos un caso de uso del mundo real: un chatbot de atención al cliente para una empresa de paneles solares que no solo responde a las consultas de los clientes, sino que también calcula el ahorro de energía en función de los datos introducidos por el usuario. Al final, tendrá un agente de IA totalmente implementable que integra varios modelos de IA y se escala sin problemas a través de AWS.
Todo el código de este tutorial está disponible en mi repositorio de GitHub, así que no dudes en seguirlo. También puedes ver mi video de YouTube donde te guío a través de todo el proceso.
Con eso, vamos a sumergirnos en la configuración del entorno y la preparación del agente de IA para el despliegue en el mundo real.
Tabla de contenidos
Configuración del entorno
Para empezar a construir y desplegar tu agente de IA, el primer paso es configurar el entorno en Visual Studio Code. Para ello, vamos a crear un entorno virtual Python para asegurar que todas las dependencias están perfectamente contenidas en el proyecto.
# create virtual environment
python -m venv env
# activate virtual environment
source env/bin/activate
# install required dependencies
pip install -r requirements.txt
Esto instalará todas las librerías necesarias para trabajar con LangGraph, LangServe, AWS, y otros paquetes relacionados.
Iniciando la Aplicación LangServe
En primer lugar, tenemos que configurar nuestra aplicación LangServe, que se encargará del despliegue de su agente de IA como una API. LangServe es una herramienta diseñada para desplegar cadenas y runnables LangChain como APIs REST. Se integra con FastAPI y utiliza Pydantic para la validación de datos, ofreciendo endpoints para manejar eficientemente las peticiones.
Paso 1: Crear la aplicación LangServe
En el directorio de tu proyecto, inicializa una nueva app LangServe ejecutando:
langchain serve new .
Este comando crea la estructura básica para tu aplicación LangServe, incluyendo los archivos y directorios necesarios. Antes de seguir adelante, es importante asegurarse de que todas las dependencias necesarias están correctamente instaladas. Como LangServe usa Poetry para la gestión de dependencias, lo usaremos para configurar e instalar los paquetes necesarios.
Paso 2: Configurar las dependencias de Poetry
Poetry simplifica la gestión de dependencias asegurando que todos los paquetes están correctamente instalados y mantenidos de forma estructurada. En la raíz del directorio de tu proyecto, encontrarás el archivo pyproject.toml. Actualízalo para incluir las siguientes dependencias:
[tool.poetry]
name = "ai-agent-deploy"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]
readme = "README.md"
packages = [
{ include = "app" },
]
[tool.poetry.dependencies]
python = ">=3.11,<3.13"
uvicorn = "^0.23.2"
langserve = {extras = ["server"], version = ">=0.0.30"}
pydantic = ">=2,<3"
langchain-core = ">=0.3.12,<0.4.0"
langgraph = ">=0.2.28,<0.3.0"
langchain = ">=0.3.3,<0.4.0"
langchain-aws = ">=0.2.2,<0.3.0"
langchain-community = ">=0.3.2,<0.4.0"
langchain-pinecone = ">=0.2.0,<0.3.0"
boto3 = ">=1.35.43,<1.36.0"
langchain-cli = ">=0.0.31,<0.1.0"
[tool.poetry.group.dev.dependencies]
langchain-cli = ">=0.0.15"
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"
A continuación, ejecuta el siguiente comando para instalar las dependencias:
poetry install
Con la configuración básica de LangServe completa y los paquetes necesarios instalados, ahora podemos pasar a construir el agente de IA usando LangGraph e integrarlo en la aplicación LangServe.
Creación del agente de IA
En este paso, crearemos un agente de IA que actúe como chatbot de atención al cliente para una empresa de paneles solares, respondiendo a consultas y calculando el ahorro energético potencial de los usuarios.
Definir el flujo de trabajo LangGraph
En el archivo server.py, utilizaremos LangGraph para crear la lógica que impulsa al agente de IA. LangGraph estructura sus flujos de trabajo usando nodos, aristas y estado:
- Nodes: Cada nodo representa un paso en el flujo de trabajo, como responder a las consultas de los clientes o calcular los ahorros.
- Edges: Conectan los nodos y definen el flujo de la conversación o el proceso de toma de decisiones.
- State: El estado mantiene el contexto de la conversación, haciendo un seguimiento de las entradas del usuario y las respuestas anteriores para garantizar que el agente pueda proporcionar respuestas pertinentes y coherentes a medida que avanza la interacción.
Puedes encontrar una explicación más detallada de la lógica del Agente AI en mi anterior artículo de Medium y en mi vídeo de YouTube.
En este tutorial, nos centraremos en la lógica para desplegar el agente de IA, más que en la implementación del agente de IA en sí. También se puede encontrar una versión completa del script server.py en mi repositorio de GitHub.
Inicializar la aplicación FastAPI
Comenzaremos inicializando la aplicación FastAPI, que gestionará las peticiones entrantes para el agente de IA.
# initiate FastAPI
app = FastAPI()
Esto configura la aplicación FastAPI, preparándola para servir de interfaz entre los usuarios y el agente de IA.
Definir la redirección de la raíz a los documentos de la API
A continuación, añadiremos una ruta que redirija automáticamente a los usuarios que visiten la raíz de la API (/) a la página de documentación de FastAPI (/docs), facilitando así la exploración de los puntos finales disponibles.
@app.get("/")
async def redirect_root_to_docs():
return RedirectResponse("/docs")Esto asegura que los usuarios puedan encontrar e interactuar fácilmente con la documentación de la API.
Inicializar la memoria y compilar el LangGraph
Para manejar el contexto de la conversación, inicializaremos la memoria para el agente de IA. Esto permite al agente recordar interacciones previas y responder de forma más inteligente en conversaciones de varios pasos. Luego compilaremos el flujo de trabajo LangGraph, integrando la memoria para retener el contexto a través de las interacciones.
memory = MemorySaver()
graph = builder.compile(checkpointer=memory)
Con esta configuración, el agente de IA puede ahora procesar las solicitudes conservando el contexto necesario de la conversación, lo que garantiza que proporciona respuestas significativas y coherentes a lo largo de la interacción.
Definir el modelo de petición con Pydantic
Para asegurarnos de que las peticiones entrantes siguen una estructura específica, utilizaremos Pydantic para definir el formato de datos esperado. Esto ayuda a la API a validar la entrada automáticamente, garantizando que sólo se acepten los datos que coincidan con los tipos correctos, como una cadena para la question y un número entero para thread_id. Si la entrada no cumple los criterios definidos, se generan mensajes de error claros.
class QuestionRequest(BaseModel):
question: str
thread_id: int
Al definir este modelo, garantizamos que cada petición se estructura correctamente, haciendo que la API sea más robusta y fácil de usar.
Añadir la ruta principal para ejecutar el agente de IA
Ahora que la estructura y los componentes están en su lugar, es el momento de implementar la funcionalidad principal mediante la definición de la ruta principal de la API. Esta ruta manejará las peticiones de los usuarios, procesará la entrada a través del agente de IA, y devolverá la respuesta apropiada.
Esto se hace mediante la creación de un controlador de peticiones POST para el punto final /generate. Los datos proporcionados en la solicitud -como la pregunta del usuario y el identificador del hilo- se validarán utilizando el modelo Pydantic que hemos definido anteriormente. La entrada validada se pasa al agente de IA, que la procesa utilizando su flujo de trabajo LangGraph. El resultado final se devuelve en formato JSON.
Así es como funciona:
@app.post("/generate")
async def generate_route(request: QuestionRequest):
print(request)
state = {"messages": [HumanMessage(content=request.question)]}
config = {"configurable": {"thread_id": request.thread_id}}
try:
outputs = []
for output in graph.stream(state, config):
print(output)
for key, value in output.items():
outputs.append({key: value})
return {"result": outputs}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))La ruta /generate acepta peticiones POST, con el cuerpo de la petición estructurado según el modelo Pydantic QuestionRequest (es decir, question e thread_id).
- Estado: El objeto de state se crea para incluir la pregunta del usuario, obtenida de la entrada de la solicitud, y se pasa al flujo de trabajo del agente de IA. Esto garantiza que el agente de IA procese correctamente la entrada del usuario.
- Config: El objeto config incluye el thread_id, lo que permite al agente de IA rastrear el contexto de la conversación utilizando la memoria.
A continuación, el agente de IA procesa el estado y la configuración utilizando el flujo de trabajo LangGraph:
- Procesamiento: El método graph.stream transmite la salida del flujo de trabajo del agente de IA en tiempo real, y cada salida se añade a la lista de outputs.
- Devolución: Después del procesamiento, las salidas se devuelven como una respuesta JSON al usuario. En caso de cualquier problema durante la ejecución, se genera un error HTTP 500 con un mensaje de error detallado.
Esta ruta es el principal punto de entrada para interactuar con el agente de IA. Una vez desplegado, los usuarios pueden enviar sus consultas, y el agente de IA responderá basándose en el flujo de trabajo definido en LangGraph.
Probando el Agente AI Localmente con LangServe
Ahora que hemos configurado el código, ejecutaremos la aplicación LangServe para probar el agente de IA localmente. LangServe proporciona la infraestructura para servir agentes basados en LangChain a través de una API REST. Así es como puedes ejecutarlo localmente y asegurarte de que todo funciona antes del despliegue.
Ejecutar LangServe
Primero, asegúrate de que tienes Docker ejecutándose, ya que LangServe depende de él para el despliegue.
En el directorio de tu proyecto, ejecuta el siguiente comando para iniciar la aplicación LangServe:
langchain serve
Este comando lanzará un servidor local alojando la API de tu agente AI. LangServe creará automáticamente un entorno utilizando Docker, y podrás acceder a tu API desde http://localhost:8000.
Acceder a la API
Una vez que el servidor esté funcionando, puedes abrir tu navegador y visitar http://localhost:8000/docs. Aquí verás la ruta POST /generate, que se utiliza para interactuar con el agente de IA. Puedes probar la API directamente desde esta página haciendo clic en la ruta, luego en «Try it out» y rellenando los campos requeridos (como la pregunta y el thread_id).
Ahora que ha probado el agente de IA localmente y ha confirmado que todo funciona según lo esperado, el siguiente paso es desplegarlo en la nube.
Implementación del agente de IA con AWS Copilot
Ahora que hemos probado con éxito el agente de IA a nivel local, es el momento de implementarlo para que se pueda acceder a él públicamente. En esta sección, utilizaremos AWS Copilot para implementar el agente de IA. AWS Copilot simplifica el proceso de implementación de aplicaciones en contenedores, como nuestro agente de IA que se ejecuta con LangServe, mediante la configuración automática de la infraestructura necesaria.
Paso 1: Configurar las credenciales de AWS
Antes de desplegar la aplicación, asegúrate de que tus credenciales de AWS están correctamente configuradas en tu máquina local. Necesitarás las claves de acceso de AWS, que se pueden configurar siguiendo las instrucciones de la documentación de AWS. Para confirmarlo, comprueba que tu directorio de inicio tiene una carpeta .aws que contiene tanto las credentials como los archivos de config. Estos archivos deberían almacenar de forma segura tu ID de clave de acceso y tu clave de acceso secreta.
Paso 2: Inicializar AWS Copilot
En el directorio de tu proyecto, ejecute el siguiente comando para inicializar AWS Copilot:
copilot init \
--app ai-agent \
--name ai-agent \
--type 'Load Balanced Web Service' \
--dockerfile './Dockerfile'
AWS Copilot creará varios componentes clave para su agente de IA:
- Elastic Load Balancer (ELB): El balanceador de carga distribuye el tráfico entrante entre varias instancias de su servicio para garantizar una alta disponibilidad y tolerancia a fallos. Esto significa que, a medida que crece el tráfico, el ELB puede distribuir la carga para evitar que una sola instancia se vea desbordada, garantizando un rendimiento y una escalabilidad sin problemas para su agente de IA.
- ECS (Elastic Container Service): ECS es un servicio de orquestación de contenedores totalmente gestionado que AWS utiliza para implementar y administrar aplicaciones en contenedores. En este caso, ECS se encargará de la ejecución, el escalado y la monitorización de su agente de IA dentro de contenedores Docker. Funciona a la perfección con ELB para garantizar que su servicio pueda escalarse automáticamente hacia arriba o hacia abajo en función de la demanda.
Tras ejecutar este comando, AWS Copilot comenzará a crear la infraestructura necesaria para tu agente de IA.
Durante el proceso de inicialización, AWS Copilot te pedirá un nombre de entorno. Normalmente, comenzará con un entorno de desarrollo, que más tarde puede ampliarse a producción. Una vez establecido el nombre del entorno, Copilot comenzará a crear todos los recursos necesarios para tu entorno. Esto puede llevar unos minutos, ya que Copilot configura las VPC (nubes privadas virtuales), los equilibradores de carga y los clústeres ECS.
Paso 3: Modificar el archivo manifest.yml
En este paso, modificaremos el archivo manifest.yml para configurar algunos ajustes adicionales para su implementación de AWS Copilot. En concreto, configuraremos una ruta de comprobación de estado y añadiremos una variable de entorno para la clave de API de Tavily. El archivo manifest.yml se encuentra en la carpeta copilot/ai-agent y define cómo se implementa y configura su servicio.
Modificaciones a realizar:
- Health Check Path: Cambiaremos el endpoint de comprobación de salud a /docs. Esto permite a AWS verificar que su aplicación es saludable mediante la comprobación de esta ruta específica.
- Clave API de Tavily: Añade una variable de entorno para la clave de API de Tavily, que se pasará a tu servicio durante el despliegue. Esto asegura que la clave API se proporciona de forma segura a su aplicación.
Aquí está el archivo manifest.yml actualizado:
# The manifest for the "ai-agent" service.
# Read the full specification for the "Load Balanced Web Service" type at:
# https://aws.github.io/copilot-cli/docs/manifest/lb-web-service/
# Your service name will be used in naming your resources like log groups, ECS services, etc.
name: ai-agent
type: Load Balanced Web Service
# Distribute traffic to your service.
http:
# Requests to this path will be forwarded to your service.
# To match all requests you can use the "/" path.
path: "/"
# You can specify a custom health check path. The default is "/".
healthcheck: "/docs"
# Configuration for your containers and service.
image:
# Docker build arguments. For additional overrides: https://aws.github.io/copilot-cli/docs/manifest/lb-web-service/#image-build
build: Dockerfile
# Port exposed through your container to route traffic to it.
port: 8080
cpu: 256 # Number of CPU units for the task.
memory: 512 # Amount of memory in MiB used by the task.
platform: linux/x86_64 # See https://aws.github.io/copilot-cli/docs/manifest/lb-web-service/#platform
count: 1 # Number of tasks that should be running in your service.
exec: true # Enable running commands in your container.
network:
connect: true # Enable Service Connect for intra-environment traffic between services.
# storage:
# readonly_fs: true # Limit to read-only access to mounted root filesystems.
# Optional fields for more advanced use-cases.
#
variables: # Pass environment variables as key value pairs.
TAVILY_API_KEY: "<YOUR API KEY>"
#secrets: # Pass secrets from AWS Systems Manager (SSM) Parameter Store.
# GITHUB_TOKEN: GITHUB_TOKEN # The key is the name of the environment variable, the value is the name of the SSM parameter.
# You can override any of the values defined above by environment.
#environments:
# test:
# count: 2 # Number of tasks to run for the "test" environment.
# deployment: # The deployment strategy for the "test" environment.
# rolling: 'recreate' # Stops existing tasks before new ones are started for faster deployments.
Paso 4: Añadir una política Bedrock
Para permitir que tu agente de IA interactúe con los modelos de AWS Bedrock (como los modelos de Anthropic), necesitas adjuntar los permisos apropiados a tu servicio. En este paso, crearemos un archivo de política llamado bedrock-policy.yml en la carpeta copilot/ai-agent/addons. Esta política concede al agente de IA los permisos necesarios para invocar los modelos de AWS Bedrock.
En la carpeta copilot/ai-agent/addons, crea un nuevo archivo llamado bedrock-policy.yml con el siguiente contenido:
# You can use any of these parameters to create conditions or mappings in your template.
Parameters:
App:
Type: String
Description: Your application name
Env:
Type: String
Description: The environment name your service, job, or workflow is being deployed to
Name:
Type: String
Description: Your workload name
Resources:
BedrockAccessPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
PolicyDocument:
Version: "2012-10-17"
Statement:
- Sid: BedrockActions
Effect: Allow
Action:
- bedrock:InvokeModel
- bedrock:InvokeModelWithResponseStream
Resource:
- arn:aws:bedrock:*::foundation-model/anthropic.*
Outputs:
# You need to output the IAM ManagedPolicy so that Copilot can add it
# as a managed policy to your ECS task role.
BedrockAccessPolicyArn:
Description: "The ARN of the ManagedPolicy to attach to the task role."
Value: !Ref BedrockAccessPolicy
Paso 5: Desplegar el agente de IA
Con el entorno configurado y las políticas necesarias en su lugar, es hora de implementar el agente de AI en AWS. Utiliza el siguiente comando para iniciar el proceso de despliegue:
copilot deploy
Este comando iniciará el despliegue de tu aplicación en AWS. Durante este proceso, Copilot:
- Creará y subirá el contenedor: Tu aplicación se empaquetará como un contenedor Docker y se cargará en Amazon Elastic Container Registry (ECR).
- Pondrá en marcha el servicio: Copilot creará la infraestructura necesaria para ejecutar tu servicio en Amazon Elastic Container Service (ECS). ECS gestiona el despliegue, el escalado y la ejecución de la aplicación en contenedores.
- Configuración de redes y equilibrio de carga: Copilot configurará un Elastic Load Balancer (ELB) para dirigir el tráfico entrante a tu servicio, garantizando una alta disponibilidad y tolerancia a fallos.
- Adjuntar permisos: Cualquier política requerida, como la Política de Acceso Bedrock, se adjuntará a tu rol de tarea ECS, asegurando que tu servicio tenga los permisos necesarios para interactuar con los modelos de AWS Bedrock.
Este proceso de implementación puede tardar varios minutos, ya que AWS Copilot aprovisiona y configura los servicios subyacentes como ECS, balanceadores de carga y grupos de seguridad para garantizar que su aplicación se ejecute sin problemas en producción.
Si surge algún problema durante el proceso de despliegue, puedes utilizar el siguiente comando para comprobar los registros y depurar los errores:
copilot svc log
Este comando mostrará los registros del servicio implementado, lo que le permitirá solucionar cualquier problema que se haya producido durante la implementación. Además, puedes acceder a los registros de AWS CloudFormation para investigar la implementación de la infraestructura subyacente si es necesario.
Paso 6: Probar tu API
Una vez completada la implementación, AWS Copilot proporcionará una URL pública para su agente de IA. Ahora puede abrir su navegador y visitar la URL para acceder a la documentación de FastAPI en: https://.aws.com/docs
Aquí verás la ruta POST /generate, que te permite interactuar con el agente de IA. Puedes volver a probar la API directamente haciendo clic en la ruta, seleccionando «Probar» y rellenando los campos obligatorios, como la pregunta y el thread_id.
Alternativamente, puedes probar la API usando curl enviando una petición POST al endpoint /generate:
curl -X POST "https://<your-app-url>.aws.com/generate" \
-H "Content-Type: application/json" \
-d '{
"question": "What are solar panels?",
"thread_id": 1
}'
Si todo funciona correctamente, recibirás una respuesta JSON similar a ésta:
{
"result": [
{
"assistant": {
"messages": {
"content": "Solar panels are devices that convert sunlight directly ..... ctricity from panels work!",
"additional_kwargs": {
"usage": {
"prompt_tokens": 508,
"completion_tokens": 272,
"total_tokens": 780
},
"stop_reason": "end_turn",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0"
},
"response_metadata": {
"usage": {
"prompt_tokens": 508,
"completion_tokens": 272,
"total_tokens": 780
},
"stop_reason": "end_turn",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0"
},
"type": "ai",
"name": null,
"id": "run-b10e6c9e-832e-4fb2-92e9-c335cb2a07f2-0",
"example": false,
"tool_calls": [],
"invalid_tool_calls": [],
"usage_metadata": {
"input_tokens": 508,
"output_tokens": 272,
"total_tokens": 780
}
}
}
}Conclusión
Una vez que el agente de IA se ha implementado correctamente con AWS Copilot, la configuración ahora permite el acceso sin problemas al agente de IA desde cualquier tipo de aplicación frontend, como aplicaciones web o móviles. Esta API es totalmente capaz de gestionar solicitudes en tiempo real y proporcionar respuestas inteligentes en varias plataformas. El despliegue permite una integración flexible, garantizando que el agente de IA pueda escalarse y adaptarse a diferentes casos de uso. Esta base hace que el agente de IA sea versátil y esté listo para ser utilizado en diversas aplicaciones del mundo real.
Sígueme en Medium, Instagram, YouTube, Pairrot.