Cómo utilizar LangChain Agents para tareas automatizadas poderosas
- Name
- Lynn Mikami
Published on
En el fascinante mundo de los modelos de lenguaje y la automatización, los LangChain Agents se destacan como un faro de innovación, permitiendo a los desarrolladores y entusiastas de la tecnología crear tareas automatizadas sofisticadas que parecen sacadas de una novela de ciencia ficción. Si estás buscando sumergirte en el mundo de los LangChain Agents pero no sabes por dónde empezar, estás en el lugar correcto. Esta guía desmitificará el proceso, haciéndolo accesible y sencillo. Así que toma una taza de café y embarquemos juntos en este emocionante viaje.
Cómo utilizar LangChain Agents: Inicio rápido
Para comprender mejor el marco de trabajo de los agentes, construyamos un agente que tenga dos herramientas: una para buscar cosas en línea y otra para buscar datos específicos que hemos cargado en un índice.
Esto asumirá conocimientos previos de LLMs y recuperación, por lo que si aún no has explorado esas secciones, se recomienda hacerlo.
Configuración: LangSmith
Por definición, los agentes realizan una secuencia de pasos determinada por ellos mismos y dependiente de la entrada antes de devolver una salida para el usuario. Esto hace que la depuración de estos sistemas sea particularmente complicada y la visibilidad sea especialmente importante. LangSmith es especialmente útil para estos casos.
Cuando construyas con LangChain, todos los pasos se rastrearán automáticamente en LangSmith. Para configurar LangSmith, simplemente necesitamos definir las siguientes variables de entorno:
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="<tu-clave-de-api>"Definir herramientas
Primero, necesitamos crear las herramientas que queremos utilizar. Utilizaremos dos herramientas: Tavily (para buscar en línea) y luego un recuperador sobre un índice local que crearemos.
- Tavily
Tenemos una herramienta incorporada en LangChain para utilizar fácilmente el motor de búsqueda Tavily como una herramienta. Ten en cuenta que esto requiere una clave de API: tienen un nivel gratuito, pero si no tienes una o no quieres crear una, siempre puedes ignorar este paso.
Una vez que hayas creado tu clave de API, deberás exportarla como sigue:
export TAVILY_API_KEY="..."from langchain_community.tools.tavily_search import TavilySearchResults
search = TavilySearchResults()
search.invoke("¿cómo está el clima en SF?")- Recuperador
También crearemos un recuperador sobre algunos datos propios. Para una explicación más detallada de cada paso aquí, consulta esta sección.
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
retriever.get_relevant_documents("¿cómo subir un conjunto de datos")[0]Ahora que hemos poblado nuestro índice sobre el cual realizaremos recuperación, podemos convertirlo fácilmente en una herramienta (el formato necesario para que un agente lo utilice correctamente).
from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
retriever,
"búsqueda_langsmith",
"Busca información sobre LangSmith. ¡Para cualquier pregunta sobre LangSmith, debes usar esta herramienta!",
)Herramientas
Ahora que hemos creado ambas, podemos crear una lista de herramientas que utilizaremos más adelante.
tools = [search, retriever_toll]Cómo crear un agente LangChain
Ahora que hemos definido las herramientas, podemos crear el agente. Utilizaremos un agente de funciones de OpenAI: para obtener más información sobre este tipo de agente, así como otras opciones, consulta esta guía.
Primero, elegimos el LLM que queremos que guíe al agente.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)A continuación, elegimos el mensaje que queremos utilizar para guiar al agente.
from langchain import hub
# Obtén el mensaje a utilizar, ¡puedes modificarlo!
prompt = hub.pull("hwchase17/openai-functions-agent")
prompt.messagesAhora podemos inicializar el agente con el LLM, el mensaje y las herramientas. El agente es responsable de recibir la entrada y decidir qué acciones tomar. Es crucial tener en cuenta que el agente no ejecuta esas acciones, eso lo hace el Agente Ejecutor (siguiente paso). Para obtener más información sobre cómo pensar en estos componentes, consulta nuestra guía conceptual.
from langchain.agents import create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)Por último, combinamos el agente (la parte inteligente) con las herramientas dentro del Agente Ejecutor (que llamará repetidamente al agente y ejecutará las herramientas). Para obtener más información sobre cómo pensar en estos componentes, consulta nuestra guía conceptual.
from langchain.agents import AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)Ejecutar el agente
¡Ahora podemos ejecutar el agente en algunas consultas! Ten en cuenta que por ahora, todas estas consultas son independientes del estado (no recordará interacciones anteriores).
agent_executor.invoke({"input": "¡Hola!"})agent_executor.invoke({"input": "¿cómo puede LangSmith ayudar con las pruebas?"})agent_executor.invoke({"input": "¿cómo está el clima en SF?"})Agregar memoria Como se mencionó anteriormente, este agente es sin estado. Esto significa que no recuerda interacciones anteriores. Para darle memoria, necesitamos pasar el historial de chat anterior. Nota: debe llamarse chat_history debido a la indicación que estamos utilizando. Si usamos una indicación diferente, podríamos cambiar el nombre de la variable.
# Aquí pasamos una lista vacía de mensajes para chat_history porque es el primer mensaje en el chat
agent_executor.invoke({"input": "¡Hola! Mi nombre es Bob", "chat_history": []})from langchain_core.messages import AIMessage, HumanMessage
agent_executor.invoke(
{
"chat_history": [
HumanMessage(content="¡Hola! Mi nombre es Bob"),
AIMessage(content="¡Hola Bob! ¿En qué puedo ayudarte hoy?"),
],
"input": "¿Cuál es mi nombre?",
}
)Si queremos realizar un seguimiento de estos mensajes automáticamente, podemos envolver esto en un RunnableWithMessageHistory. Para obtener más información sobre cómo usar esto, consulte esta guía.
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
message_history = ChatMessageHistory()
agent_with_chat_history = RunnableWithMessageHistory(
agent_executor,
# Esto es necesario porque en la mayoría de los escenarios del mundo real, se necesita un ID de sesión
# No se usa realmente aquí porque estamos utilizando un ChatMessageHistory simple en memoria.
lambda session_id: message_history,
input_messages_key="input",
history_messages_key="chat_history",
)
agent_with_chat_history.invoke(
{"input": "¡Hola! Soy Bob"},
# Esto es necesario porque en la mayoría de los escenarios del mundo real, se necesita un ID de sesión
# No se usa realmente aquí porque estamos utilizando un ChatMessageHistory simple en memoria.
config={"configurable": {"session_id": "<foo>"}},
)Tipos de agentes de LangChain
Tipos de agentes
En el ámbito de los agentes de LangChain, la diversidad es la clave. Estos agentes vienen en varios sabores, cada uno adaptado a diferentes tareas y capacidades. Exploraremos el mundo matizado de los tipos de agentes, desglosando sus tipos de modelos previstos, soporte para historial de chat, herramientas con múltiples entradas, llamadas de función paralelas y parámetros de modelo requeridos. Comprender estas categorías te ayudará a seleccionar el agente perfecto para tus necesidades.
-
Herramientas de OpenAI: Un agente de vanguardia optimizado para modelos recientes de OpenAI (desde el 1106 en adelante). Está diseñado para manejar interacciones de chat, admitir herramientas con múltiples entradas y realizar llamadas de función paralelas, requiriendo los parámetros de modelo 'tools'. Ideal para aquellos que aprovechan las últimas ofertas de OpenAI.
-
Funciones de OpenAI: Adaptado para modelos de OpenAI o modelos de código abierto ajustados que imiten las capacidades de llamada de función de OpenAI. Sobresale en entornos de chat, maneja herramientas con múltiples entradas y requiere los parámetros de modelo 'functions'. Una elección sólida para modelos expertos en llamadas de función.
-
XML: Este agente se adapta a modelos especializados en XML, como los de Anthropic. Está construido para LLMs (no modelos de chat), admite historial de chat y se utiliza mejor con herramientas no estructuradas que requieren una entrada de cadena única. Elije esto cuando trabajes con modelos competentes en XML.
-
Chat estructurado: Un agente versátil que destaca en aplicaciones basadas en chat y admite herramientas con múltiples entradas. No necesita parámetros adicionales de modelo, lo que lo convierte en una excelente opción para proyectos que requieren interacciones complejas de herramientas.
-
Chat en JSON: Orientado a modelos que se destacan en JSON, este agente es adecuado para aplicaciones de chat. Simplifica el trabajo con modelos compatibles con JSON, agilizando el desarrollo de aplicaciones basadas en chat.
-
ReAct: Simplista pero eficaz, este agente está diseñado para aplicaciones básicas de LLM. Es un excelente punto de partida para modelos simples que requieren una implementación sencilla.
-
Self Ask con búsqueda: Ideal para modelos simples con una sola herramienta de búsqueda, este agente es perfecto para proyectos que requieren un conjunto de herramientas conciso y enfocado.
Cada tipo de agente tiene sus propias fortalezas, por lo que es crucial combinar el agente con los requisitos específicos de tu proyecto. Ya sea que necesites soporte para historial de chat, herramientas con múltiples entradas o llamadas de función paralelas, hay un agente diseñado para satisfacer esas necesidades. Considera la complejidad de tus tareas, las capacidades del modelo de lenguaje elegido y la naturaleza de las interacciones que manejará tu aplicación. Al alinear estos factores con el tipo de agente adecuado, podrás desbloquear todo el potencial de los agentes de LangChain en tus proyectos, allanando el camino para soluciones innovadoras y flujos de trabajo optimizados.
Ampliando las intrincadas características de los agentes de LangChain, esta guía tiene como objetivo proporcionar una comprensión más profunda y aplicaciones prácticas de diferentes tipos de agentes. Al explorar códigos y escenarios de muestra detallados, obtendrás una visión de la selección e implementación del agente más adecuado para las necesidades de tu proyecto. Sumergámonos en el núcleo de los agentes de LangChain, destacando sus características y capacidades únicas a través de ejemplos.
Agentes de LangChain n.º 1: Agente de herramientas de OpenAI
El agente de Herramientas de OpenAI está diseñado para funcionar sin problemas con los modelos más recientes de OpenAI, facilitando la ejecución de múltiples funciones o "herramientas" simultáneamente. Este agente es particularmente útil cuando tu aplicación requiere interactuar con varias API externas o realizar múltiples tareas en paralelo, reduciendo así el tiempo total de procesamiento.
Código de muestra:
# Importar bibliotecas y herramientas necesarias
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
# Inicializar la herramienta de búsqueda de Tavily
tools = [TavilySearchResults(max_results=1)]
# Obtener la indicación y configurar el LLM
prompt = hub.pull("hwchase17/openai-tools-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0)
# Crear el agente de Herramientas de OpenAI
agente = create_openai_tools_agent(llm, herramientas, prompt)
# Ejecutar el agente con una entrada de ejemplo
ejecutor_agente = AgentExecutor(agent=agente, tools=herramientas, verbose=True)
respuesta = ejecutor_agente.invoke({"input": "¿Qué es LangChain?"})
print(respuesta)En este ejemplo, la función create_openai_tools_agent construye un agente que puede utilizar el modelo de OpenAI para decidir de manera inteligente cuándo invocar una o más herramientas basándose en la entrada. La herramienta Tavily Search se utiliza aquí para demostrar las capacidades de búsqueda en la web.
Agentes de LangChain #2: Agente de Funciones de OpenAI
El agente de Funciones de OpenAI es apto para tareas en las que el modelo necesita decidir si y qué función llamar en función de la entrada. Aunque es similar al agente de Herramientas, está específicamente diseñado para escenarios en los que la llamada a funciones es fundamental para la tarea, ya que OpenAI ha dejado de utilizar este enfoque en favor de las herramientas para los modelos más nuevos.
Código de ejemplo:
# Configuración del agente de Funciones de OpenAI
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
# Inicialización de las herramientas y elección de LLM
herramientas = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106")
# Construcción y ejecución del agente de Funciones de OpenAI
agente = create_openai_functions_agent(llm, herramientas, prompt)
ejecutor_agente = AgentExecutor(agent=agente, tools=herramientas, verbose=True)
respuesta = ejecutor_agente.invoke({"input": "¿Qué es LangChain?"})
print(respuesta)Este ejemplo resalta cómo configurar y utilizar el agente de Funciones de OpenAI, utilizando Tavily Search como herramienta para demostrar la capacidad del agente de invocar funciones específicas en función de las consultas del usuario.
Agentes de LangChain #3: Agente XML
El agente de XML está optimizado para modelos capaces de generar e interpretar estructuras XML. Este tipo de agente es ventajoso cuando se trabaja con datos estructurados o cuando la interacción con el modelo se beneficia del formato estructurado de XML.
Código de ejemplo:
# Inicialización del agente XML
from langchain import hub
from langchain.agents import AgentExecutor, create_xml_agent
from langchain_community.chat_models import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
herramientas = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/xml-agent-convo")
llm = ChatAnthropic(model="claude-2")
# Creación y ejecución del agente XML
agente = create_xml_agent(llm, herramientas, prompt)
ejecutor_agente = AgentExecutor(agent=agente, tools=herramientas, verbose=True)
respuesta = ejecutor_agente.invoke({"input": "¿Qué es LangChain?"})
print(respuesta)Esta configuración muestra el uso de un agente XML con Claude-2, un modelo de Anthropic conocido por su capacidad con XML. El formato XML proporciona una forma estructurada de comunicación entre el agente y el modelo, facilitando el manejo de datos complejos.
Agentes de LangChain #4: Agente de Chat JSON
El agente de Chat JSON utiliza el formato JSON para sus salidas, lo que lo hace adecuado para aplicaciones que requieren datos de respuesta estructurados. Este agente es ideal para modelos de chat que se destacan en el procesamiento y la generación de estructuras JSON.
Código de ejemplo:
# Configuración del agente de Chat JSON
from langchain import hub
from langchain.agents import AgentExecutor, create_json_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
herramientas = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/react-chat-json")
llm = ChatOpenAI()
# Creación y ejecución del agente de Chat JSON
agente = create_json_chat_agent(llm, herramientas, prompt)
ejecutor_agente = AgentExecutor(agent=agente, tools=herramientas, verbose=True, handle_parsing_errors=True)
respuesta = ejecutor_agente.invoke({"input": "¿Qué es LangChain?"})
print(respuesta)Aquí, se utiliza el agente de Chat JSON para procesar una entrada y generar una respuesta estructurada en formato JSON, utilizando la herramienta Tavily Search para capacidades de búsqueda en la web. Este agente es particularmente útil en escenarios donde se requiere una respuesta estructurada para su procesamiento posterior o para una interacción más estructurada con el usuario.
Agentes de LangChain #5: Agente de Chat Estructurado
El Agente de Chat Estructurado destaca en escenarios que involucran herramientas de múltiples entradas, lo que permite interacciones complejas que requieren más que una simple cadena de entrada. Este agente está diseñado para facilitar flujos de trabajo complejos donde se deben considerar múltiples parámetros para cada invocación de herramienta.
Código de ejemplo:
# Inicialización del Agente de Chat Estructurado
from langchain import hub
from langchain.agents import AgentExecutor, create_structured_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
herramientas = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/structured-chat-agent")
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")
# Construcción y ejecución del Agente de Chat Estructurado
agente = create_structured_chat_agent(llm, herramientas, prompt)
ejecutor_agente = AgentExecutor(agent=agente, tools=herramientas, verbose=True, handle_parsing_errors=True)
respuesta = ejecutor_agente.invoke({"input": "¿Qué es LangChain?"})
print(respuesta)Este ejemplo ilustra el uso de un Agente de Chat Estructurado para interactuar de manera efectiva con herramientas de múltiples entradas. Al especificar un prompt detallado y seleccionar un modelo de lenguaje adecuado, este agente puede manejar consultas y herramientas complejas sin problemas. Al comprender las distinciones y capacidades de estos Agentes de LangChain, los desarrolladores pueden adaptar mejor sus aplicaciones para aprovechar todo el potencial de los modelos de lenguaje y las tareas automatizadas. Ya sea que su aplicación requiera llamadas de función simples, procesamiento de datos estructurados o interacciones complejas con múltiples herramientas, hay un Agente de LangChain que se ajusta a sus necesidades. Con estos ejemplos como base, estará bien equipado para embarcarse en su viaje de construcción de aplicaciones más inteligentes, eficientes y receptivas.
Conclusión
En conclusión, los Agentes de LangChain ofrecen un conjunto de herramientas versátil y poderoso para los desarrolladores que buscan integrar capacidades avanzadas de modelos de lenguaje en sus aplicaciones. Al comprender los matices de cada tipo de agente, desde los Agentes de Herramientas y Funciones de OpenAI hasta los Agentes de Chat XML, JSON y Estructurados, puede elegir la herramienta adecuada para las necesidades específicas de su proyecto. Estos agentes pueden manejar una amplia gama de tareas, desde llamadas de función simples hasta complejas interacciones que involucran múltiples entradas y formatos de datos estructurados.