Agentes de IA con Llama 3 y AutoGen
En esta lección, explorarás cómo construir agentes de IA conversacionales utilizando el modelo Llama 3 y la biblioteca AutoGen. Aprenderás a integrar herramientas y a diseñar interacciones complejas, como un juego de ajedrez conversacional, aplicando patrones de diseño de agentes. Esta habilidad es crucial para desarrollar sistemas de IA más autónomos y capaces de resolver problemas complejos.
Este notebook adapta el curso corto de DeepLearning.AI AI Agentic Design Patterns with AutoGen Lesson 4 Tool Use and Conversational Chess para usar Llama 3.
Te recomendamos tomar el curso antes o después de revisar este notebook para obtener una comprensión más profunda.
Configuración Inicial
Antes de empezar, asegúrate de tener una clave de API válida para acceder a los modelos de Llama 3. Esta clave es esencial para que los agentes puedan interactuar con el modelo de lenguaje.
El siguiente bloque de código instala las bibliotecas necesarias para AutoGen y otras dependencias. Es un paso fundamental para preparar tu entorno de desarrollo.
!pip install chess
!pip install pyautogenEste segmento de código importa las clases y funciones clave de AutoGen que necesitarás para definir y configurar tus agentes. Incluye elementos para la gestión de conversaciones y la ejecución de tareas.
import chess
import chess.svg
from typing_extensions import AnnotatedAquí se configura el modelo de lenguaje que utilizarán tus agentes. Se especifica Llama 3 y se establece la clave de API. Asegúrate de reemplazar "YOUR_API_KEY" con tu clave real para evitar errores de autenticación.
board = chess.Board()
made_move = FalseEste código define la configuración global para los modelos de lenguaje que usarán los agentes. Es un diccionario que incluye el modelo específico (Llama 3) y la clave de API, lo que permite a AutoGen saber cómo interactuar con el LLM.
def get_legal_moves(
) -> Annotated[str, "A list of legal moves in UCI format"]:
return "Possible moves are: " + ",".join(
[str(move) for move in board.legal_moves]
)Definición de Agentes
En esta sección, crearás los diferentes agentes que participarán en la conversación. Cada agente tendrá un rol y capacidades específicas.
Este bloque inicializa el UserProxyAgent, que simula la interacción de un usuario humano. Este agente es crucial para iniciar conversaciones y proporcionar retroalimentación a otros agentes.
from IPython.display import SVG
def make_move(
move: Annotated[str, "A move in UCI format."]
) -> Annotated[str, "Result of the move."]:
move = chess.Move.from_uci(move)
board.push_uci(str(move))
global made_move
made_move = True
svg_str = chess.svg.board(
board,
arrows=[(move.from_square, move.to_square)],
fill={move.from_square: "gray"},
size=200
)
display(
SVG(data=svg_str)
)
# Get the piece name.
piece = board.piece_at(move.to_square)
piece_symbol = piece.unicode_symbol()
piece_name = (
chess.piece_name(piece.piece_type).capitalize()
if piece_symbol.isupper()
else chess.piece_name(piece.piece_type)
)
return f"Moved {piece_name} ({piece_symbol}) from "\
f"{chess.SQUARE_NAMES[move.from_square]} to "\
f"{chess.SQUARE_NAMES[move.to_square]}."Aquí se define el AssistantAgent, que actuará como un asistente de IA. Este agente es responsable de procesar las solicitudes, utilizar herramientas y generar respuestas basadas en el modelo de lenguaje.
# base url from https://console.groq.com/docs/openai
config_list = [
{
"model": "llama3-70b-8192",
"base_url": "https://api.groq.com/openai/v1",
'api_key': 'your_groq_api_key', # get a free key at https://console.groq.com/keys
},
]Uso de Herramientas
Los agentes pueden extender sus capacidades utilizando herramientas. Aquí se muestra cómo definir y registrar una herramienta para que los agentes la utilicen.
Este código define una función de Python que servirá como una herramienta. En un contexto de ajedrez, podría ser una función para validar movimientos o actualizar el tablero. La capacidad de los agentes para usar estas herramientas es lo que los hace tan potentes.
from autogen import ConversableAgent
# Player white agent
player_white = ConversableAgent(
name="Player White",
system_message="You are a chess player and you play as white. "
"First call get_legal_moves(), to get a list of legal moves in UCI format. "
"Then call make_move(move) to make a move. Finally, tell the proxy what you have moved and ask the black to move", # added "Finally..." to make the agents work
llm_config={"config_list": config_list,
"temperature": 0,
},
)Este segmento registra la herramienta definida previamente con el AssistantAgent. Al registrar una herramienta, el agente sabe cuándo y cómo invocarla durante una conversación para resolver una tarea.
# Player black agent
player_black = ConversableAgent(
name="Player Black",
system_message="You are a chess player and you play as black. "
"First call get_legal_moves(), to get a list of legal moves in UCI format. "
"Then call make_move(move) to make a move. Finally, tell the proxy what you have moved and ask the white to move", # added "Finally..." to make the agents work
llm_config={"config_list": config_list,
"temperature": 0,
},)Iniciando la Conversación
Una vez que los agentes y las herramientas están configurados, puedes iniciar una conversación para ver cómo interactúan.
Este código inicia la conversación entre el UserProxyAgent y el AssistantAgent. El mensaje inicial es el "prompt" que guía la interacción y define la tarea a realizar, como jugar una partida de ajedrez.
def check_made_move(msg):
global made_move
if made_move:
made_move = False
return True
else:
return False
Ejemplo de Ajedrez Conversacional
Ahora, aplicaremos los conceptos anteriores para construir un juego de ajedrez conversacional.
Este bloque de código define la lógica del juego de ajedrez, incluyendo el estado del tablero y las reglas básicas. Es la base sobre la cual los agentes interactuarán para jugar.
board_proxy = ConversableAgent(
name="Board Proxy",
llm_config=False,
is_termination_msg=check_made_move,
default_auto_reply="Please make a move.",
human_input_mode="NEVER",
)Aquí se definen las funciones que los agentes usarán como herramientas para interactuar con el juego de ajedrez. Podrían ser funciones para hacer un movimiento, verificar el estado del juego o mostrar el tablero.
from autogen import register_functionEste código registra las herramientas de ajedrez con los agentes, permitiéndoles manipular el juego a través de comandos de lenguaje natural.
for caller in [player_white, player_black]:
register_function(
get_legal_moves,
caller=caller,
executor=board_proxy,
name="get_legal_moves",
description="Call this tool to get all legal moves in UCI format.",
)
register_function(
make_move,
caller=caller,
executor=board_proxy,
name="make_move",
description="Call this tool to make a move.",
)Este segmento de código inicializa el UserProxyAgent, pero esta vez con un contexto específico para el juego de ajedrez. Esto asegura que el agente entienda el dominio de la conversación.
player_black.llm_config["tools"]Aquí se inicializa el AssistantAgent, también configurado para el contexto del ajedrez. Este agente será el encargado de procesar los movimientos y las reglas del juego.
player_white.register_nested_chats(
trigger=player_black,
chat_queue=[
{
"sender": board_proxy,
"recipient": player_white,
"summary_method": "last_msg",
}
],
)
player_black.register_nested_chats(
trigger=player_white,
chat_queue=[
{
"sender": board_proxy,
"recipient": player_black,
"summary_method": "last_msg",
}
],
)Finalmente, este código inicia la conversación de ajedrez. El "prompt" inicial le indica a los agentes que comiencen una partida, y ellos usarán sus herramientas y lógica para jugar.
board = chess.Board()
chat_result = player_black.initiate_chat(
player_white,
message="Let's play chess! Your move.",
max_turns=3,
)Resumen
- Aprendiste a configurar un entorno para agentes de IA con Llama 3 y AutoGen.
- Definiste y configuraste diferentes tipos de agentes (
UserProxyAgentyAssistantAgent). - Exploraste cómo integrar y registrar herramientas personalizadas para extender las capacidades de los agentes.
- Aplicaste estos conceptos para construir un ejemplo de ajedrez conversacional.
- Comprendiste la importancia de los "prompts" iniciales para guiar las interacciones de los agentes.