Introducción a LangChain

1

Creación de un sistema de preguntas y respuestas con LangChain

2

Estructura y Uso de Langchain en Python

3

Carga de Modelos Open Source con Lanchain y Hugging Face

4

Uso de Modelos OpenAI con LangChain: Guía Práctica para Principiantes

5

Creación de Prompts Dinámicos con LangChain

6

Uso de Cadenas en Modelos de Lenguaje con Language Chain

7

Procesamiento de PDFs y creación de resúmenes con LangChain

8

Creación de Cadenas de Preguntas y Respuestas con Modelos de Lenguaje

9

Creación de cadenas secuenciales en Python para procesamiento de texto

Quiz: Introducción a LangChain

Casos de uso de LangChain

10

Aplicaciones y Beneficios de Lancheng en el Manejo de LLMs

11

Implementación de Lanchain y LLMs: Costos, Privacidad y Buenas Prácticas

Quiz: Casos de uso de LangChain

Manejo de documentos con índices

12

Carga de Documentos en Langchain para Creación de Índices

13

Fundamentos de la Clase Document en Langchain

14

Carga y Transformación de Documentos No Estructurados con Landship

15

Lectura de CSV y conversión a DataFrame de Pandas y LangChain

16

Creación de un Cargador de JSON-Lines Personalizado en Python

17

Fragmentación de Documentos con TextSplitter en Langsteam

18

Creación de un Chatbot con Documentación de Hugging Face

19

Creación de Índice Vectorial con Langchain y Embeddings

Quiz: Manejo de documentos con índices

Embeddings y bases de datos vectoriales

20

Creación de Índices con Embeddings y Bases de Datos Vectoriales

21

Creación y uso de embeddings con OpenAI y Lanchain

22

Modelos de Embeddings Open Source en Español con Sentence Transformers

23

Creación y Gestión de Bases de Datos Vectoriales con Chroma

24

Creación y manejo de bases de datos vectoriales con OpenAI Embeddings

25

Creación y Uso de un Retriever en Chroma para Consultas Avanzadas

26

Modelo de Chat para Preguntas y Respuestas con LangChain y Chroma

27

Creación de un Chatbot para Preguntas con Bases de Datos Vectoriales

Quiz: Embeddings y bases de datos vectoriales

Chats y memoria con LangChain

28

Memoria de Corto Plazo en Chatbots: Implementación y Optimización

29

Creación y Uso de Modelos de Chat con OpenAI y LangChain

30

Creación de Plantillas Dinámicas para Prompts de Chat en Langstead

31

Memoria en chatbots: Implementación con ConversationBufferMemory

32

Configuración de ConversationBufferWindowMemory en Chatbots

33

Memoria de Resumen de Conversaciones con Chat GPT-3.5

34

Gestión de Memoria en Chatbots con ConversationSummaryBufferMemory

35

Memoria de Entidades en Chatbots para Soporte de Ventas

36

Implementación de Chatbot con Memoria en Python usando Langchain

Quiz: Chats y memoria con LangChain

Evolución del uso de LLM

37

Creación de Chatbots con Modelos de Lenguaje y Bases de Datos Vectoriales

Curso de LangChain

Curso de LangChain

Omar Espejel

Omar Espejel

Creación de un sistema de preguntas y respuestas con LangChain

1/37
Recursos
Transcripción

Aportes 34

Preguntas 17

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

No entendi un carajo.

Wow 🤯. Veo mucho campo de aplicación de LangChain para desarrollar aplicaciones muy útiles. Muy buen nivel de explicación por parte de Omar, felicidades 👏🏽

Hola comunidad.

Les comparto mi código con leves modificaciones y con comentarios pertinentes.

# --- Carga de documents
import os
import requests
from dotenv import load_dotenv
from langchain.document_loaders import PyPDFLoader

# leo el archivo keys.env y obtengo mi Api KEY de OpenAI
load_dotenv("../secret/keys.env")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

# Es importante que quede seteado como una variable de entorno porque será utilizado más adelante
os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY

urls = [
    'https://arxiv.org/pdf/2306.06031v1.pdf',
    'https://arxiv.org/pdf/2306.12156v1.pdf',
    'https://arxiv.org/pdf/2306.14289v1.pdf',
    'https://arxiv.org/pdf/2305.10973v1.pdf',
    'https://arxiv.org/pdf/2306.13643v1.pdf'
]

ml_papers = []

for i, url in enumerate(urls):
    filename = f'paper{i+1}.pdf'

    # Verifico si el archivo no ha sido descargado previamente
    if not os.path.exists(filename):
        response = requests.get(url)
        with open(filename, 'wb') as f:
            f.write(response.content)
        print(f'Descargado {filename}')
    else:
        print(f'{filename} ya existe, cargando desde el disco.')

    loader = PyPDFLoader(filename)
    data = loader.load()
    ml_papers.extend(data)

# Utiliza la lista ml_papers para acceder a los elementos de todos los documentos descargados
print('Contenido de ml_papers:')
print()

print(type(ml_papers), len(ml_papers), ml_papers[3])

# --- Split de documents

# Los documentos NO pueden ser procesados directamente por LLMs porque contienen demasiado texto, sin embargo, podemos
# particionarlo en conjuntos de texto más pequeños para entonces poder acceder a su información.
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Cada partición contendrá 1500 palabras, y tendrán una intersección de 200, de modo que la cadena 2 comparte 200
# palabras con la cadena 1 y con la cadena 3
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
    length_function=len
    )

documents = text_splitter.split_documents(ml_papers)
# Ahora podemos revisar de nuevo la cantidad de `documentos` y ver un ejemplo del mismo
print(len(documents), documents[10])

# --- Embeddings e ingesta a base de datos vectorial

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Crea un objeto capaz de convertir el texto a un vector utilizando como base el modelo de ADA-002 de OpenAI
# En este punto es importante que hayas seteado tu OPENAI API KEY como variable de entorno, para que puedas acceder
# a este servicio
embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")

# Con ayuda de Chroma, creamos un objeto vectorstore para almacenar las representaciones vectoriales de los textos
# contenidos en `documents` una cadena de texto previamente generada

vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=embeddings
)

# Una vez que hayas creado la Base de datos vectorial, el parámetro search_kwargs `k` me permite definir hasta cuantos
# vectores similares voy a buscar al momento de encontrar información para una pregunta. `retriever` será entonces
# nuestra base de datos de vectores que servirá para añadir información reciente a los LLMs con el fin de responder
# preguntas.
retriever = vectorstore.as_retriever(
    search_kwargs={"k": 3}
    )

# --- Modelos de Chat y cadenas para consulta de información

from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA


# Voy a crear un objeto `chat` de la clase ChatOpenAI indicando que el engine a utilizar será GPT 3.5 y cuya temperatura
# será 0 lo que signfica que tendrá respuestas muy restrictivas basadas únicamente en el texto que conoce y tendrá
# poca creatividad al momento de responder peticiones.
chat = ChatOpenAI(
    openai_api_key=OPENAI_API_KEY,
    model_name='gpt-3.5-turbo',
    temperature=0.0
)

# Finalmente, creamos una cadena `chain` del tipo `Question Answer` pregunta-respuesta. Como LLM utilizará al objeto
# `chat` que es una instancia de ChatGPT 3.5, el tipo de cadena es `stuff` que significa que vamos a utilizar tanta
# información como quepa en el prompt, y finalmente el `retriever` será la base de datos vectoriales que hemos definido
# previamente.
qa_chain = RetrievalQA.from_chain_type(
    llm=chat,
    chain_type="stuff",
    retriever=retriever
)

# Vamos a poner a prueba nuestra cadena de preguntas y respuestas:

query = "qué es fingpt?"
print(query)
print(qa_chain.run(query))

query = "qué hace complicado entrenar un modelo como el fingpt?"
print(query)
print(qa_chain.run(query))

query = "qué es fast segment?"
print(query)
print(qa_chain.run(query))

query = "cuál es la diferencia entre fast sam y mobile sam?"
print(query)
print(qa_chain.run(query))

Extremadamente útil considerando que Llama 2 acaba de salir esta semana. Así que obligado a probarlo con llama2

Primer video del curso, y ya llovieron golpes de todos lados 😅

Majestuoso este curso e iniciando con todo

A despatar una habilidad nueva en la Vida!!

Buen inicio de curso, grandes expectativas…

Tremendo inicio del curso, grandes expectativas, buen contenido.

13:08 Tuve problemas con Chromadb y lo solucioné con **Solución** Sigue estos pasos para resolver el problema: #### **1. Instalar Microsoft C++ Build Tools** Este es un requisito para compilar ciertas bibliotecas de Python en Windows. 1. Ve al siguiente enlace para descargar los Build Tools: [Microsoft C++ Build Tools ](https://visualstudio.microsoft.com/visual-cpp-build-tools/)<https://visualstudio.microsoft.com/es/visual-cpp-build-tools/> 2. Descarga e instala los Build Tools. Durante la instalación: * Selecciona la opción **"Desarrollo para escritorio con C++"**. * Asegúrate de incluir las herramientas de compilación necesarias, como: * **MSVC (Microsoft Visual C++)** * **CMake Tools para Windows** * **SDK de Windows** 3. Una vez instalado, reinicia tu terminal. #### **2. Actualizar pip, setuptools y wheel** Antes de intentar instalar nuevamente, actualiza las herramientas relacionadas con la construcción de paquetes de Python: ```js pip install --upgrade pip setuptools wheel ``` #### **3. Instalar nuevamente el paquete** Intenta instalar nuevamente `chromadb`: ```js pip install chromadb ```Esto debería compilar y construir las dependencias necesarias, incluyendo **chroma-hnswlib**. #### **4. Verificar la instalación** Para confirmar que todo se instaló correctamente, ejecuta: ```js pip show chromadb ```Deberías ver información sobre el paquete, como su versión y ubicación.

Es interesante que los archivos pdf están en inglés y aún así la chain responde en español. Digo curioso porque al hacer los embeddings en la base de datos vectorial están en inglés los chunks, y la pregunta se hace en español, y dicha pregunta en español se convierte a embedding para hacer búsqueda por similaridad a los textos guardados previamente en inglés. Me hace pensar que los embeddings de text-embedding-ada-002 de OpenAI son entrenados en múltiples lenguajes y extraen el contexto y contenido semántico de las palabras sin importar el lenguaje

Cuando yo subo información privada al modelo, el modelo guarda esta información o estos documentos en PDF siguen siendo privados?
alguien me puede ayudar con este error porfa WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 4.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 4.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 4.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 8.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 10.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. \--------------------------------------------------------------------------- RateLimitError Traceback (most recent call last) [\<ipython-input-37-5e00256e2744>](https://localhost:8080/#) in \<cell line: 5>() 3 embeddings = OpenAIEmbeddings(model="text-embedding-ada-002") 4 \----> 5 vectorstore = Chroma.from\_documents( 6 documents=documents, 7 embedding=embeddings 18 frames[/usr/local/lib/python3.10/dist-packages/openai/api\_requestor.py](https://localhost:8080/#) in \_interpret\_response\_line(self, rbody, rcode, rheaders, stream) 773 stream\_error = stream and "error" in resp.data 774 if stream\_error or not 200 <= rcode < 300: \--> 775 raise self.handle\_error\_response( 776 rbody, rcode, resp.data, rheaders, stream\_error=stream\_error 777 ) RateLimitError: You exceeded your current quota, please check your plan and billing details. este es el codigo: from langchain.embeddings import OpenAIEmbeddingsfrom langchain.vectorstores import Chromaembeddings = OpenAIEmbeddings(model="text-embedding-ada-002") vectorstore = Chroma.from\_documents(    documents=documents,    embedding=embeddings) retriever = vectorstore.as\_retriever(    search\_kwargs={"k" : 3})
Buenas! Estoy recibiendo el siguiente Warning en el paso de embeddings e ingesta en base de datos vectorial: WARNING:langchain.embeddings.openai:Retrying langchain.embeddings.openai.embed\_with\_retry.\<locals>.\_embed\_with\_retry in 4.0 seconds as it raised RateLimitError: You exceeded your current quota, please check your plan and billing details.. Entiendo que esto se debe a que justamente no tengo contratado un plan en Open AI y por consiguiente no tengo cuota para consumir la API. Conocen alguna alternativa de otro modelo que pueda usar para adaptar este ejemplo y que sea gratis?. Me gustaría avanzar paso a paso y replicar este mismo ejemplo inicial. Gracias!!!

Empezamos a todo vapor con el mejor Profesor de PLATZI !!!

Wow este curso empieza directo en la acción 🔥

here we go again
Este curso ya esta desactualizado, como va hacer platzi para mantenerse al dia, de forma seguida estos framework se van actualizando, y cuando uno hace el curso no lo puede seguir por que la version usada esta desactualizada.
aún recuerdo cuando los modelos de lenguaje se les eran muy difícil darles contenido externo. Un gran curso.🤖
Indexar documentos se refiere al proceso de organizar y almacenar información de manera que sea fácilmente recuperable. En el contexto de LangChain, esto implica convertir documentos en representaciones numéricas (embeddings) que se almacenan en bases de datos vectoriales. Esto permite que los modelos de lenguaje accedan rápidamente a los datos relevantes para responder preguntas específicas, facilitando la búsqueda y recuperación de información importante. Este proceso es fundamental para crear aplicaciones efectivas que integren inteligencia artificial y datos personalizados.
LangChainDeprecationWarning: Importing chat models from langchain is deprecated. Importing from langchain will no longer be supported as of langchain==0.2.0. Please import from langchain-community instead:
Hola! para los que lo están viendo en Agosto del 2024 con Langchain v0.2, les dejo el código funcional. Se actualizaron algunas librerías y por ende se deben modificar las importaciones, pero el concepto es el mismo. En el video se descargan PDFs desde internet, en mi caso ya tenía un PDF local que quería probar, así que modifiqué un poco ese código así quedó: `from ``langchain_community.document_loaders ``import ``PyPDFLoader` `from ``dotenv ``import ``load_dotenv` `import ``os` `from ``sympy.physics.units ``import ``temperature` `load_dotenv()` `urls = [` ` './quienes_somos.pdf'` `]` `ml_papers = []` `for ``file ``in ``urls:` ` loader = PyPDFLoader(file)` ` data = loader.load()` ` ml_papers.extend(data)` Aquí vamos a cortar nuestros PDFs es pedacitos más pequeños, en mi caso como el PDF era tan pequeño tuve que ponerle un pocos caracteres, pero recomiendo seguir los caracteres del profe mientras se aprende a identificar cuál es la mejor opción: `from ``langchain.text_splitter ``import ``RecursiveCharacterTextSplitter` `text_splitter = RecursiveCharacterTextSplitter(` ` chunk_size=500,` ` chunk_overlap=50,` ` length_function=len,` `)` `documents = text_splitter.split_documents(ml_papers)` Ahora hacemos nuestro proceso de embedding y guardamos en la base de datos vectorial. `from ``langchain_openai ``import ``OpenAIEmbeddings` `from ``langchain_chroma ``import ``Chroma` `embeddings = OpenAIEmbeddings(model="text-embedding-3-large")` `vectorstore = Chroma(` ` embedding_function=embeddings` `)` `vectorstore.add_documents(documents, collection_name="quienes_somos")` `retriever = vectorstore.as_retriever(` ` search_kwargs={"k": 3}` `)` Finalmente configuramos nuestra cadena junto con el modelo de lenguaje a utilizar `from ``langchain_openai ``import ``ChatOpenAI` `from ``langchain.chains ``import ``RetrievalQA` `# Creamos el cliente de OPEN AI` `chat = ChatOpenAI(` ` api_key=os.getenv("OPENAI_API_KEY"),` ` model_name="gpt-4o-mini",` ` temperature=0.0` `)` `qa_chain = RetrievalQA.from_chain_type(` ` llm=chat,` ` chain_type="stuff",` ` retriever=retriever,` `)` Y listo! Ahora a probar! `prompt="Cuales son los tiempos de absorción?"` `qa_chain.invoke(prompt)` En vez de qa\_chain.run ahora se utiliza invoke Feliz aprendizaje!
Librerías actualizadas: ```python %%capture !pip install langchain pypdf openai chromadb tiktoken langchain_community langchain_chroma ```%%capture!pip install langchain pypdf openai chromadb tiktoken langchain\_community langchain\_chroma
aqui comparto el codigo para contar y admistrar los tokens : import tiktoken # type: ignore \# Cargar el modelo específico, por ejemplo, GPT-3 o GPT-4enc = tiktoken.encoding\_for\_model("gpt-3.5-turbo") \# Texto de ejemplotexto = "Este es un ejemplo de texto para contar tokens. por que contar es lo mqjoer del mundo" \# Contar los tokenstokens = enc.encode(texto) print(f"El número de tokens es: {len(tokens)}")
companeros , me aparece este error corriendo , al cargar lospdf ModuleNotFoundError Traceback (most recent call last) [/usr/local/lib/python3.10/dist-packages/langchain/\_api/module\_import.py](https://localhost:8080/#) in import\_by\_name(name) 68 try: \---> 69 module = importlib.import\_module(new\_module) 70 except ModuleNotFoundError as e:
me sale este error como puedo solucionarlo
**Al correr esto** from langchain.text\_splitter import RecursiveCharacterTextSplitter text\_splitter = RecursiveCharacterTextSplitter(    chunk\_size=1200,    chunk\_overlap=200,    length\_function=len   ) documents = text\_splitter.split\_documents(ml\_papers) **me sale estos errores, alguien me podria decir por que es ?** AttributeError Traceback (most recent call last) [\<ipython-input-26-4592e76b0b35>](https://localhost:8080/#) in \<cell line: 9>() 7 ) 8 print('paso') \----> 9 documents = text\_splitter.split\_documents(ml\_papers) [/usr/local/lib/python3.10/dist-packages/langchain/text\_splitter.py](https://localhost:8080/#) in split\_documents(self, documents) 158 texts, metadatas = \[], \[] 159 for doc in documents: \--> 160 texts.append(doc.page\_content) 161 metadatas.append(doc.metadata) 162 return self.create\_documents(texts, metadatas=metadatas) AttributeError: 'list' object has no attribute 'page\_content'

Y si yo quiero entrenar a mi modelo con la información de una sitio web, (texto) y no poseo esa información en PDF, como puedo hacerlo ???

A diciembre del 2023, esto responde chatGPT.

User
qué es fingpt?
ChatGPT
Hasta mi última actualización de conocimientos en enero de 2022, no tengo información específica sobre “fingpt”. Puede que sea un término específico o una referencia a un proyecto o tecnología que haya surgido después de esa fecha, o podría ser un error tipográfico.

Woow increíble
Hola, ¿Soy el único que no puede cargar los Recursos del curso?
Hola, el código en los recursos de la clase.

Empezó con todo esto!

ya quiero saber mas al respecto de este tema 😮