Guía de Inicio Rápido

Langchain es una biblioteca Python, creada por Harrison Chase, de código abierto diseñada específicamente para proporcionar a los desarrolladores las herramientas necesarias para crear aplicaciones basadas en grandes modelos lingüísticos (LLM) de manera eficiente y profesional.

Docs: https://python.langchain.com/en/latest/getting_started/getting_started.html

Con LangChain, los desarrolladores pueden conectarse fácilmente a diversas fuentes de datos y de cálculo, permitiéndoles crear aplicaciones que realicen tareas de procesamiento del lenguaje natural (PLN) en fuentes de datos específicas de dominio, repositorios privados y mucho más.

Es un marco para la creación de agentes capaces de razonar y encadenar tareas. Brindando a los desarrolladores la capacidad de crear agentes inteligentes capaces de razonar sobre problemas complejos y dividirlos en subtareas más pequeñas. Con LangChain, es posible introducir contexto y memoria en las finalizaciones al crear pasos intermedios y encadenar comandos.

Instalación

Para empezar, instala LangChain con el siguiente comando:

pip install langchain

Todo el artículo, el código y el Jupyter Notebook explicado en este blog lo pueden encontrar en el siguiente repo de Github, dónde iré actualizando estas guías y tutoriales

⭐ (Estrella) el repo mientras tanto para recibir actualizaciones.

https://github.com/SamuSarmiento/CursoLangchain

Configuración del entorno

Usar LangChain normalmente requerirá integraciones con uno o más proveedores de modelos, almacenes de datos, apis, etc. Para este ejemplo, vamos a utilizar las APIs de OpenAI, por lo que primero tendremos que instalar su SDK

Consigue tu clave API de OpenAI https://platform.openai.com/account/api-keys

pip install openai
pip install python-dotenv

A continuación, tendremos que establecer la variable de entorno en nuestro archivo .env

import os
from dotenv import load_dotenv

load_dotenv()

openai_key = os.getenv("OPENAI_API_KEY")

Creación de una aplicación de modelos lingüísticos

Ahora que hemos instalado LangChain y configurado nuestro entorno, podemos empezar a construir nuestra aplicación de modelo de lenguaje.

LangChain proporciona muchos módulos que pueden ser utilizados para construir aplicaciones de modelos de lenguaje. Los módulos pueden combinarse para crear aplicaciones más complejas, o utilizarse individualmente para aplicaciones sencillas.

LLMs: Obtener predicciones de un modelo lingüístico

El bloque de construcción más básico de LangChain es llamar a un LLM con algún input. Básicamente tener tu propio ChatGPT corriendo en tu terminal.

Consejo: Compara los precios del servicio ChatGPT Plus de OpenAI y sus precios para la API 😜

En esta lección aprenderemos a interactuar con ChatGPT para generar texto. Muchas aplicaciones que están valoradas en millones de dólares como JasperAI, CopyAI... hacen lo mismo como parte de su negocio principal.

Veamos un ejemplo sencillo de cómo hacerlo. Para ello, primero tenemos que importar el LLM wrapper.

from langchain.llms import OpenAI

Podemos entonces inicializar el wrapper con cualquier argumento. En este ejemplo, probablemente queremos que las salidas sean standard, así que lo inicializaremos con una temperatura media/baja

llm = OpenAI(temperature=0.3)

Ahora podemos llamarlo con algún input!

text = "What would be a good company name for a company that makes LLMs powered Applications?"
print(llm(text))

LLMTech Solutions.

Plantillas de Prompts: Gestión de prompts para LLM

Llamar a un LLM es un gran primer paso, pero es sólo el principio. Normalmente, cuando utilizas un LLM en una aplicación, no envías el input del usuario directamente al LLM. En su lugar, es probable que tomes el input del usuario, construyas un prompt y luego lo envíes al LLM.

Por ejemplo, en el ejemplo anterior, el texto que pasamos estaba "hardcoded" para pedir el nombre de una empresa que fabrica agentes autónomos. En este servicio, lo que querríamos hacer es tomar sólo la entrada del usuario describiendo lo que hace la empresa, y luego formatear el prompt con esa información.

Esto es fácil de hacer con LangChain.

Primero definamos la plantilla del prompt:

from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)

print(prompt.format(product="Autonomous Vehicles"))

What is a good name for a company that makes Autonomous Vehicles?

print(llm(prompt.format(product="Autonomous Vehicles")))

Autonomous Mobility Solutions.

Cadenas: Combina LLMs y prompts en flujos de trabajo de varios pasos.

Hasta ahora, hemos trabajado con los PromptTemplate y LLM de base por sí solos. Pero, por supuesto, una aplicación real no es sólo una primitiva, sino más bien una combinación de ellas.

Una cadena en LangChain se compone de enlaces, que pueden ser primitivas como LLMs u otras cadenas.

El tipo más básico de cadena es una LLMChain, que consiste en un PromptTemplate y un LLM.

Extendiendo el ejemplo anterior, podemos construir una LLMChain que tome la entrada del usuario, la formatee con un PromptTemplate, y luego pase la respuesta formateada a un LLM.

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(temperature=0.3)

prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)

Ahora podemos crear una cadena muy simple que tomará la entrada del usuario, formateará el prompt con ella, y luego la enviará al LLM:

from langchain.chains import LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

print(chain.run("Software as a service"))

CloudSoft Solutions.

Y ya está. Esta es la primera cadena: una LLM Chain. Este es uno de los tipos más simples de cadenas, pero entender cómo funciona te preparará para trabajar con cadenas más complejas.

Agentes: Cadenas de llamadas dinámicas basadas en el input del usuario

Hasta ahora, las cadenas que hemos visto se ejecutaban en un orden predeterminado.

Los agentes ya no lo hacen: utilizan un LLM para determinar qué acciones realizar y en qué orden. Una acción puede consistir en utilizar una herramienta y observar su resultado, o en volver al usuario.

Cuando se utilizan correctamente, los agentes pueden ser extremadamente potentes.

Para cargar agentes, debe comprender los siguientes conceptos:

• Herramienta: Una función que realiza una tarea específica. Pueden ser cosas como: Búsqueda en Google, búsqueda en bases de datos, Python REPL, otras cadenas. La interfaz para una herramienta es actualmente una función que se espera que tenga una cadena como entrada, con una cadena como salida.

• LLM: El modelo de lenguaje que alimenta al agente.

• Agente: El agente a utilizar. Debe ser una cadena que haga referencia a una clase de agente de soporte. Dado que este cuaderno se centra en la API más simple y de más alto nivel, sólo cubre el uso de los agentes estándar soportados. Si quieres implementar un agente personalizado, consulta la documentación https://python.langchain.com/en/latest/getting_started/getting_started.html#agents-dynamically-call-chains-based-on-user-input

Para este ejemplo, también necesitarás instalar el paquete SerpAPI Python.

pip install google-search-results

import os
from dotenv import load_dotenv

load_dotenv()

openai_key = os.getenv("SERP_API_KEY")

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI

# En primer lugar, vamos a cargar el modelo lingüístico que vamos a utilizar para controlar el agente.
llm = OpenAI(temperature=0)

# A continuación, vamos a cargar algunas herramientas a utilizar. Ten en cuenta que la herramienta `llm-math` utiliza un LLM, así que tenemos que pasarlo.
tools = load_tools(["serpapi"], llm=llm)


# Por último, vamos a inicializar un agente con las herramientas, el modelo de lenguaje y el tipo de agente que queremos utilizar.
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# ¡Ahora vamos a probarlo!
agent.run("What was the high temperature in Madrid yesterday in Celsius?")

'The high temperature in Madrid yesterday in Celsius was 21.5°C.'

Memoria: Añadir estado a cadenas y agentes

Hasta ahora, todas las cadenas y agentes por los que hemos pasado han sido sin estado. Pero a menudo, es posible que quieras que una cadena o agente tenga algún concepto de "memoria" para que pueda recordar información sobre sus interacciones anteriores. El ejemplo más claro y sencillo de esto es el diseño de un chatbot: quieres que recuerde mensajes anteriores para que pueda utilizar su contexto para mantener una conversación mejor. Esto sería un tipo de "memoria a corto plazo". En el lado más complejo, se podría imaginar una cadena/agente que recordara piezas clave de información a lo largo del tiempo: esto sería una forma de "memoria a largo plazo".

from langchain import OpenAI, ConversationChain

llm = OpenAI(temperature=0)
conversation = ConversationChain(llm=llm, verbose=True)

output = conversation.predict(input="Hi there!")
print(output)

Hi there! It's nice to meet you. How can I help you today?

Creación de una aplicación de modelos lingüísticos: Modelos de chat

Del mismo modo, puedes utilizar modelos de chat en lugar de LLM. Los modelos de chat son una variación de los modelos de lenguaje. Aunque los modelos de chat utilizan modelos lingüísticos, la interfaz que exponen es un poco diferente: en lugar de exponer una API de "entrada de texto, salida de texto", exponen una interfaz en la que los "mensajes de chat" son las entradas y salidas.

Las API de modelos de chat son bastante nuevas.

Plantillas de mensajes de chat

De forma similar a los LLMs, puedes hacer uso de plantillas utilizando un MessagePromptTemplate.

Puedes construir un ChatPromptTemplate a partir de uno o más MessagePromptTemplates. Puede utilizar el format_prompt de ChatPromptTemplate - esto devuelve un PromptValue, que puede convertir en una cadena o en un objeto Message, dependiendo de si desea utilizar el valor formateado como entrada a un modelo llm o chat.

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

chat = ChatOpenAI(temperature=0)

template = "You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

# Obtén una finalización de chat a partir de los mensajes formateados
chat(chat_prompt.format_prompt(input_language="English", output_language="Spanish", text="I love programming.").to_messages())

AIMessage(content='Me encanta programar.', additional_kwargs={}, example=False)

Cadenas con modelos de chat

La LLMChain comentada en la sección anterior también puede utilizarse con modelos de chat:

from langchain.chat_models import ChatOpenAI
from langchain import LLMChain
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

chat = ChatOpenAI(temperature=0)

template = "You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

chain = LLMChain(llm=chat, prompt=chat_prompt)
chain.run(input_language="English", output_language="Spanish", text="I love programming.")

'Me encanta programar.'

Agentes con modelos de chat

Los agentes también se pueden utilizar con modelos de chat, puedes inicializar uno utilizando AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTIONcomo tipo de agente.

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI

# En primer lugar, vamos a cargar el modelo de lenguaje que vamos a utilizar para controlar el agente.
chat = ChatOpenAI(temperature=0)

# A continuación, vamos a cargar algunas herramientas a utilizar. Ten en cuenta que la herramienta `llm-math` utiliza un LLM, así que tenemos que pasarlo.
llm = OpenAI(temperature=0)
tools = load_tools(["serpapi"], llm=llm)

# Por último, vamos a inicializar un agente con las herramientas, el modelo de lenguaje y el tipo de agente que queremos utilizar.
agent = initialize_agent(tools, chat, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# ¡Ahora vamos a probar!
agent.run("Who is Allan Turing's father?")

"Allan Turing's father was Julius Mathison Turing."

Memoria: Añadir estado a cadenas y agentes

Puedes utilizar la memoria con cadenas y agentes inicializados con modelos de chat. La principal diferencia entre esto y y l amemoria para LLMs es que en lugar de intentar condensar todos los mensajes anteriores en una cadena, podemos mantenerlos como su propio objeto de memoria único.

from langchain.prompts import (
    ChatPromptTemplate, 
    MessagesPlaceholder, 
    SystemMessagePromptTemplate, 
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])

llm = ChatOpenAI(temperature=0)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)

conversation.predict(input="Hi there!")

'Hello! How can I assist you today?'

conversation.predict(input="I'm doing well! Just having a conversation with an AI.")

"That sounds like fun! I'm happy to chat with you. Is there anything specific you'd like to talk about?"

conversation.predict(input="Tell me about yourself.")

"Sure! I am an AI language model designed to assist with various tasks such as answering questions, generating text, and providing recommendations. I was created using natural language processing techniques and machine learning algorithms, which allow me to understand and respond to human language. I am constantly learning and improving based on the interactions I have with users like you. Is there anything else you'd like to know?"

Recursos adicionales

• Documentación Langchain

  https://python.langchain.com/en/latest/getting_started/getting_started.html

• DeepLearning.AI Short Courses

---

Soy Samu Sarmiento, embajador de thirdweb y desarrollador de software. Mi experiencia incluye trabajar con TypeScript y frameworks populares como React, Next.js y Node.js, así como construir aplicaciones Web 3.0 usando thirdweb.

A Junio de 2023, llevo aproximadamente tres meses investigando el mundo de la inteligencia artificial, machine learning, deep learning, modelos de lenguaje, agentes autónomos.... Y de ahí nacen estas guías/tutoriales ;)

En los próximos días y semanas estaré trayendoles en mi Newsletter más notícias, actualizaciones, nuevos agentes o frameworks. Nuevos casos de uso. Y sobretodo muchos tutoriales y guías prácticas para que no pierdas mucho tiempo investigando y puedas poner en marcha tus ideas rápidamente.

Espero que les guste y la disfruten. Todo feedback es más que bienvenido, contacta conmigo en Twitter directamente ( @SamuSarmiento_ ).

---

¡Y eso es todo por hoy! Espero que hayas adquirido una comprensión superficial de las capacidades de LangChain. Si quieres seguir leyendo guías y tutoriales como este o el anterior, estar al día sobre AI, AGI, LLMs y productos potenciados por IA:

1. Sígueme en Twitter

2. Suscríbete a mi Newsletter para no perderte las últimas noticias sobre Agentes autónomos, LLMs y productos potenciados por IA.

3. ⭐ el repo de Github mientras tanto para recibir actualizaciones.