La llegada de los agentes de IA (opens new window) ha transformado diversas industrias, ofreciendo una eficiencia y productividad sin precedentes. Estudios muestran que más del 60% (opens new window) de los propietarios de negocios anticipan un aumento en la productividad a través de la implementación de IA. Específicamente, el 64% (opens new window) cree que la IA mejorará la productividad general del negocio, mientras que el 42% espera una simplificación de los procesos laborales. Estas estadísticas subrayan el impacto transformador de los agentes de IA en la optimización de flujos de trabajo y el impulso del crecimiento en diversos sectores.
En la vida cotidiana, nos encontramos con agentes de IA más de lo que nos damos cuenta, desde asistentes virtuales como Siri y Alexa hasta sistemas de recomendación personalizados en plataformas de streaming. Estos agentes desempeñan un papel fundamental en la mejora de las experiencias de usuario, proporcionando soluciones personalizadas y automatizando tareas rutinarias de manera fluida.
En el ámbito del desarrollo de IA, LangChain (opens new window) destaca como un marco modular revolucionario diseñado para simplificar la creación de aplicaciones de lenguaje potenciadas por IA. Esta innovadora herramienta proporciona una interfaz estandarizada para interactuar con modelos de lenguaje y una integración perfecta con fuentes de datos externas. LangChain abstrae las complejidades típicamente asociadas con el trabajo en Modelos de Lenguaje Grandes (LLMs) (opens new window), lo que la hace accesible incluso para aquellos sin una amplia experiencia en aprendizaje automático o IA.
# ¿Qué es una Cadena en LangChain?
LangChain fue desarrollado inicialmente para proporcionar una interfaz fluida para integrar LLMs con fuentes de datos externas. Su objetivo es cerrar la brecha entre las capacidades de los potentes modelos de IA y las vastas cantidades de datos que pueden utilizar. Este marco permite a los desarrolladores crear aplicaciones avanzadas que aprovechan el poder de los LLMs para acceder y manejar datos de diversas fuentes.
La estructura de LangChain se basa principalmente en el concepto de "cadenas". Estas cadenas representan secuencias de operaciones que transforman las entradas en salidas deseadas. La elegancia de LangChain radica en su modularidad y flexibilidad, lo que permite a los desarrolladores diseñar flujos de trabajo personalizados adaptados a sus necesidades específicas.
En LangChain, una cadena es una secuencia de pasos u operaciones que procesan datos de entrada para producir una salida. Cada paso en la cadena realiza una función específica, como la recuperación de datos, la transformación o la interacción con un LLM. Las cadenas pueden ser simples, involucrando solo unos pocos pasos, o complejas, involucrando múltiples etapas de procesamiento de datos e interacciones con modelos.
Por ejemplo, una cadena podría comenzar con la recuperación de datos de una API, luego pasar esos datos a través de una serie de transformaciones y finalmente alimentarlos a un LLM para generar una respuesta. Este enfoque modular facilita el diseño, prueba y reutilización de componentes individuales de un flujo de trabajo.
Sin embargo, las cadenas tienen sus limitaciones. Son lineales y a veces pueden tener dificultades con tareas más dinámicas o adaptativas. Aquí es donde entran en juego los agentes de LangChain, abordando las limitaciones de las cadenas al ofrecer más flexibilidad e inteligencia.
# ¿Qué son los Agentes de LangChain?
Los agentes de LangChain son componentes potentes diseñados para mejorar las capacidades de los LLMs al permitirles tomar decisiones y realizar acciones basadas en esas decisiones. A diferencia de las cadenas, que siguen una secuencia predeterminada de acciones, los agentes utilizan los LLMs como motores de razonamiento para determinar dinámicamente la secuencia de acciones a realizar.
La funcionalidad principal de los agentes de LangChain implica seleccionar y ejecutar acciones basadas en datos de entrada y los resultados de acciones anteriores. Esto los hace altamente adaptables y capaces de manejar tareas complejas con una intervención humana mínima. Por ejemplo, un agente puede interactuar con varias herramientas y fuentes de datos, procesar información y refinar iterativamente sus acciones para lograr un objetivo específico.
En las cadenas, una secuencia de acciones está codificada de antemano, mientras que en los agentes, la secuencia de acciones no está predefinida y se utiliza un modelo de lenguaje como motor de razonamiento para determinar qué acciones tomar y en qué orden.
Los agentes tienen varias cualidades clave:
- Adaptabilidad: Los agentes pueden ajustar sus acciones en función de los datos y el contexto que encuentran. Esto significa que no están limitados a una secuencia predefinida de pasos como las cadenas.
- Autonomía: Los agentes pueden operar de forma independiente, tomando decisiones sobre la marcha sin necesidad de supervisión constante.
- Interactividad: Los agentes pueden interactuar con múltiples fuentes de datos, herramientas y LLMs, lo que los hace versátiles para manejar diversas tareas.
Al incorporar agentes, tu sistema puede gestionar flujos de trabajo más sofisticados que requieren respuestas dinámicas y comportamiento adaptativo, superando la rigidez de las cadenas simples.
# ¿Cuáles son los principales componentes de un agente?
Para construir un agente efectivo en LangChain, se requieren varios componentes clave:
# Herramientas
Las herramientas son los bloques de construcción que un agente utiliza para realizar tareas, incluyendo la interacción con APIs, bases de datos y funciones de procesamiento de datos. Cada herramienta proporciona capacidades específicas que el agente puede aprovechar para realizar diversas tareas.
LangChain ofrece varias formas de utilizar diferentes herramientas, incluyendo herramientas predefinidas, retrievers (opens new window) como herramientas y herramientas personalizadas (opens new window). Veamos cada una de ellas en detalle:
# Herramientas predefinidas
LangChain proporciona una colección de herramientas predefinidas (opens new window) que puedes utilizar fácilmente importándolas e integrándolas en tus agentes. Por ejemplo:
from langchain_community.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
En este ejemplo, estamos importando la herramienta DuckDuckGoSearchRun del módulo langchain_community.tools e inicializándola. Después de la inicialización, esta herramienta se puede utilizar dentro de un agente a través de un kit de herramientas (opens new window), como veremos más adelante.
# Uso de Retrievers como herramientas
En escenarios en los que necesites obtener datos de una base de datos vectorial (opens new window) basada en consultas de usuario, LangChain te permite convertir los recuperadores de datos en herramientas y utilizarlos dentro de tus agentes. Así es cómo puedes hacerlo:
from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
retriever,
"nombre_de_la_herramienta",
"Descripción de la herramienta",
)
Utilizando el método create_retriever_tool de LangChain, puedes convertir cualquier recuperador en una herramienta de LangChain. Este método toma tres argumentos: el recuperador que has creado previamente, el nombre de la herramienta y una descripción de la herramienta. La descripción ayuda al LLM a decidir cuándo utilizar esta herramienta y qué tipo de datos contiene.
# Herramientas personalizadas
LangChain también permite a los desarrolladores definir herramientas personalizadas adaptadas a sus aplicaciones o casos de uso. La forma más sencilla de definir una herramienta personalizada es utilizando el decorador @tool con cualquier método de Python. Aquí tienes un ejemplo:
from langchain.agents import tool
@tool
def obtener_longitud_palabra(palabra: str) -> int:
"""Devuelve la longitud de una palabra."""
return len(palabra)
obtener_longitud_palabra.invoke("abc")
En este ejemplo, el nombre del método se utiliza como nombre de la herramienta, y la cadena de documentación sirve como descripción de la herramienta. Esta configuración permite que el agente comprenda y utilice la herramienta de manera efectiva.
Para herramientas más complejas, puedes extender la clase BaseTool proporcionada por LangChain para crear herramientas personalizadas sofisticadas que satisfagan necesidades específicas.
# Kit de herramientas
Un kit de herramientas es una colección de herramientas a las que un agente puede acceder. Define el conjunto de acciones que el agente puede realizar y los recursos que puede utilizar. Es una lista de herramientas que has definido para ser utilizadas en el agente de esta manera:
kit_de_herramientas=[retriever_tool,obtener_longitud_palabra]
Todas las herramientas en el kit de herramientas actúan de la misma manera, sin importar cómo se definan.
# LLM (Modelo de Lenguaje Grande)
El LLM es el núcleo de la inteligencia del agente, procesando entradas de lenguaje natural, generando respuestas y dirigiendo el proceso de toma de decisiones. LangChain se integra perfectamente con varios LLMs de última generación como GPT-4 (opens new window), BERT (opens new window) y T5 (opens new window), asegurando que los agentes tengan acceso a capacidades de IA de vanguardia.
Esta integración mejora la comprensión del lenguaje natural, permite una toma de decisiones sofisticada y admite la personalización a dominios específicos, lo que hace que los agentes de LangChain sean versátiles y potentes para realizar tareas complejas.
# Prompt
El prompt es la instrucción o consulta inicial que guía el comportamiento del LLM. La creación de prompts claros y efectivos es crucial para garantizar que el agente realice tareas de manera precisa y eficiente.
LangChain Hub
LangChain Hub es un repositorio central para encontrar, compartir y gestionar prompts, cadenas, agentes y más. Ayuda a los desarrolladores y equipos a acceder a prompts de alta calidad y acelerar sus procesos de desarrollo.
Uso de LangChain Hub
Con LangChain Hub (opens new window), puedes importar fácilmente un prompt público en tu código, lo que te permite aprovechar prompts bien elaborados adaptados a tu caso de uso específico y al modelo de lenguaje que estás utilizando. Así es cómo puedes importar un prompt preescrito:
from langchain import hub
prompt = hub.pull("hwchase17/openai-functions-agent")
El código hub.pull("hwchase17/openai-functions-agent") se utiliza para importar un prompt predefinido del LangChain Hub, diseñado específicamente para funcionar con funciones de OpenAI (opens new window). Este prompt en particular es parte de una colección destinada a mejorar la funcionalidad de los agentes utilizando los potentes modelos de lenguaje de OpenAI.
# Ejecutor del Agente
El ejecutor del agente (opens new window) es un elemento crítico en el ecosistema de LangChain. Orquesta las actividades del agente, gestionando el flujo de operaciones y asegurando que cada componente funcione de manera armoniosa.
Según la documentación de LangChain, el flujo de trabajo del ejecutor del agente se ve aproximadamente así:
siguiente_accion = agente.obtener_accion(...)
while siguiente_accion != AgenteFinalizado:
observacion = ejecutar(siguiente_accion)
siguiente_accion = agente.obtener_accion(..., siguiente_accion, observacion)
return siguiente_accion
Básicamente, es un bucle while que sigue llamando a los métodos de acción siguientes en el agente, hasta que el agente haya devuelto su respuesta final. El ejecutor es responsable de:
- Iniciar tareas: Inicia las actividades del agente en función del prompt y el contexto dados.
- Gestionar el flujo de trabajo: Coordina la interacción entre las herramientas, el kit de herramientas y el LLM, asegurando la ejecución fluida del flujo de trabajo.
- Manejar errores: Gestiona cualquier error o excepción (opens new window) que ocurra durante las operaciones del agente, proporcionando un rendimiento sólido y confiable.
Cada uno de estos componentes desempeña un papel vital en la funcionalidad de un agente. LangChain maneja estos componentes con gran flexibilidad, permitiendo a los desarrolladores personalizar y optimizar cada parte según sus necesidades.
# Crear un Agente utilizando MyScaleDB y LangChain
Hasta ahora, hemos explorado los componentes importantes necesarios para construir un agente. Ahora, creemos un agente utilizando MyScaleDB (opens new window) y DuckDuckGo (opens new window). Este agente tendrá dos herramientas:
- Recuperador: Esta herramienta obtendrá información relacionada con telemetría de MyScaleDB (opens new window).
- Herramienta DuckDuckGo: Esta herramienta obtendrá datos de internet.
# Configuración del Entorno
Antes de comenzar a construir el agente, instalemos las herramientas y tecnologías necesarias. Abre tu terminal e ingresa el siguiente comando:
pip install langchain langchain_openai duckduckgo-search
Esto instalará todos los paquetes necesarios para construir este agente.
# Cargar los datos para la herramienta recuperadora
Comencemos cargando los datos para la herramienta recuperadora utilizando el WebBaseLoader de LangChain:
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
# Cargar los datos de internet
loader = WebBaseLoader("https://myscale.com/blog/es/myscale-telemetry-llm-app-observability/")
docs = loader.load()
# Dividir el texto en fragmentos más pequeños
documents = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200
).split_documents(docs)
# Configuración de las Credenciales de MyScaleDB
Antes de inicializar el recuperador, necesitamos configurar las credenciales para la base de datos vectorial. Estamos utilizando MyScale, y puedes leer más al respecto en la guía de inicio rápido (opens new window). Configura las credenciales de la siguiente manera:
import os
# Credenciales para MyScaleDB
os.environ["MYSCALE_HOST"] = "tu-nombre-de-host-aquí"
os.environ["MYSCALE_PORT"] = "443"
os.environ["MYSCALE_USERNAME"] = "tu-nombre-de-usuario-aquí"
os.environ["MYSCALE_PASSWORD"] = "tu-contraseña-aquí"
# Configura la clave de la API de OpenAI para el LLM de OpenAI
os.environ["OPENAI_API_KEY"] = "tu-clave-de-api-aquí"
Para este proyecto, utilizaremos incrustaciones de OpenAI (opens new window) y ChatGPT, lo que requiere configurar la clave de la API de OpenAI (opens new window).
# Inicializar el Recuperador
Iniciemos el recuperador y pongamos los datos en el recuperador de MyScaleDB (opens new window).
from langchain_community.vectorstores import MyScale
from langchain_openai import OpenAIEmbeddings
vector = MyScale.from_documents(documents, OpenAIEmbeddings())
recuperador = vector.as_retriever()
Una vez que el recuperador esté listo, el siguiente paso es convertirlo en una herramienta de langchain. Para esto, utilizaremos el método create_retriever_tool:
from langchain.tools.retriever import create_retriever_tool
herramienta_recuperador = create_retriever_tool(
recuperador,
"MyScale_telemetry",
"Buscar información sobre la telemetría de MyScale. ¡Para cualquier pregunta sobre Telemetría, debes utilizar esta herramienta!",
)
La herramienta definida se utilizará cada vez que una consulta de usuario pregunte sobre la telemetría de MyScale. Como se discutió anteriormente, la descripción de la herramienta es muy importante porque ayuda al LLM a elegir la herramienta adecuada en función de la consulta.
# Definir la Herramienta de Búsqueda
Definamos la segunda herramienta para nuestro agente. Esta es una herramienta predefinida diseñada para buscar eventos actuales o obtener la información más reciente de internet.
from langchain_community.tools import DuckDuckGoSearchRun
busqueda = DuckDuckGoSearchRun()
# Crear el Kit de Herramientas
Nuestro agente utilizará dos herramientas: el recuperador y la búsqueda web. Creemos el kit de herramientas:
herramientas = [busqueda, herramienta_recuperador]
# Inicializar el LLM
Utilizaremos el modelo GPT-3.5-turbo de OpenAI para el agente:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# Obtener el Prompt
Utilizaremos el mismo prompt predefinido del LangChain Hub porque estamos utilizando el modelo de OpenAI para nuestro agente.
from langchain import hub
# Obtener la plantilla del prompt
prompt = hub.pull("hwchase17/openai-functions-agent")
prompt.messages
# Crear el Agente y el Ejecutor del Agente
LangChain proporciona varios tipos de agentes (opens new window), cada uno diseñado con capacidades y funcionalidades de razonamiento únicas. Para este proyecto, utilizaremos el agente más avanzado y robusto disponible: el agente de herramientas de OpenAI (opens new window). Como se destaca en la documentación oficial, este agente utiliza los últimos modelos de OpenAI, ofreciendo un rendimiento mejorado y una amplia gama de capacidades.
from langchain.agents import create_tool_calling_agent
agente = create_tool_calling_agent(llm, herramientas, prompt)
Ahora, pasemos el agente al AgenteExecutor que manejará todas las funcionalidades del agente definido.
from langchain.agents import AgentExecutor
ejecutor_agente = AgentExecutor(agente=agente, herramientas=herramientas, verbose=True)
Establecer verbose=True en el AgentExecutor permite un registro detallado de las operaciones del agente. Esto proporciona una mayor transparencia y comprensión del proceso de toma de decisiones del agente, lo que es útil para depurar y comprender cómo interactúa el agente con diferentes herramientas.
# Agregar Memoria al Agente
Agregamos memoria al agente para retener el contexto de interacciones anteriores, lo que mejora su capacidad para proporcionar respuestas relevantes y coherentes en conversaciones en curso. La memoria también permite que el agente aprenda y se adapte con el tiempo, mejorando su rendimiento y haciendo que las interacciones sean más personalizadas e inteligentes.
from langchain.memory import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
memoria = ChatMessageHistory(session_id="sesion-de-prueba")
agente_con_historial_de_chat = RunnableWithMessageHistory(
ejecutor_agente,
lambda session_id: memoria,
input_messages_key="input",
history_messages_key="chat_history",
)
El uso de un ID de sesión ayuda a mantener y organizar sesiones de usuario individuales, asegurando que el agente pueda realizar un seguimiento y recordar con precisión las interacciones específicas de cada sesión.
# Llamar al Agente
Finalmente, podemos llamar al agente para obtener información. Al hacer esta consulta:
# Obtener información sobre la telemetría de MyScale
ejecutor_agente.invoke({"input": "¿Qué es la telemetría de MyScale?"}, config={"configurable": {"session_id": "<foo>"}})
Los resultados serán similares a esto:
Como puedes ver, la consulta estaba relacionada con la telemetría de MyScale y el agente está invocando la herramienta MyScale_telemetry para esto.
Hagamos otra consulta y obtengamos los datos más recientes de internet.
# Obtener información del clima en California
ejecutor_agente.invoke({"input": "¿Cómo está el clima en California?"}, config={"configurable": {"session_id": "<foo>"}})
Los resultados serán similares a esto:
Este ejemplo práctico demuestra cómo crear un agente de LangChain con MyScaleDB y herramientas de DuckDuckGo. Cada componente es esencial para la funcionalidad del agente, y configurar el entorno correctamente garantiza un funcionamiento fluido.
# Conclusión
Los agentes de LangChain son componentes avanzados que mejoran las capacidades de los LLMs. Lo hacen permitiendo que los LLMs tomen decisiones y realicen acciones basadas en esas decisiones. A diferencia de las cadenas tradicionales que siguen una secuencia establecida, los agentes utilizan los LLMs para determinar dinámicamente la secuencia de acciones. Esta flexibilidad permite que los agentes manejen tareas complejas y cambiantes de manera más eficiente. Los agentes de LangChain son altamente modulares, lo que facilita la integración de diversas herramientas y funciones personalizadas, lo que permite a los desarrolladores crear flujos de trabajo adaptados a necesidades específicas.
MyScaleDB (opens new window) es una opción destacada entre las bases de datos vectoriales, conocida por su rendimiento y escalabilidad superiores. Su algoritmo MSTG (Multi-Stage Tree Graph) (opens new window) supera a otros al proporcionar una recuperación de datos más rápida y precisa, lo cual es vital para tareas impulsadas por IA. MyScaleDB está diseñado para manejar eficientemente grandes volúmenes de datos, asegurando operaciones confiables y de alta velocidad. Esto lo convierte en una herramienta esencial para los desarrolladores que buscan crear aplicaciones de IA robustas que requieren una gestión y recuperación eficientes de datos a gran escala.
