Desarrollo de aplicaciones LLM utilizando LangChain y el modelo de lenguaje Cohere

Seguramente estemos cansados de escuchar términos como LLM, IA Generativa o automatización y un sinfín de personas que animadas por la facilidad de uso de las herramientas de inteligencia artificial se han «subido a este carro». Sin embargo, desde una perspectiva puramente técnica se aprecia una clara falta de comprensión con respecto a su correcta aplicación e integración en cualquier tipo de desarrollo donde sea necesaria. El hecho de que tantas personas hayan accedido a este ámbito sin un background técnico, al menos lo que puedo llegar a percibir yo, está evidenciando una falta de optimización derivada de la confianza en las respuestas que generan los diferentes clientes (chats) de estos modelos de grandes lenguajes. Por esta razón el artículo de hoy trata de explicar de manera sencilla y para todo tipo de públicos cómo generar la base de una aplicación desarrollada en Python para la interpretación y utilización de este tipo de modelos. Lo primero como siempre será incluir algunas librerías básicas que se utilizarán a lo largo del desarrollo:

 

LangChain

Es un framework de código abierto diseñado para desarrollar aplicaciones utilizando modelos de lenguaje de gran tamaño (LLM). Estos modelos, que son redes neuronales profundas entrenadas con enormes volúmenes de datos, pueden generar respuestas a las consultas de los usuarios, como responder preguntas o crear imágenes a partir de solicitudes textuales. LangChain ofrece herramientas y abstracciones que mejoran la personalización, precisión y relevancia de la información producida por los modelos. Por ejemplo, los desarrolladores pueden emplear los componentes de LangChain para crear nuevas secuencias de solicitudes o personalizar plantillas ya existentes. Muchas de estas aplicaciones desarrolladas con LangChain constan de varios pasos y múltiples llamadas a LLM. Por esta razón, a medida que estas aplicaciones se vuelven más complejas, es esencial poder examinar en detalle lo que sucede dentro de la cadena o el agente. Para ello, una muy buena opción es la utilización de LangSmith. 

# In [1]

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "...85d5"

Cohere

Esta plataforma facilita a los desarrolladores y empresas la creación de aplicaciones basadas en LLM a través de modelos implementados de forma segura y privada. La familia de modelos Command (especializados en el desarrollo de chats y generación de texto) abarca: Command, Command R y Command R+. Estos modelos son los LLM que generan texto para impulsar agentes conversacionales, resúmenes, redacción de contenido y otros casos de uso similares. Operan a través del endpoint Chat, el cual puede utilizarse con o sin generación aumentada mediante recuperación (RAG). En este caso, para el ejercicio práctico voy a utilizar el modelo Command R como se ve a continuación:

# In [2]


import os
os.environ["COHERE_API_KEY"] = "...PoqUa"
from langchain_cohere import ChatCohere # type: ignore
model = ChatCohere(model="command-r")

Implementación paso a paso

El modelo devuelve una respuesta AIMessage que incluye una cadena de texto junto con otros metadatos. En la mayoría de ocasiones, es interesante trabajar únicamente con la cadena de respuesta. Esto se puede hacer de manera sencilla utilizando un output parser básico.

# In [3]


from langchain_core.output_parsers import StrOutputParser 
parser = StrOutputParser()

Los PromptTemplates son un concepto de LangChain diseñados para facilitar esta transformación. Estos templates reciben la entrada directa del usuario y devuelven un prompt listo para ser utilizado por un modelo de lenguaje. Por ejemplo, en el caso que nos acontece, se han creado dos variables {experto} y {texto} para dar respuesta al comportamiento que debe tener el sistema e integrar la propuesta del usuario respectivamente. 

# In [4]


from langchain_core.prompts import ChatPromptTemplate
system_template = "Actúa como un experto {experto} y ayúdame con la siguiente pregunta:"


prompt_template = ChatPromptTemplate.from_messages(
    [("system", system_template), ("user", "{texto}")]
)

Ya solo quedaría unificar (pipeline) todos los componentes (modelo, parser y template) usando el comando «|».

# In [5]


chain = prompt_template | model | parser

Respuesta del modelo

En este caso he optado por crear algo sencillo para mostrar la respuesta directamente en el notebook. Básicamente consta de dos variables de tipo input donde deberemos escribir «qué rol debe adoptar el modelo» y «cuál es la tarea o pregunta». 

# In [6]


import pprint


experto = input()
print('Experto: ' + experto)
texto = input()
print('Pregunta: ' + texto)


def formatear_texto(data, width=160):
    formatted_data = pprint.pformat(data, width=width)
    formatted_data = formatted_data.replace("'", "").replace('"', '').replace('\n', ' ').replace('(', '').replace(')', '')
    print(formatted_data)

text = chain.invoke({"experto": experto, "texto": texto})
formatear_texto(text)