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

Chroma vector store en LangChain

23/37
Recursos

Aportes 4

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Listo, reto realizado. Utilic茅 el modelo:

embeddings_st = SentenceTransformerEmbeddings(
    model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
)

Con un archivo de texto convertido desde un PDF de 100 hojas, el problema que encuentro es que al hacer la pregunta no es nada acertado con ese modelo utilizado, pero creo que se puede mejorar ya que ya lo hab铆a probado con el de Open AI y va de maravilla.

Si alguien tiene una duda de como lo hice pueden escrbirme.

primer comentario

Les comparto el c贸digo formateado de una forma m谩s 鈥減ythonica鈥 y menos 鈥渃olab鈥.

Primero instalamos las biliotecas necesarias:

pip install langchain
pip install pypdf
pip install InstructorEmbedding 
pip instal sentence_transformers
pip install chromadb

Ahora el c贸digo documentado por m铆

import requests
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.vectorstores import Chroma


def download_pdf_file():
    url = 'https://www.cs.virginia.edu/~evans/greatworks/diffie.pdf'
    response = requests.get(url)

    with open('public_key_cryptography.pdf', 'wb') as f:
        f.write(response.content)
    print("documento descargado")


def load_pdf_file():
    loader = PyPDFLoader("./public_key_cryptography.pdf")
    data = loader.load()
    print("documento cargado")
    return data


def generate_document(data, chunk_size, overlap, function):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=overlap,
        length_function=function,
    )
    documents = text_splitter.split_documents(data)
    print(documents[0].page_content)
    return documents


def instantiate_embedding_model(model, device):
    # A junio de 2023 no hay modelos Instruct para espa帽ol
    embedding_instruct = HuggingFaceInstructEmbeddings(
        model_name=model,
        model_kwargs={"device": device}
    )
    print("Tipo de Embedding:")
    print(type(embedding_instruct))
    return embedding_instruct


def generate_vectorstore(documents, embedding_instruct, vectorstore_name):
    vectorstore_chroma = Chroma.from_documents(
        documents=documents,
        embedding=embedding_instruct,
        persist_directory=vectorstore_name
    )
    print("Vector Store generado")
    return vectorstore_chroma


def save_vectorstore(vectorstore):
    vectorstore.persist()
    print("Vector store almacenado con 茅xito")


def load_vectorstore(vectorstore_name, embedding_instruct):
    vectorstore_chroma = Chroma(
        persist_directory=vectorstore_name,
        embedding_function=embedding_instruct
    )
    print("Vector Store cargado")
    return vectorstore_chroma


if __name__ == '__main__':
    # Primer paso: Descargar el documento PDF que queremos analizar
    download_pdf_file()
    # Ahora lo cargamos con un Loader que se adapte al tipo de archivo
    data = load_pdf_file()
    # Generamos un Document con una partici贸n de 500 car谩cteres y un overlap del 10%
    documents = generate_document(data, chunk_size=500, overlap=50, function=len)
    # Si es la primera vez que se instancia el modelo entonces este se va a descargar y se va a cargar en el device CUDA
    embedding_model = instantiate_embedding_model(model="hkunlp/instructor-large", device="cuda")
    # Ya teniendo el modelo de embedding entonces podemos generar el Vector Store, le asignamos el siguiente nombre:
    vectorstore_name = "instruct-embeddings-public-crypto"
    # Y lo vamos a generar con la informaci贸n de `Documents` utilizando el modelo `embedding_model` y nombre 
    # `vectorstore_name`
    vectorstore = generate_vectorstore(documents, embedding_model, vectorstore_name)
    # Guardamos el modelo en disco
    save_vectorstore(vectorstore)
    # Cargamos el modelo para trabajar con 茅l
    vectorstore_loaded = load_vectorstore(vectorstore_name, embedding_model)
    # Vamos a hacer una petici贸n que dada la siguiente pregunta obtenga 5 Chunks con informaci贸n similar
    query = "What is public key cryptography?"
    docs = vectorstore_loaded.similarity_search_with_score(query, k=5)
    # Veamos cuantos documentos gener贸 y un ejemplo del mismo
    print(len(docs))
    print(docs[3])

Si alguien quiere leer de manera m谩s potable las respuestas del vectorstore, pueden usar este script al final para ver las respuestas, el contenido y el score:

contents  = ([x[0].page_content for x in docs])
score = [x[1] for x in docs]
for count, i in enumerate(contents):
  print(f"answer {count+1}:")
  print(i)
  print(f"score: {score[count]}\n")

Ver谩n algo as铆

answer 1:
public key and substitute one for a public key they have 
manufactured themselves and whose corresponding secret 
key is therefore known to them. This will enable them to 
decrypt any message that Alice sends to Bob. If such a mis- 
DIFFIE: TEN YEARS OF PUBLIC-KEY CRYPTOGRAPHY 567
score: 0.2250361144542694