Document Loaders: JSONL

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()

`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.