- Inicialización: Configurando el “cerebro” de nuestro agente
- Generación de código: enseñamos a nuestro agente a escribir scripts en Python
- Gestión de la biblioteca: permitir que nuestro agente instale las herramientas necesarias
- Ejecución de código: permitir que nuestro agente ejecute el código que genera
- Centro de comando: creación de un centro central para gestionar todas estas funciones
Ahora, analicemos cada uno de estos pasos y veamos cómo se combinan para formar nuestro asistente de IA.
Paso 1: Inicialización: le damos a nuestro agente su primera chispa de vida
Todo gran viaje comienza con un paso y, en el mundo de los agentes de IA, ese paso es la inicialización. Aquí es donde configuramos la estructura básica de nuestro agente y lo conectamos a su fuente principal de inteligencia: en este caso, la API de OpenAI.
from openai import OpenAI
import os
from google.colab import userdata
import base64
import requests
from PIL import Image
from io import BytesIO
import subprocess
import tempfile
import re
import importlib
import sysos.environ["OPENAI_API_KEY"] = userdata.get('OPENAI_API_KEY')
class AgentPro:
def __init__(self):
# Future initialization code can go here
pass
Este fragmento es el equivalente digital de darle vida a nuestro asistente de IA. Estamos importando las bibliotecas necesarias, configurando nuestra clave API de OpenAI y creando el esqueleto de nuestra clase AgentPro. Es como proporcionar un cuerpo para nuestra IA: no es muy útil por sí solo, pero es esencial para todo lo que sigue.
Paso 2: Generación de código: enseñar a nuestro agente a escribir Python
Ahora que nuestro agente tiene un «cuerpo», vamos a darle la capacidad de pensar (o, en este caso, de generar código). ¡Aquí es donde las cosas empiezan a ponerse interesantes!
def generate_code(self, prompt):
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a Python code generator. Respond only with executable Python code, no explanations or comments except for required pip installations at the top."},
{"role": "user", "content": f"Generate Python code to {prompt}. If you need to use any external libraries, include a comment at the top of the code listing the required pip installations."}
],
max_tokens=4000,
temperature=0.7,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
code = re.sub(r'^```python\n|^```\n|```$', '', response.choices[0].message.content, flags=re.MULTILINE)
code_lines = code.split('\n')
while code_lines and not (code_lines[0].startswith('import') or code_lines[0].startswith('from') or code_lines[0].startswith('#')):
code_lines.pop(0)return '\n'.join(code_lines)
Este método es la joya de la corona de las capacidades de nuestro agente. Utiliza la API de OpenAI para generar código Python en función de una solicitud dada.
Piense en ello como si le diésemos a nuestro agente la capacidad de generar ideas y escribir código sobre la marcha. También estamos haciendo una limpieza para asegurarnos de obtener un código Python limpio y ejecutable sin formato Markdown ni comentarios innecesarios.
Los parámetros que utilizamos (como la temperatura y top_p) nos permiten controlar la creatividad y la aleatoriedad del código generado. ¡Es como ajustar la perilla de “inspiración” en la imaginación de nuestra IA!
Paso 3: Gestión de la biblioteca: dotar a nuestro agente de las herramientas adecuadas
Todo buen programador sabe lo importante que es tener las bibliotecas adecuadas a su disposición. Nuestro asistente de IA no es diferente. El siguiente método permite a AgentPro identificar e instalar las bibliotecas de Python necesarias
def install_libraries(self, code):
libraries = re.findall(r'#\s*pip install\s+([\w-]+)', code)
if libraries:
print("Installing required libraries...")
for lib in libraries:
try:
importlib.import_module(lib.replace('-', '_'))
print(f"{lib} is already installed.")
except ImportError:
print(f"Installing {lib}...")
subprocess.check_call([sys.executable, "-m", "pip", "install", lib])
print("Libraries installed successfully.")
Este método es como enviar a nuestro agente a hacer compras en el índice de paquetes de Python. Escanea el código generado en busca de comentarios de instalación de pip, verifica si las bibliotecas ya están instaladas y, si no es así, las instala. Se asegura de que nuestro agente siempre tenga las herramientas adecuadas para el trabajo, sin importar la tarea que le encomendemos.
Paso 4: Ejecución del código: cómo darle vida al código
Generar código es genial, pero ejecutarlo es lo fundamental. El siguiente método permite que nuestro agente ejecute el código que ha generado:
def execute_code(self, code):
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
temp_file.write(code)
temp_file_path = temp_file.nametry:
result = subprocess.run(['python', temp_file_path], capture_output=True, text=True, timeout=30)
output = result.stdout
error = result.stderr
except subprocess.TimeoutExpired:
output = ""
error = "Execution timed out after 30 seconds."
finally:
os.unlink(temp_file_path)
return output, error
Este método es donde realmente ocurre la magia. Toma el código generado, lo escribe en un archivo temporal, lo ejecuta, captura el resultado (o cualquier error) y luego lo limpia. Es como darle a nuestro agente las manos para que escriba el código y lo ejecute, todo en un abrir y cerrar de ojos.
Paso 5: Centro de comando: cómo poner todo junto
Por último, necesitamos una forma de orquestar todas estas increíbles capacidades. Introduzca el método de ejecución:
def run(self, prompt):
print(f"Generating code for: {prompt}")
code = self.generate_code(prompt)
print("Generated code:")
print(code)
print("\nExecuting code...")
output, error = self.execute_code(code)if output:
print("Output:")
print(output)
if error:
print("Error:")
print(error)
Este es el centro de comando de nuestro asistente de IA. Toma una indicación, genera el código, lo ejecuta y te informa los resultados o cualquier error. Es como tener un asistente personal que no solo entiende tus solicitudes, sino que las lleva a cabo y te brinda un informe completo.
Poniéndolo todo junto:
Ahora que tenemos todos nuestros componentes, veamos cómo podemos usar nuestro nuevo asistente de IA:
if __name__ == "__main__":
agent = AgentPro()
agent.run("""make a detailed deck on the best forms of leadership with at
least 10 slides and save it to a pptx called leadership.pptx""")
Con este simple comando, le pedimos a nuestro agente que cree una presentación completa sobre estilos de liderazgo, con al menos 10 diapositivas, y la guarde como un archivo de PowerPoint.
Nuestro agente generará el código Python necesario (probablemente usando una biblioteca como python-pptx), instalará las bibliotecas necesarias, ejecutará el código para crear la presentación y luego informará los resultados o cualquier error encontrado.
Acabamos de construir las bases de un potente agente de IA capaz de generar y ejecutar código Python a pedido. Desde configurar su «cerebro» con la API OpenAI, hasta darle el poder de escribir y ejecutar código y equiparlo con la capacidad de instalar las herramientas necesarias, hemos creado un asistente digital versátil.
Este es solo el comienzo de lo que es posible con los agentes de IA personalizados. En futuras entregas, exploraremos cómo mejorar AgentPro con capacidades de búsqueda web, generación de imágenes y procesos de toma de decisiones aún más complejos.
Recuerda que un gran poder conlleva una gran responsabilidad. Tu nuevo asistente de IA es una herramienta poderosa, pero depende de ti guiarlo con sabiduría. Úsalo para automatizar tareas tediosas, explorar nuevas ideas y ampliar los límites de lo que es posible con la IA.
Tal vez no le pidas que escriba tus votos matrimoniales o que decida tu próximo paso en tu carrera: ¡algunas cosas es mejor dejarlas en manos de la intuición humana!
Mantente atento a la Parte B, donde le enseñaremos a nuestro agente algunos trucos nuevos y comenzaremos a descubrir su verdadero potencial. Hasta entonces, ¡feliz codificación y que tus aventuras con IA estén libres de errores y sean infinitamente emocionantes!
¡Sigue para la Parte B!
Si estás interesado en conocer más sobre este contenido, suscríbete. También puedes conectarte conmigo en LinkedIn
Acerca de mí
¡Hola! Soy Hamza y estoy encantado de ser tu guía en este apasionante viaje al mundo de los agentes de IA. Con experiencia como investigador científico sénior en Google y como docente en instituciones prestigiosas como Stanford y UCLA, he estado a la vanguardia del desarrollo y la educación en IA durante años. Mi pasión radica en desmitificar conceptos complejos de IA y empoderar a la próxima generación de profesionales de IA.
Hablando de eso, si disfrutaste de esta inmersión profunda en la creación de agentes de IA desde cero, es posible que te interese llevar tu conocimiento de LLM al siguiente nivel. Recientemente desarrollé un curso completo titulado RAG empresarial y aplicaciones multiagente en la plataforma MAVEN. Este curso está diseñado para profesionales que desean ampliar los límites de lo que es posible con los modelos de lenguaje de gran tamaño, especialmente en entornos empresariales.
En RAG empresarial y aplicaciones multiagente Exploramos técnicas de vanguardia que van más allá de lo básico. Desde soluciones avanzadas de recuperación y generación aumentada (RAG) hasta los últimos métodos en optimización de modelos y prácticas de IA responsables, este curso está diseñado para brindarle las habilidades necesarias para enfrentar los desafíos de IA del mundo real.
Ya sea que esté buscando implementar aplicaciones LLM de última generación o profundizar en las complejidades del ajuste de modelos y la implementación de IA ética, este curso lo tiene cubierto.