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

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de LangChain

Curso de LangChain

Omar Espejel

Omar Espejel

Creación de Índice Vectorial con Langchain y Embeddings

19/37
Recursos

¿Cómo se crea un índice de Chroma a partir de documentos JSON-L?

Comenzar con un proyecto de indexación de documentos puede parecer una tarea compleja, pero con las herramientas adecuadas, se puede simplificar en gran medida. La meta es transformar una base de datos JSON-L en un índice de Chroma que pueda procesar consultas de usuario de manera eficiente. ¡Veamos cómo hacerlo!

¿Cómo preparar los documentos?

En primer lugar, es esencial tener un ambiente de programación listo y la base de datos, en este caso, un archivo JSON-L. Nuestro primer paso es convertir este archivo en un formato que Langchain pueda procesar.

  • Conversión a formato Langchain: Esto se logra mediante una función de Python que cargue los documentos desde un path especificado. Supongamos que llamamos a esta función loadDocuments. Esta función utiliza docs.json.lloader para convertir cada línea del JSON-L en un document de Langchain.
def loadDocuments(filePath):
    from utils import docs.json.loader
    loader = docs.json.loader(filePath)
    data = loader.load()
    return data

¿Cómo dividir los documentos?

Una vez que los documentos están en formato adecuado, es necesario dividirlos en fragmentos más pequeños. Esto se hace para que puedan ser procesados por embeddings, que convertirán los documentos en números.

  • Uso de un text splitter: Utilizamos recursive character text splitter de Langchain. Este nos permite establecer un chunk_size adecuado, que para embeddings grandes como los de OpenAI puede ser de 1600 caracteres.
from langchain.textsplitters import recursive_character_text_splitter

text_splitter = recursive_character_text_splitter(chunk_size=1600, chunk_overlap=160)
split_documents = text_splitter.split_documents(data)

¿Cómo obtener el path correcto de los documentos?

Para facilitar el proceso, podemos definir una función que obtenga automáticamente el path correcto hacia nuestros documentos. Esta puede ser una función simple de utils, por ejemplo, getFilePath.

from utils import getFilePath

file_path = getFilePath()
print("Path to documents:", file_path)

¿Cómo verificar el proceso?

Es importante verificar cuántos fragmentos de documentos tenemos y cómo se ve uno en detalle. Esto nos ayuda a entender que el proceso de división se ha llevado a cabo correctamente.

def main():
    # Cargar y dividir documentos
    documents = loadDocuments(getFilePath())
    split_documents = split_documents(documents)

    # Imprimir resultados
    print("Número total de documentos:", len(split_documents))
    print("Primer documento:", split_documents[0])

A través de estos pasos, pasamos de tener un archivo JSON-L grande a más de 1800 fragmentos de documentos, cada uno con información clave como el contenido de la página y metadatos sobre el creador y el repositorio asociado. Este proceso nos prepara para la próxima etapa que incluye la conversión de esos documentos en embeddings y su almacenamiento en una base de datos vectorial como Chroma.

¿Está todo listo? ¡Es hora de seguir explorando y avanzar hacia la creación de un modelo de chat efectivo!

Aportes 4

Preguntas 0

Ordenar por:

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

Les muestro cual serīa el código para cargar los datos usando la clase JSONLoader de langchain.

<code> 
from langchain.document_loaders import JSONLoader  # importar clase
from langchain.text_splitter import RecursiveCharacterTextSplitter

from utils import get_file_path


# funcion metadata para retornar title, repo_owner, repo_name en la metadata del documento
def metadata_func(record: dict, metadata: dict) -> dict:
    metadata["title"] = record.get("title")
    metadata["repo_owner"] = record.get("repo_owner")
    metadata["repo_name"] = record.get("repo_name")

    return metadata


def load_documents(path):
    loader = JSONLoader(
        path,
        json_lines=True,  # indica que el archivo es un jsonl
        jq_schema=".",  # indica que el jsonl tiene un solo elemento por linea, más info en https://python.langchain.com/docs/modules/data_connection/document_loaders/json#common-json-structures-with-jq-schema
        content_key="text",  # indica que el contenido del documento está en la llave "text"
        metadata_func=metadata_func,  # indica que la función metadata_func se usará para obtener la metadata del documento
    )
    data = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1600, length_function=len, chunk_overlap=160
    )

    return text_splitter.split_documents(data)

y así quedaría un Documento:

**A Enero 2025:** Si hicieron una descarga recientemente, para que conversation\_ai funcione deben cambiar el path en con **config.yaml** En mi caso `jsonl_database_path: data/docs_en_2025_01_10.jsonl`
Para hacer split con tokens ```js def load_documents(file_path: str): loader = DocsJSONLLoader(file_path) data = loader.load() print(f"Documents loaded: {len(data)}") # Split by tokens text_splitter_recursive = RecursiveCharacterTextSplitter.from_tiktoken_encoder( model_name="gpt-4", chunk_size=500, chunk_overlap=50, ) return text_splitter_recursive.split_documents(data) ```def load\_documents(file\_path: str): loader = DocsJSONLLoader(file\_path) data = loader.load() print(f"Documents loaded: {len(data)}") \# Split by tokens text\_splitter\_recursive = RecursiveCharacterTextSplitter.from\_tiktoken\_encoder( model\_name="gpt-4", chunk\_size=500, chunk\_overlap=50, ) return text\_splitter\_recursive.split\_documents(data)
Excelente, cada ves se aterriza más lo que podemos hacer apps con esto, esta supremo este curso.