No tienes acceso a esta clase

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

VectorStore: Chroma

18/26
Recursos

Un VectorStore es una estructura diseñada para almacenar y gestionar vectores de texto, también conocidos como embeddings. Los embeddings son representaciones numéricas de fragmentos de texto que capturan su significado semántico, permitiendo que los textos con significados similares tengan vectores cercanos entre sí en un espacio vectorial. Esta capacidad es esencial para realizar búsquedas semánticas basadas en similitud, lo que facilita la recuperación de información relevante.

¿Cómo Funciona un VectorStore?

  1. Generación de Embeddings: Primero, el texto se convierte en un vector mediante un modelo de embeddings, como los que ofrece OpenAI o HuggingFace.
  2. Almacenamiento de Vectores: Estos vectores, junto con metadatos (como el origen del documento o la categoría), se almacenan en un VectorStore.
  3. Consulta y Búsqueda: Cuando se recibe una nueva consulta (query), esta también se transforma en un vector y se compara con los vectores ya almacenados para encontrar aquellos que sean más cercanos en significado.

Chroma: Un VectorStore Open Source

En esta clase exploramos Chroma, una tecnología open source que permite gestionar bases vectoriales. La integración entre LangChain y Chroma facilita la creación y manejo de estas bases. Con Chroma, puedes almacenar y buscar vectores creados a partir de texto, ya sea de archivos CSV, PDF, HTML o incluso entradas directas como comentarios en redes sociales.

Flujo de Trabajo de un VectorStore con Embeddings

  1. Transformación del Texto: El texto se convierte en un vector utilizando un modelo de embeddings.
  2. Almacenamiento: Los vectores generados, junto con su metadata (como fuente, categoría o ID), se almacenan en una colección dentro de la base vectorial.
  3. Búsqueda por Similitud: Cuando realizamos una búsqueda, el texto de la consulta se convierte en un vector y se compara con los vectores almacenados en la base. Los resultados son los vectores más cercanos, según la métrica de similitud.

Creación de la Base Vectorial en Chroma

  1. Instalación: La instalación de Chroma es simple, se realiza a través de pip install chromadb.
  2. Integración con LangChain: Chroma se integra con LangChain para permitir la gestión de los vectores. En LangChain, puedes utilizar modelos como OpenAI para generar embeddings y luego almacenar esos vectores en una base creada con Chroma.
  3. Documentos y Metadatos: Los documentos se convierten en embeddings y se almacenan con metadatos adicionales que ayudan a identificar y filtrar la información durante las búsquedas.

Ejemplo Práctico

Un caso de uso que exploramos es el almacenamiento de comentarios de redes sociales (por ejemplo, tweets) en una base vectorial. Cada comentario se convierte en un vector, y se le asigna metadata como la fuente (Twitter) y un ID único. Esto nos permite posteriormente realizar búsquedas entre estos comentarios, recuperando aquellos que son semánticamente similares a una nueva consulta.

Por ejemplo, si tenemos una base vectorial con comentarios relacionados a LangChain, cuando un usuario ingresa una consulta sobre “Large Language Models”, la búsqueda devolverá los comentarios más cercanos en significado, mostrando aquellos que mencionan temas relacionados, como “LangChain” o “Language Models”.

Búsqueda por Similitud en Chroma

La búsqueda por similitud en un VectorStore de Chroma sigue estos pasos:

  1. Query: El usuario ingresa una consulta en formato de texto.
  2. Conversión a Vector: La consulta se transforma en un vector utilizando el mismo modelo de embeddings que se usó para los documentos.
  3. Búsqueda en la Base Vectorial: El sistema compara el vector de la consulta con los vectores almacenados y recupera los más cercanos en función de su similitud.
  4. Filtrado por Metadata: Puedes aplicar filtros para restringir la búsqueda a ciertos tipos de documentos o fuentes, como comentarios de Twitter o posts de Facebook.

Beneficios de Utilizar Chroma con LangChain

  • Open Source: Chroma es una solución de código abierto que permite gestionar bases vectoriales sin depender de servicios pagos.
  • Versatilidad: Puedes almacenar y buscar vectores generados a partir de múltiples tipos de datos, incluyendo archivos CSV, PDFs, HTML, y más.
  • Búsqueda Semántica: Al trabajar con embeddings, las búsquedas no se limitan a palabras clave exactas, sino que buscan similitudes en el significado, proporcionando resultados más relevantes.
  • Facilidad de Integración: LangChain facilita la integración con Chroma, lo que simplifica el proceso de crear y gestionar bases vectoriales.

Aportes 6

Preguntas 5

Ordenar por:

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

Por favor corregir los links, tanto del notebook, como de la documentación para poder seguir el ejercicio
Script que lee un csv ```python import os import csv from langchain.docstore.document import Document from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_community.vectorstores import Chroma from langchain_openai import OpenAIEmbeddings # Asegúrate de configurar tu API key de OpenAI #os.environ["OPENAI_API_KEY"] = "tu-api-key-aquí" def find_file(filename, search_path): for root, dirs, files in os.walk(search_path): if filename in files: return os.path.join(root, filename) return None def custom_csv_loader(file_path): documents = [] with open(file_path, 'r', encoding='utf-8') as csvfile: reader = csv.reader(csvfile) headers = next(reader) # Get the headers for row in reader: # Create a string representation of the row content_parts = [] for i, value in enumerate(row): cleaned_value = value.strip().strip('=').strip('"') content_parts.append("{}: {}".format(headers[i], cleaned_value)) content = ", ".join(content_parts) metadata = {"source": file_path} documents.append(Document(page_content=content, metadata=metadata)) return documents def load_and_split_document(file_path): _, file_extension = os.path.splitext(file_path) if file_extension.lower() == '.csv': documents = custom_csv_loader(file_path) else: raise ValueError("Tipo de archivo no soportado. Use CSV.") text_splitter = RecursiveCharacterTextSplitter( chunk_size=1000, chunk_overlap=200, length_function=len ) chunks = text_splitter.split_documents(documents) return chunks def create_vector_store(chunks): embeddings = OpenAIEmbeddings() vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db") return vectorstore def main(): current_dir = os.getcwd() print("Directorio actual: {}".format(current_dir)) file_name = "books.csv" file_path = find_file(file_name, current_dir) if file_path is None: print("No se pudo encontrar el archivo {} en el directorio actual o sus subdirectorios.".format(file_name)) return print("Archivo encontrado: {}".format(file_path)) try: chunks = load_and_split_document(file_path) print("Documento dividido en {} chunks.".format(len(chunks))) vectorstore = create_vector_store(chunks) print("Base de datos vectorial creada y poblada.") query = "Menciona un libro de ciencia ficción" results = vectorstore.similarity_search(query) print("\nResultados para la consulta '{}':".format(query)) for doc in results: print(doc.page_content[:200] + "...") except Exception as e: print("Ocurrió un error: {}".format(str(e))) if __name__ == "__main__": main() ```
### ¿Qué es un VectorStore? En el contexto de LangChain, un **VectorStore** es una base de datos especializada diseñada para almacenar y recuperar vectores numéricos. Estos vectores, como ya hemos visto, son representaciones numéricas de textos, imágenes, o cualquier otro tipo de dato que pueda ser codificado en un espacio vectorial. Un VectorStore es crucial para: * **Búsqueda Semántica:** Permite buscar información basada en el significado en lugar de coincidencia exacta de palabras clave. * **Recuperación de Información:** Ayuda a encontrar documentos relevantes en grandes conjuntos de datos. * **Recomendaciones:** Puede sugerir elementos similares a los que el usuario ha interactuado previamente. ### ¿Por qué Chroma? **Chroma** es una de las opciones más populares para crear VectorStores en LangChain. Ofrece una serie de ventajas: * **Rendimiento:** Está optimizado para realizar búsquedas de similitud en grandes conjuntos de vectores de manera eficiente. * **Flexibilidad:** Permite almacenar diferentes tipos de datos y ofrece múltiples opciones de indexación. * **Integración con LangChain:** Se integra de manera nativa con LangChain, facilitando su uso en proyectos de procesamiento de lenguaje natural. * **Escalabilidad:** Puede manejar grandes volúmenes de datos y escalar fácilmente para adaptarse a las necesidades crecientes. ### ¿Cómo funciona Chroma en LangChain? 1. **Creación del VectorStore:** Se crea una instancia de Chroma y se configura con los parámetros necesarios. 2. **Adición de Vectores:** Los vectores, junto con su metadata (por ejemplo, el texto original), se añaden al VectorStore. 3. **Búsqueda:** Cuando se realiza una búsqueda, se convierte la consulta en un vector y se busca los vectores más cercanos en el VectorStore. 4. **Recuperación de Información:** Se recuperan los documentos asociados a los vectores más cercanos, que son los más relevantes para la consulta. **Ejemplo básico:** Python`from langchain.vectorstores import` Chroma `from langchain.embeddings import` OpenAIEmbeddings `# Crear embeddings` embeddings = OpenAIEmbeddings() `# Crear un VectorStore` vectordb = Chroma.from\_documents( ` documents, embeddings, collection_name="my_collection"` ) `# Realizar una búsqueda` `docs = vectordb.similarity_search("What is the meaning of life?"`) Usa el código [con precaución](/faq#coding). ### Casos de Uso * **Chatbots:** Para encontrar respuestas relevantes a preguntas de los usuarios. * **Sistemas de Recomendación:** Para sugerir productos, películas o noticias basadas en las preferencias del usuario. * **Búsqueda Semántica:** Para buscar información en grandes bases de datos de texto. * **Resumen Automático:** Para identificar las partes más relevantes de un documento. ### Conclusiones Chroma es una herramienta poderosa y flexible para crear VectorStores en LangChain. Al permitir la búsqueda semántica y la recuperación de información basada en similitud, abre un mundo de posibilidades para aplicaciones de procesamiento de lenguaje natural.
Por que, usaste esta opción para inicializar la base de datos \----------- import chromadb persistent\_client = chromadb.PersistentClient() collection = persistent\_client.get\_or\_create\_collection("collection\_name") collection.add(ids=\["1", "2", "3"], documents=\["a", "b", "c"]) vector\_store\_from\_client = Chroma( client=persistent\_client, collection\_name="collection\_name", embedding\_function=embeddings, ) \-------------------------------- Estaba mirando documentación y algunos dicen que es adecuado tener Id para realizar las funciones básicas de una DB
Se me ocurre que podría hace un Embbeding con mis notas en Obsidian y cargarlo en un modelo para hacer una versión virtual de mi mismo 😆
No permitio guardar la salida del script ni en formato ong, ni en texto plano. Sale error acá.