Construyendo aplicaciones de IA generativa con LangChain y OpenAI API

Construyendo aplicaciones de IA con LangChain y OpenAI API

Introducción

La IA generativa está liderando la última ola tecnológica en la industria. Aplicaciones de IA generativa como generación de imágenes, generación de texto, resumen y chatbots de pregunta y respuesta, entre otros, están en auge. A medida que OpenAI lideró recientemente la ola de modelos de lenguaje grandes, muchas startups desarrollaron herramientas y marcos para permitir a los desarrolladores construir aplicaciones innovadoras utilizando estos LLMs. Una de estas herramientas es LangChain, un marco para desarrollar aplicaciones impulsadas por LLMs con composabilidad y confiabilidad. LangChain se ha convertido en la herramienta preferida para los desarrolladores de IA de todo el mundo para construir aplicaciones de IA generativa. LangChain también permite conectar fuentes de datos externas e integrarse con muchos LLMs disponibles en el mercado. Además de esto, las aplicaciones impulsadas por LLM requieren una base de datos de almacenamiento de vectores para almacenar los datos que recuperarán más adelante. En este blog, aprenderemos sobre LangChain y sus funciones construyendo una tubería de aplicación con la API de OpenAI y ChromaDB.

Objetivos de aprendizaje:

  • Aprender los fundamentos de LangChain para construir una tubería de IA generativa
  • Incrustación de texto utilizando modelos de código abierto y bases de datos de almacenamiento de vectores como Chromadb
  • Aprender a usar las API de OpenAI con LangChain para integrar LLMs en su aplicación

Este artículo fue publicado como parte del Data Science Blogathon.

Resumen de un LangChain

LangChain se ha convertido recientemente en un marco popular para aplicaciones de modelos de lenguaje grandes. LangChain proporciona un marco sofisticado para interactuar con LLMs, fuentes de datos externas, indicaciones e interfaces de usuario.

Propuestas de valor de LangChain

Las principales propuestas de valor de LangChain son:

  • Componentes: Estas son las abstracciones necesarias para trabajar con modelos de lenguaje. Los componentes son modulares y fáciles de usar para muchos casos de uso de LLM.
  • Cadenas predefinidas: Un conjunto estructurado de varios componentes y módulos para lograr una tarea específica, como resumen, pregunta y respuesta, etc.

Detalles del proyecto

LangChain es un proyecto de código abierto y, desde su lanzamiento, el proyecto ha obtenido más de 54K+ estrellas en Github, lo que muestra la popularidad y aceptabilidad del proyecto.

El archivo readme del proyecto describe el marco de la siguiente manera:

Los modelos de lenguaje grandes (LLMs) están emergiendo como una tecnología transformadora que permite a los desarrolladores construir aplicaciones que antes no podían. Sin embargo, usar estos LLMs de forma aislada a menudo es insuficiente para crear una aplicación realmente poderosa: el verdadero poder radica en combinarlos con otras fuentes de cálculo o conocimiento.

Fuente: Repositorio del proyecto

Claramente, define el propósito del marco con el objetivo de ayudar en el desarrollo de aplicaciones donde se aprovecha el conocimiento del usuario.

Componentes de LangChain (fuente: ByteByteGo)

LangChain tiene seis componentes principales para construir aplicaciones de LLM: entrada/salida del modelo, conexiones de datos, cadenas, memoria, agentes y devoluciones de llamada. El marco también permite la integración con muchas herramientas para desarrollar aplicaciones de pila completa, como OpenAI, Huggingface Transformers y almacenes de vectores como Pinecone y chromadb, entre otros.

Explicación completa de los componentes:

  1. Entrada/salida del modelo: Interfaz con modelos de lenguaje. Consiste en indicaciones, modelos y analizadores de salida
  2. Conexión de datos: Interfaz con fuentes de datos específicas de la aplicación con transformadores de datos, divisores de texto, almacenes de vectores y recuperadores de datos
  3. Cadenas: Construye una secuencia de llamadas con otros componentes de la aplicación de IA. Algunos ejemplos de cadenas son cadenas secuenciales, cadena de resumen y cadenas de pregunta y respuesta de recuperación
  4. Agentes: LangChain proporciona agentes que permiten a las aplicaciones utilizar una cadena dinámica de llamadas a varias herramientas, incluidos LLMs, según la entrada del usuario.
  5. Memoria: Persiste el estado de la aplicación entre las ejecuciones de una cadena
  6. Devoluciones de llamada: Registra y transmite los pasos de las cadenas secuenciales para ejecutar las cadenas de manera eficiente y controlar el consumo de recursos

A continuación, veamos algunos de los casos de uso para LangChain.

  1. Respuesta a preguntas o chat sobre documentos específicos
  2. Chatbots
  3. Resumen
  4. Agentes
  5. Interacción con APIs

Estos son algunos de los muchos casos de uso. Aprenderemos y desarrollaremos una aplicación de búsqueda semántica para responder preguntas sobre documentos específicos utilizando las APIs de OpenAI y ChromaDB, una base de datos de vectores de código abierto. Para obtener más información sobre el marco de trabajo de LangChain, recomiendo leer la documentación oficial. (Enlace: aquí)

Configuración del entorno y carga de documentos

Ahora, configuraremos un entorno para nuestra aplicación de búsqueda semántica utilizando las APIs de LLM de OpenAI para responder preguntas de los usuarios sobre un conjunto de documentos. En este artículo estamos utilizando documentos de muestra, pero tú puedes usar tus propios documentos para construir una aplicación de respuesta a preguntas. Primero, debemos instalar las siguientes bibliotecas:

Instalando las dependencias del proyecto

# instalar openai, langchain, sentence transformers y otras dependencias
!pip install openai langchain sentence_transformers -q
!pip install unstructured -q

# instalar las dependencias del entorno
!pip install pydantic==1.10.8
!pip install typing-inspect==0.8.0 typing_extensions==4.5.
!pip install chromadb==0.3.26

LangChain requiere algunas dependencias de entorno con una versión específica, como pydantic, typing extensions y ChromaDB. Una vez que la instalación se haya completado, puedes ejecutar el siguiente código en tu entorno de Colab o en cualquier otro entorno de bloc de notas.

Cargador de documentos de LangChain

LangChain proporciona clases de cargador de documentos para cargar documentos desde la entrada del usuario o desde una base de datos. Admite varios formatos de archivo, como HTML, JSON, CSV, etc. Tenemos algunos archivos de texto que utilizaremos en nuestro caso de uso. Puedes encontrar los archivos en el repositorio de GitHub. (Repositorio de GitHub – Enlace)

# importar el cargador de directorio de langchain desde los cargadores de documentos
from langchain.document_loaders import DirectoryLoader

# ruta del directorio
directorio = '/content/pets'

# función para cargar los documentos de texto
def cargar_docs(directorio):
  cargador = DirectoryLoader(directorio)
  documentos = cargador.load()
  return documentos

documentos = cargar_docs(directorio)
len(documentos)

---------------------------[Salida]----------------------------------------
[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Unzipping tokenizers/punkt.zip.
[nltk_data] Downloading package averaged_perceptron_tagger to
[nltk_data]     /root/nltk_data...
[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.
5

Una vez que los datos se cargan, utilizaremos un divisor de texto para dividir los documentos de texto en fragmentos de tamaño fijo para almacenarlos en la base de datos de vectores. LangChain ofrece varios divisores de texto, como dividir por carácter, dividir por código, etc.

# usar el divisor de texto para dividir el texto en fragmentos
from langchain.text_splitter import RecursiveCharacterTextSplitter

# dividir los documentos en fragmentos usando el divisor de caracteres recursivo
def dividir_docs(documentos, tamaño_fragmento=1000, superposición_fragmentos=20):
  divisor_texto = RecursiveCharacterTextSplitter(chunk_size=tamaño_fragmento, chunk_overlap=superposición_fragmentos)
  docs = divisor_texto.split_documents(documentos)
  return docs

# almacenar los documentos divididos en la variable docs
docs = dividir_docs(documentos)

Una vez que los documentos se convierten en fragmentos, los incrustaremos en un vector utilizando modelos de incrustación de código abierto en la siguiente sección.

Incrustación de texto utilizando LangChain y modelo de código abierto

La incrustación de textos es el concepto más importante en el desarrollo de aplicaciones LLM. Todos los documentos de texto deben ser vectorizados antes de poder ser procesados para tareas como búsqueda semántica, resumen, etc. Utilizaremos el modelo de incrustación de texto de código abierto “all-MiniLM-L6-v2” para las incrustaciones de texto. Una vez que los documentos estén incrustados, podemos almacenarlos en la base de datos de vectores de código abierto ChromaDB para realizar una búsqueda semántica. Veamos un ejemplo de código práctico.

# incrustaciones utilizando langchain
from langchain.embeddings import SentenceTransformerEmbeddings
incrustaciones = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")

# utilizando chromadb como almacenamiento de vectores y almacenando los documentos en él
from langchain.vectorstores import Chroma
db = Chroma.from_documents(docs, incrustaciones)

# Realizando búsqueda de similitud usando consulta
consulta = "¿Cuáles son los diferentes tipos de mascotas que la gente suele tener?"
documentos_coincidentes = db.similarity_search(consulta)

documentos_coincidentes[0]

--------------------------[Salida]----------------------------------------
Document(page_content='Los animales de compañía vienen en todas las formas y tamaños,
cada uno adecuado para diferentes estilos de vida y entornos domésticos.
Los perros y los gatos son los más comunes, conocidos por su compañía
y personalidades únicas. Los pequeños mamíferos como hámsters, cobayas,
y conejos se eligen a menudo por sus necesidades de bajo mantenimiento.
Las aves ofrecen belleza y canto, y los reptiles como las tortugas y
los lagartos pueden ser mascotas intrigantes. Incluso los peces, con su presencia calmante,
pueden ser mascotas maravillosas.', 
metadata={'source': '/content/pets/Different Types of Pet Animals.txt'})

En el código anterior, utilizamos embeddings para almacenar en ChromaDB, que admite almacenamiento en memoria, para poder consultar la base de datos y obtener la respuesta de nuestros documentos de texto. Pedimos conocer diferentes tipos de mascotas comúnmente poseídas por las personas, y obtuvimos una respuesta correcta con la fuente de la respuesta.

Aplicaciones de IA generativa utilizando OpenAI APIs, ChromaDB y LangChain

Búsqueda semántica de preguntas y respuestas utilizando LangChain y OpenAI APIs

Este pipeline implica interpretar la intención y el contexto de los términos de búsqueda y los documentos para producir resultados de búsqueda más precisos. Puede aumentar la precisión de la búsqueda al comprender la intención del usuario, examinar las conexiones entre palabras y conceptos, y producir resultados de búsqueda conscientes del contexto utilizando mecanismos de atención en el procesamiento del lenguaje natural (NLP).

LangChain ofrece una interfaz de chat de OpenAI para llamar a las APIs del modelo en tu aplicación y crear un pipeline de preguntas/respuestas que responda a las consultas de los usuarios en función del contexto o los documentos de entrada proporcionados. Básicamente realiza una búsqueda vectorizada para encontrar la respuesta más similar a la pregunta. (Consulta el diagrama de flujo a continuación).

Pipeline de búsqueda basado en el contexto (fuente: LangChain Docs)
# inserta una clave de openai debajo del parámetro
import os
os.environ["OPENAI_API_KEY"] = "TU-CLAVE-OPENAI"

# carga el modelo LLM
from langchain.chat_models import ChatOpenAI
model_name = "gpt-3.5-turbo"
llm = ChatOpenAI(model_name=model_name)

# Utilizando la cadena de preguntas y respuestas para obtener la respuesta a nuestra consulta
from langchain.chains.question_answering import load_qa_chain
chain = load_qa_chain(llm, chain_type="stuff",verbose=True)

# escribe tu consulta y realiza una búsqueda de similitud para generar una respuesta
query = "¿Cuáles son los beneficios emocionales de tener una mascota?"
matching_docs = db.similarity_search(query)
answer =  chain.run(input_documents=matching_docs, question=query)
answer

-----------------------------------[Resultados]---------------------------------
'Tener una mascota puede proporcionar numerosos beneficios emocionales. Las mascotas ofrecen compañía y pueden ayudar a reducir los sentimientos de soledad y aislamiento. Brindan amor y apoyo incondicional, lo que puede mejorar el estado de ánimo y el bienestar general. La interacción con las mascotas, como acariciarlas o jugar con ellas, ha demostrado disminuir los niveles de hormonas del estrés y aumentar la liberación de oxitocina, una hormona asociada con el vínculo y la relajación. Las mascotas también ofrecen un sentido de propósito y responsabilidad, ya que cuidar de ellas puede brindar una sensación de plenitud y distraer de los estresores diarios. Además, el vínculo entre las mascotas y sus dueños puede proporcionar una sensación de estabilidad y consistencia durante momentos de estrés personal o social.'

El código anterior llama a la API del modelo “gpt-3.5-turbo” utilizando la función ChatOpenAI() de LangChain y crea una cadena de preguntas y respuestas para responder a nuestra consulta. Para obtener información más detallada sobre el código, puedes visitar la documentación oficial de LangChain (aquí) y el cuaderno de código en Github (aquí)

Generar nombres de empresas utilizando LLMChain

Otro caso de uso del modelo de lenguaje grande es generar nombres de empresas utilizando LLMChain, OpenAI LLM y PromptTemplate de LangChain. Puedes generar nombres de empresas o productos basados en la descripción proporcionada como indicación. Consulta el siguiente código:

# importa los componentes necesarios de langchain 
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# LLM por OpenAI 
llm = OpenAI(temperature=0.9)

# Escribe una indicación utilizando PromptTemplate
prompt = PromptTemplate(
    input_variables=["product"],
    template="¿Cuál es un buen nombre para una empresa que fabrica {product}?",
)

# crea una cadena utilizando LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

# Ejecuta la cadena especificando solo la variable de entrada.
print(chain.run("calcetines coloridos"))

Resultado>>>    Colorful Toes Co.

Resumen de Documentos de Texto Utilizando Cadenas de LangChain

Las cadenas también permiten el desarrollo de aplicaciones de resumen de texto que pueden ser útiles en la industria legal para resumir grandes cantidades de documentos legales y acelerar el proceso judicial. Consulte el código de ejemplo a continuación utilizando la función de LangChain:

# from langChain import load_suumarize_chain function and OpenAI llm
from langchain.llms import OpenAI
from langchain.chains.summarize import load_summarize_chain

# LLM de OpenAI 
llm = OpenAI(temperature=0.9)

# crea una instancia de cadena con OpenAI LLM con el tipo de cadena de map_reduce
chain = load_summarize_chain(llm, chain_type="map_reduce")
chain.run(docs)

La interfaz fácil de usar de LangChain desbloquea muchas aplicaciones diferentes y resuelve muchos problemas para los usuarios finales. Como puede ver, con unas pocas líneas de código simples, podemos aprovechar el poder de los LLM para resumir cualquier dato de cualquier fuente en la web.

Conclusión

En conclusión, la publicación del blog exploró el emocionante campo de construir aplicaciones de IA generativas utilizando LangChain y las APIs de OpenAI. Vimos una descripción general de LangChain, sus diversos componentes y casos de uso para aplicaciones de LLM. La IA generativa ha revolucionado varios campos, permitiéndonos generar texto realista, imágenes, videos y más. La búsqueda semántica es una aplicación utilizada para construir aplicaciones de preguntas y respuestas utilizando LLMs de OpenAI como GPT-3.5 y GPT-4. Veamos las principales conclusiones de este blog:

  1. Aprendimos sobre una breve descripción general de LangChain, un marco de código abierto para construir aplicaciones impulsadas por LLM.
  2. Aprendimos a utilizar LangChain y ChromaDB, una base de datos de vectores para almacenar incrustaciones para aplicaciones de búsqueda de similitud.
  3. Finalmente, aprendimos sobre las APIs de OpenAI LLM para construir aplicaciones de IA generativas utilizando LangChain.

Preguntas Frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

OpenAI presenta DALL·E 3 Un salto revolucionario en la generación de texto a imagen

En un salto tecnológico significativo, OpenAI ha anunciado el lanzamiento de DALL·E 3, la última iteración en su revo...

Aprendizaje Automático

Detectando el Crecimiento del Cáncer Utilizando Inteligencia Artificial y Visión por Computadora.

El cáncer de mama es una de las formas más mortales de cáncer en mujeres. Según la Organización Mundial de la Salud (...

Inteligencia Artificial

¿Por qué los humanos temen a la inteligencia artificial AI?

El ritmo de innovación en la Inteligencia Artificial (IA) es asombroso. La IA es ahora la fuerza impulsora detrás de ...

Inteligencia Artificial

Mejora Amazon Lex con LLMs y mejora la experiencia de las preguntas frecuentes utilizando la ingestión de URL

En el mundo digital de hoy, la mayoría de los consumidores prefieren encontrar respuestas a sus preguntas de servicio...

Inteligencia Artificial

Este artículo de IA explica cómo los lenguajes de programación pueden potenciarse entre sí a través de la sintonización de instrucciones.

La introducción de los Modelos de Lenguaje Grande (LLMs) ha causado sensación en el mundo. Estos modelos son famosos ...

Inteligencia Artificial

El mundo natural potencia el futuro de la visión por computadora

Un sistema de software de código abierto tiene como objetivo mejorar el entrenamiento de sistemas de visión por compu...