Introducción a LangChain

1

Desarrollo de aplicaciones con LLM utilizando LangChain

2

Estructura y módulos de LangChain

3

Uso de modelos Open Source de Hugging Face

4

Uso de modelos de OpenAI API

5

Prompt templates de LangChain

6

Cadenas en LangChain

7

Utility chains

8

RetrievalQA chain

9

Foundational chains

Quiz: Introducción a LangChain

Casos de uso de LangChain

10

Casos de uso de LangChain

11

¿Cómo utilizar LangChain en mi equipo?

Quiz: Casos de uso de LangChain

Manejo de documentos con índices

12

¿Cómo manejar documentos con índices en LangChain?

13

La clase Document

14

Document Loaders: PDF

15

Document Loaders: CSV con Pandas DataFrames

16

Document Loaders: JSONL

17

Document Transformers: TextSplitters

18

Proyecto de Chatbot: configuración de entorno para LangChain y obtención de datos

19

Proyecto de Chatbot: creación de documents de Hugging Face

Quiz: Manejo de documentos con índices

Embeddings y bases de datos vectoriales

20

Uso de embeddings y bases de datos vectoriales con LangChain

21

¿Cómo usar embeddings de OpenAI en LangChain?

22

¿Cómo usar embeddings de Hugging Face en LangChaing?

23

Chroma vector store en LangChain

24

Proyecto de Chatbot: ingesta de documents en Chroma

25

RetrievalQA: cadena para preguntar

26

Proyecto de Chatbot: cadena de conversación

27

Proyecto de Chatbot: RetrievalQA chain

Quiz: Embeddings y bases de datos vectoriales

Chats y memoria con LangChain

28

¿Para qué sirve la memoria en cadenas y chats?

29

Uso de modelos de chat con LangChain

30

Chat prompt templates

31

ConversationBufferMemory

32

ConversationBufferWindowMemory

33

ConversationSummaryMemory

34

ConversationSummaryBufferMemory

35

Entity memory

36

Proyecto de Chatbot: chat history con ConversationalRetrievalChain

Quiz: Chats y memoria con LangChain

Evolución del uso de LLM

37

LangChain y LLM en evolución constante

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

Document Loaders: JSONL

16/37
Recursos

¿Cómo crear un cargador de JSON Lines en LangChain?

¿Alguna vez has enfrentado la necesidad de manejar formatos de datos que no son compatibles directamente con las herramientas que estás usando? En el mundo de la ciencia de datos y la programación, esto es más común de lo que podrías pensar. A través de este artículo, aprenderás a crear un cargador de datos que te permita manejar archivos JSON Lines, un formato aún no soportado por LangChain. Esta implementación te dará el control para personalizar cómo se cargan y gestionar los datos.

¿Qué son los JSON Lines y cómo funcionan?

JSON Lines es un formato de datos en el que cada línea es un registro JSON independiente. Esto permite trabajar de manera eficiente con grandes volúmenes de datos, ya que se pueden procesar línea por línea sin cargar todo el archivo en memoria.

  • Ventajas de JSON Lines:
    • Fácil de trabajar tanto para humanos como para máquinas.
    • Permite el procesamiento incremental de registros.
    • Ideal para flujos de datos que se transmiten en tiempo real.

Para comenzar a trabajar con JSON Lines, necesitarás instalar una librería que te permita manejarlos en Python:

pip install jsonlines

¿Cómo se crea un cargador específico?

Para esta tarea, crearemos una clase en Python que le proporcionará a LangChain la funcionalidad necesaria para manejar archivos JSON Lines. Así, podrás cargar, manipular y almacenar datos de manera personalizada según tus necesidades.

Paso a paso para crear un cargador de JSON Lines

  1. Inicializa tu clase: Inicia con la creación de una clase en Python para manejar esta tarea.
class JSONLLoader:
    def __init__(self, filepath: str):
        self.filepath = filepath
  1. Función para cargar datos: Define la función load para leer los datos y transformarlos en una lista de documentos.
from typing import List
from esquema import Document
import jsonlines

    def load(self) -> List[Document]:
        with jsonlines.open(self.filepath) as reader:
            documents = []
            for obj in reader:
                page_content = obj.get('text', '')
                metadata = {
                    'title': obj.get('title', None),
                    'repo_owner': obj.get('repo_owner', None),
                    'repo_name': obj.get('repo_name', None),
                }
                documents.append(Document(page_content=page_content, metadata=metadata))
            return documents
  1. Manejo de errores y personalización: Asegúrate de manejar errores y personalizar el formato de los metadatos según tus necesidades. Este código proporciona una estructura básica, pero puedes modificarlo para capturar más información o diseñar otras funcionalidades.

  2. Uso del cargador: Una vez que tu cargador esté listo, úsalo para procesar tus datos.

loader = JSONLLoader('ruta/al/archivo.jsonl')
datos = loader.load()

for doc in datos:
    print(doc)

¿Cuáles son los beneficios de personalizar tu propio cargador?

Crear tu propio cargador de datos tiene muchas ventajas. No solo puedes adaptar el proceso para ajustarse perfectamente a tus requisitos, sino que también puedes expandir las capacidades de las herramientas existentes como LangChain. Esto es especialmente útil cuando trabajas con formatos de datos no estándar o quieres garantizar que los metadatos se almacenen de una manera específica. Además, desarrollar estas habilidades te permite integrarte mejor en contextos profesionales donde los datos y su manipulación son parte esencial de las operaciones diarias.

La magia de la programación recae en que puedes moldear tus herramientas para satisfacer exactamente tus necesidades, y esta guía te brinda el conocimiento para hacerlo con confianza.

Aportes 6

Preguntas 0

Ordenar por:

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

Les dejo por aquí una estructura que estoy probando para un archivo de excel en la que previamente depuramos cierta data que queremos que exista en una base vectorial, me encantaría recibir feedback:

from langchain.schema import Document
from typing import List
import pandas as pd

class TransformerExcelLoader:
    
    def __init__(self, file_path: str):
        self.file_path = file_path
    
    def load(self) -> List[Document]:
        data = pd.read_excel(self.file_path)
        documents = []

        # Reemplazar valores NaN con cadenas vacías
        data.fillna("", inplace=True)

        for _, fila in data.iterrows():
            if fila["FUENTE"] == "":
                page_content = "RESPUESTA " + fila["RESPUESTA"]
            else:
                # Usar str.cat() para concatenar cadenas eficientemente
                page_content = "RESPUESTA: " + fila["RESPUESTA"] + " FUENTE: " + fila["FUENTE"]

            metadata = {
                'empresa': fila["EMPRESA"],
                'area': fila["AREA"],
                'topico': fila["TOPICO"],
                'pregunta': fila["PREGUNTA"],
                'contexto': fila["CONTEXTO"]
            }

            documents.append(Document(page_content=page_content, metadata=metadata))
            
        return documents

Posdata: Se que hice algo de hardcoded colocando los nombres de las variables pero es una estrcutra que no esperamos cambiar en el corto plazo…

Hoy en día ya contamos con loaders de JSONL, aquí dejo el link de la doc en langchain: <https://python.langchain.com/docs/modules/data_connection/document_loaders/json#json-lines-file>

Dejo un ejemplo usando el loader de LangChaing y se obtiene un resultado muy similar.

# !pip install jq
from langchain.document_loaders import JSONLoader

# Define the metadata extraction function.
def metadata_func(record: dict, metadata: dict) -> dict:

    metadata["title"] = record.get("title", "")
    metadata["repo_owner"] = record.get("timestamp_ms", "")
    metadata["repo_name"] = record.get("repo_name", "")

    return metadata

loader = JSONLoader(
    file_path='transformers_docs.jsonl',
    jq_schema='.',
    content_key='text',
    json_lines=True,
    metadata_func=metadata_func
    )

data = loader.load()
a Jan 2025 Acá la doc actualizada de JSON Loaders <https://python.langchain.com/docs/integrations/document_loaders/json/>
`from langchain_core.documents import Documentfrom langchain_core.document_loaders import BaseLoader` `class CustomDictLoader(BaseLoader):    def __init__(self, data):        self.data = data    def load(self):        documents = convert_dict_to_documents(self.data)        return [Document(page_content=doc['text'], metadata={"source": doc['metadata']}) for doc in documents]` Yo cree mi propio loader de un diccionario que dentro tiene otros diccionarios, es interesante poder adaptar los loaders a cualquier caso de uso
Es super poderoso esto, ya no podemos tener un block con respecto a la fuente de datos.